Breakpoint 2024: Product Keynote: Efficient Solana Programs

Solana takes a giant leap towards Google-scale blockchain performance with the announcement of Peregrine, a groundbreaking framework for efficient on-chain programs. This development, unveiled at Breakpoint 2024, marks a pivotal shift in Solana's journey to become the world's fastest and most scalable blockchain.

Summary

Kevin Poole, representing Temporal, a new alternative firm, delivered a keynote speech at Breakpoint 2024, focusing on the evolution of Solana's performance and the introduction of new tools to enhance its efficiency. The presentation highlighted the network's shift from feature addition to performance and robustness improvements over recent years.

Poole discussed various optimizations across different layers of the Solana ecosystem, including advancements in networking protocols, packet ingestion, and runtime improvements. He emphasized the critical need for efficient on-chain programs to fully realize Solana's potential as a high-performance blockchain.

The keynote's climax was the announcement of Peregrine, a new framework designed to create highly efficient Solana programs. Peregrine addresses inefficiencies in current tooling and promises to dramatically reduce executable size and improve performance. Poole also introduced the Solana Program Cave, a collection of simple programs demonstrating these new techniques.

Key Points:

Network and Client Improvements

Solana has seen significant improvements in its network layer and client implementations. The migration from UDP to QUIC for packet ingestion has been a key development, with ongoing optimizations to enhance this further. Temporal is actively researching and developing a new networking protocol to accelerate packet ingestion even more.

Quality of Service (QoS) has been another focus area, with Temporal demonstrating their P0QS system working at an impressive 1.4 million TPS per core. This advancement is crucial for handling the increasing packet volume on the Solana network.

On the client side, implementations like Firedancer with its AVX-512 optimizations for vote verification have shown the potential for independent, high-performance clients. The introduction of a new scheduler in version 1.18 was also highlighted as a significant step forward in improving Solana's overall performance.

Runtime and VM Enhancements

Poole discussed ongoing work on direct account mapping in the Solana runtime, acknowledging that while progress has been made, there's still room for improvement. A new Cindy implementation is set to reduce the data transfer between the VM and other programs, further optimizing performance.

The transition point where the VM invokes on-chain program entry points was identified as a critical juncture. This is where code not written or selected by core developers begins to execute, highlighting the importance of efficient on-chain programs for overall network performance.

Introduction of Peregrine Framework

The keynote's main announcement was Peregrine, a new framework for creating efficient Solana programs. Peregrine addresses inefficiencies in current tooling, including the compiler, core abstractions, and program frameworks. Key features of Peregrine include:

• Zero-copy handling of instruction and account data
• Separation of validation and execution, maintaining familiar developer patterns
• Use of native Rust, avoiding problematic macros or BPF assembly
• Significant reduction in executable size compared to SPL and Anchor programs
• Dramatic improvement in performance, demonstrated by a token program implementation

Poole showcased a token program written with Peregrine that achieved a 3x reduction in executable size compared to SPL and a 4x reduction compared to a blank Anchor program. This program uses 100 times less compute budget per transfer and can process 54,000 transfers per second on a single core, even with current VM overhead.

Solana Program Cave

In addition to Peregrine, Poole announced the Solana Program Cave, a collection of simple programs demonstrating the efficient techniques enabled by the new framework. This resource is intended to provide developers with examples and inspiration for creating high-performance Solana programs.

Facts + Figures

• Temporal's P0QS system demonstrated 1.4 million TPS per core
• Peregrine-based token program reduces executable size by factor of 3 compared to SPL
• The Peregrine token program uses 100 times less compute budget per transfer
• Peregrine token program achieves 54,000 transfers per second on a single core
• Potential for 432,000 transfers per second with 8-16 execution threads
• Migration from UDP to QUIC for packet ingestion has improved network performance
• Solana version 1.18 introduced a new scheduler for better performance
• Direct account mapping in the runtime is an ongoing area of improvement
• A new Cindy implementation will reduce data transfer between VM and other programs

Top quotes

1. "It is now time to make performance the top priority."
2. "If we execute in a few years, we can almost sit back and bask in the glory and admire the beauty of the symphony of silicon that we call Solana."
3. "We will not realize the vision of Solana as a blockchain for Google scale [without efficient on-chain programs]."
4. "This is the future that I want for Solana. And if we actually do it, right, this is a shared mission."
5. "A lot of the programs on mainnet inherit inefficiencies from the current tooling."

Questions Answered

What is Peregrine and why is it important for Solana?

Peregrine is a new framework for creating efficient Solana programs. It's important because it addresses inefficiencies in current tooling and allows developers to write performant, readable, and maintainable code in Rust. Peregrine significantly reduces executable size and improves performance, which is crucial for realizing Solana's vision as a high-performance blockchain capable of Google-scale operations.

How does Peregrine improve upon existing Solana development frameworks?

Peregrine improves upon existing frameworks by reducing executable size, using zero-copy handling of instruction and account data, and maintaining familiar developer patterns like separation of validation and execution. It achieves this without relying on problematic macros or BPF assembly, instead using native Rust. In practical terms, a token program written with Peregrine showed a 3x reduction in size compared to SPL and used 100 times less compute budget per transfer.

What recent improvements have been made to Solana's network layer?

Solana's network layer has seen several improvements, including the migration from UDP to QUIC for packet ingestion. Temporal is also working on developing a new networking protocol to further accelerate packet ingestion. Additionally, Quality of Service (QoS) improvements have been made, with Temporal's P0QS system demonstrating capabilities of 1.4 million TPS per core.

What is the Solana Program Cave?

The Solana Program Cave is a collection of simple programs that demonstrate the efficient techniques enabled by the Peregrine framework. It serves as a resource for developers to learn and implement high-performance practices in their Solana programs. The Program Cave includes examples of previously unseen parameters on Solana, showcasing the potential of the new framework.

How does Peregrine address the challenge of inefficient on-chain programs?

Peregrine addresses the challenge of inefficient on-chain programs by providing a framework that eliminates unnecessary code injected by current tooling, including the compiler, core abstractions, and program frameworks. It allows developers to write efficient code directly in Rust, resulting in smaller executables and significantly improved performance. This is crucial because inefficient on-chain programs can bottleneck the entire Solana network, even with optimized clients and network layers.