Solayer 백서

Solayer

원문

bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 2쪽 중 1쪽

SOLAYER CHAIN : Infinitely Scalable Hardware-Accelerated SVM Network Jason Li, Chaofan Shou, Qi Su, Chaz Cui, and Tony Ke (lxj,shou,changzecui)@berkeley.edu, qisu@cs.ucsb.edu, yuanyu.ke@link.cuhk.edu.hk January 7, 2025 Abstract We introduce S OLAYER CHAIN , a next-generation blockchain architecture that scales a single, global state machine to achieve unprecedented throughput, low latency, and robust composability. Unlike conventional vertical scaling or sharded rollups, S OLAYER CHAIN maintains atomic state transitions by distributing the workload a cross microservices and spe- cialized hardware accelerators. It offloads signature checks, transaction filtering, pre-execution simulation, scheduling, and storage to distinct scalable clusters, each optimized for its func- tion. Transactions are speculatively executed before reaching the sequencer, then finalized through a hybrid Proof-of-Authority-and-Stake consensus. The architecture leverages Infini- band RDMA for near-microsecond inter-node communication and advanced concurrency con- trol strategies to minimize re-execution. A shared-nothing key-value store, sharded across multiple nodes, supports arbitrarily large account data with load balancing. S OLAYER CHAIN pushes blockchain performance to hardware limits, targeting 1M+ TPS and 100Gbps+ net- work bandwidth. This design provides a path for next-generation applications that require high throughput, low fees, and a seamless composable environment. S OLAYER CHAIN also introduces multiple user experience improvements. Hooks allow developers to embed post- transaction logic—such as arbitrage, liquidations, and accounting—directly within the chain, while jumbo transactions, cross-chain calls, and built-in OAuth support further enhance devel- oper and user experience. Disclaimer: The information contained in this paper is provided for informational and research purposes only and does not constitute investment advice, financial advice, trading advice, or any other form of advice. The implementation details are subject to change and may differ from what is described here. 1 1 Introduction Blockchain scalability remains a foundational challenge for decentralized systems, as rising trans- action volumes demand faster processing, larger data storage, and robust consensus protocols—all without compromising security or decentralization. High-performance blockchains can reduce transaction times and fees, foster a positive user experience, and open the door to large-scale appli- cations. As the industry matures, the demand for block space continues to increase. On platforms like Ethereum, heightened demand raises gas fees due to fee auctions; on Solana, a flooded network can lead to dropped or expired transactions. Typical metrics such as transactions per second (TPS) shed light on throughput, yet blockchains have grown beyond simple transfers to support Turing- complete smart contracts and complex functionality. Meeting these demands requires rethinking how block space is provisioned and how state is managed. Horizontal scaling approaches, such as Ethereum’s Layer 2 (L2) rollups, move transaction processing off the main chain into separate, independently updated states, posting final results back on L1. While this boosts throughput, it fragments a once-unified global state, weakening composability, atomic state transitions, and liquidity. For instance, if an asset is split across multiple pools on different rollups, a cross-rollup swap can suffer higher slippage relative to a single, unified liquidity pool. Vertical scaling strategies, exemplified by Solana, aim to maximize throughput within a single-state machine by optimizing the virtual machine for parallel execution, writing high-performance software, and running on powerful consumer-grade hardware. This preserves transaction atomicity and streamlines execution, allowing the system to coordinate changes cleanly and maintain composability. Solana’s success in hosting numerous token launches and generating large on-chain trading volumes reflects the power of this design. Despite its advantages, Solana’s approach now encounters inherent hardware limits. To keep pace with current throughput, validators already require CPUs exceeding 3.1 GHz, more than 500 GB of high-speed RAM, and at least 2.5 TB of high-throughput NVMe storage. With CPU utiliza- tion hovering around 30% under heavy load, further gains via software optimization alone are lim- ited. Instead, additional acceleration—such as offloading certain tasks to FPGAs—becomes essen- tial to push performance even higher. Moreover, validators must store and access ever-expanding account data. Standard consumer-grade hardware will inevitably be replaced by specialized so- lutions, like NVMe-oF, for scaling storage without sacrificing low latency. Network bandwidth similarly faces pressure: peer-to-peer (P2P) communication already consumes around 0.8 Gbps per validator, posing a risk of exceeding the 1 Gbps internet limits typical of consumer-grade net- working environments if throughput continues to increase. 2 Figure 1: System architecture To address these emerging bottlenecks, we advocate for a multi-executor, hardware-accelerated SVM network. The design is shown in Figure 1. This design scales a single-state blockchain in- finitely by distributing workload across specialized hardware and clusters while preserving a global atomic state. The following sections outline how this architecture decomposes critical pipeline stages into microservices to scale non-atomic components like ingress and state publishing, hard- ware acceleration for scheduling and locking, a sharded database for scaling storage, and a new hy- brid consensus protocol based on Solana that guarantees both security and low latency. To further increase usability, SOLAYER CHAIN introduces chain-level supports of hooks, cross-chain contract calls, jumbo transactions, seamless wallet support, and OAuth-based signers. Overall, S OLAYER CHAIN aims to become the most user-friendly chain with 1M+ TPS and 100Gbps+ bandwidth. 2 Background In the following subsections, we introduce the background of technology leveraged by S OLAYER CHAIN . 3 2.1 Solana and SVM Solana introduces a novel blockchain architecture that fundamentally departs from traditional con- sensus mechanisms through its proof-of-history (PoH) protocol and parallel execution environ- ment. The SVM employs a shared-nothing architecture where each transaction’s read and write sets are determined prior to execution. This enables the runtime to construct a dependency graph that maximizes parallel execution while maintaining serializability guarantees. Unlike the Ethereum Virtual Machine’s sequential execution model, SVM processes non-conflicting transactions con- currently across available CPU cores. The SVM’s memory model implements a multi-version concurrency control (MVCC) mechanism, maintaining multiple versions of data to support con- current read operations while ensuring write operations maintain strict serialization order based on the PoH sequence. The EVM and SVM exemplify contrasting approaches to concurrency control. The EVM em- ploys optimistic concurrency control, where transactions are processed concurrently under the as- sumption that conflicts will be rare. However, because transactions do not declare their state access upfront, conflicts—such as multiple transactions attempting to modify the same state—are only detected at runtime, requiring rollbacks and retries. In contrast, the SVM adopts pessimistic con- currency control, where transactions must declare their state access patterns upfront. This allows Solana’s Sealevel parallel execution engine to execute non-overlapping transactions concurrently, avoiding conflicts altogether. By combining explicit state access declarations with advanced mem- ory and execution models, Solana achieves unparalleled scalability and efficiency in blockchain processing. 2.2 RDMA and Infiniband Remote Direct Memory Access (RDMA) enables zero-copy data transfer directly between ap- plication memory spaces across network-connected systems. Modern RDMA implementations leverage specialized network interface cards (RNICs) that implement both the transport protocol and direct memory operations in hardware. This architecture bypasses traditional operating system networking stacks, eliminating context switches and CPU overhead associated with network I/O processing. The RDMA protocol suite implements both connection-oriented (Reliable Connected) and connectionless (Unreliable Datagram) transport modes, with the former providing guaranteed in-order delivery and the latter optimizing for low-latency scenarios where applications can tolerate potential packet loss. The protocol’s memory semantics enable remote memory operations to com- plete without interrupting the remote CPU, achieving end-to-end latencies below one microsecond for small messages in optimized deployments. This is achieved through a sophisticated protection model where memory regions must be explicitly registered with the RNIC, which then maintains page tables for direct virtual-to-physical address translation. InfiniBand is a prominent implementation of RDMA, offering a high-speed, low-latency net- working architecture tailored for high-performance computing and data center environments. It utilizes Host Channel Adapters (HCAs) to offload protocol processing and memory translation to 4 hardware, thereby reducing CPU involvement in data transfer operations. InfiniBand supports data transfer rates ranging from 10 Gb/s (Single Data Rate) up to 100 Gb/s per port, using both copper and optical fiber connections. This high bandwidth, combined with ultra-low latencies—as low as 600 nanoseconds end-to-end—makes InfiniBand particularly effective for applications requiring rapid data exchange, such as artificial intelligence and high-performance computing workloads. Its efficiency and scalability have led to widespread adoption in distributed machine learning and other data-intensive applications. 2.3 Software-defined Network Software-defined Networking separates the control plane from the data plane, enabling program- matic control over network behavior through a logically centralized controller. Modern SDN ar- chitectures implement a three-tier model: the data plane consists of programmable forwarding ele- ments that process packets based on match-action rules, the control plane implements network poli- cies and path computation, and the management plane provides high-level network orchestration. The forwarding plane has evolved from fixed-function match-action tables to fully programmable packet processing pipelines through languages like P4, enabling custom protocol implementation and complex packet transformations at line rate. SDN controllers implement distributed consensus protocols to maintain network state consistency across controller replicas, while providing north- bound APIs that abstract network complexity for applications. The forwarding plane typically employs a pipeline architecture where packets traverse multiple match-action stages, with each stage capable of performing arbitrary modifications to packet headers and maintaining local state. This programmability enables implementation of complex network functions like load balancing, traffic engineering, and network virtualization directly in the data plane while maintaining line-rate performance. 3 Scaling Transaction Processing Overall architecture of S OLAYER CHAIN is illustrated in Figure 1. Each transaction reaches an initial ingress point that conducts sigverify and local deduplification. The verified transaction is then sent to the pre-execution cluster that conducts pre-execution. We discuss this pipeline in sub- section 3.1. Transaction effect and intermediate snapshots are sent to the sequencer via Infiniband. The sequencer leverages SDN switch and additional FPGA to decide whether a transaction shall go through simple path (i.e., all transaction accounts are at latest version when pre-executing) or complex path (i.e., at least one account has a newer version). For simple path transaction, the state change is directly applied via RDMA, with a local cache on the SDN. For complex path transac- tion, it enters a local mempool with sub-millisecond processing speed. The sequencer schedules the transactions in the local mempool to achieve fair and optimal parallel execution of all trans- actions. The scheduling algorithm is described in subsection 3.2. We discuss distributed database that stores account data in subsection 3.3. After the transaction is executed and state change has been written, the transaction is propagated through a global PoPs. 5 Figure 2: Amount of transaction requiring re-execution versus the amount of transactions the ex- ecutor is lagging behind. 3.1 Microservice Pipeline SOLAYER CHAIN ’s transaction processing pipeline mirrors some of Solana’s core stages: signature verification (sigverify), deduplication, scheduling, banking, and storage. Banking stages are inher- ently sequential, requiring either coarse-grained locking or single-threaded execution to maintain consistency. However, while Solana executes these stages in a monolithic architecture, signature verification, deduplication, and storage operations can be decoupled and distributed. S OLAYER CHAIN exploits this observation by decomposing these stages into independent microservices de- ployed across an elastic compute fabric. Our system implements dynamic resource provisioning through a feedback-driven control plane that monitors transaction ingress rates and automatically scales processing capacity. A key insight in our design is that a significant portion of transactions can be pre-executed inde- pendently, provided they do not exhibit read-write dependencies on accounts accessed by concur- rent transactions (i.e., no dirty read happens). According to Figure 2, a simulation of pre-executing transactions from 1000 slots starting from 304992000, only 2% of the transaction needs to be re- executed due to dirty read, even if the executor is significantly lagging behind the chain. Building on this observation, S OLAYER CHAIN introduces a simulation stage that precedes transaction scheduling. This stage, which can be horizontally scaled across nodes, performs spec- ulative execution of transactions against the most recently committed state on the node. During simulation, the system captures both the transaction effects and a set of intermediate execution snapshots at account access boundaries. While some transactions may exhibit conflicts due to over- lapping account access patterns, our approach allows parallel pre-execution of the non-conflicting majority. Notably, transactions that only perform read operations can be fully validated and confirmed at the edge, bypassing the central banking stage entirely. To further reduce the congestion of con- flicting transactions, transactions accessing hot accounts can be pre-executed for all possibilities 6 of the future value of those hot accounts. Each account has a short-term prediction model imple- mented using Winter-Holt’s double exponential smoothing prediction (DESP) for each byte in the account. Depending on the access frequency of an account, the pre-execution node operator could manually inject a more accurate prediction model, and a transaction can be simulated millions of times with different possible account data. For the remaining transactions that are still conflicting with previous measures, when conflicts are detected, the subscriber of the simulation results can rapidly reconstruct the correct execution state from the nearest valid snapshot in simulation results, eliminating the need for complete transaction re-execution. This design significantly reduces the computational overhead traditionally associated with the banking stage while maintaining strict consistency guarantees. 3.2 Transaction Semantic Aware Scheduling Solana’s transaction processing model employs account-level access pattern analysis to batch trans- actions, preventing dirty reads through strict isolation. The scheduler partitions transactions into batches based on their declared account access patterns, optimizing for parallel execution. While this approach enables lock-free execution within batches during the banking stage, it is inherently conservative, treating all account accesses within a transaction as concurrent. S OLAYER CHAIN extends this model by introducing fine-grained sequence prediction of read-write operations. By analyzing the temporal ordering of account accesses within transactions, our system constructs an optimized locking schedule that permits concurrent execution of transactions accessing the same accounts when their actual read-write sequences do not conflict during execution. This dynamic scheduling approach significantly reduces lock contention while maintaining serializability guar- antees. SOLAYER CHAIN leverages its simulation stage to obtain estimated read-write sequences of transactions before they enter the scheduling phase. Formally, for a transaction t, we define its execution trace as a sequence: E(t) = {(op1, a1, c1), (op2, a2, c2), ...,(opn, an, cn)} where opi ∈ {read, write} represents the operation type, ai represents the accessed account, and ci represents the predicted execution time cost between opi and opi+1. For any two transactions ti and tj with overlapping accounts A(ti) ∩ A(tj), we define the temporal sequenceSa(t) for account a as the ordered sequence of operations {(opk, tk)|ak = a} where tk is the relative timestamp. The computational gap between consecutive operations is defined asGk = ck · α where α is the average instruction execution time. Two transactions can execute in parallel if for alla ∈ A(ti)∩A(tj), their sequences Sa(ti) and Sa(tj) have no write-write conflicts, and for any read-write pairs(read, tk) ∈ Sa(ti), (write, tl) ∈ Sa(tj), the gap satisfies Gk > δwhere δ is a tunable number representing the estimation error that simulations can make. Note that while the goal is to find a lock free schedule, lock is still used during execution as the schedule is based on estimation and may not be correct. Given that this problem is analogous to bin-packing problem, the best algorithm to solve the optimal schedule is NP-hard. To ensure the schedule can be found at sub-millisecond level, we 7 leverage Shortest Makespan First (SMF), a greedy algorithm that is widely used in database sys- tems, for solving a near-optimal schedule. In addition, S OLAYER CHAIN employs a parallel scheduler ensemble that concurrently ex- plores multiple scheduling strategies to optimize transaction throughput. The ensemble includes Solana’s multiple original account-based partitioning algorithms as a baseline, along with the SMF algorithm. Each algorithm in the ensemble generates a candidate schedule with an estimated time cost, and the scheduler selects the schedule with the least time cost. 3.3 Sharding Database with RDMA Blockchain systems face significant scalability challenges due to their ever-growing state size. For example, Ethereum’s state currently exceeds 1.1 TB, highlighting the need for efficient state management solutions. While storing this data in memory is crucial for low-latency access, the memory limitations of individual servers necessitate a distributed approach. S OLAYER CHAIN implements a sophisticated sharding mechanism based on a key-value store architecture, mapping 32-byte account addresses to their corresponding state data. Unlike Solana, which imposes a 10MB limit on account data size, SOLAYER CHAIN supports arbitrary data sizes per account. Each database node in S OLAYER CHAIN stores a shard of data. The core architecture of each database node of SOLAYER CHAIN consists of three primary components. First, a memory-resident jump table maintains mappings between account address
프로젝트로 돌아가기