Skip to content
Crypto.world

The Ledger

Ethereum’s PBT Debate Turns on Records Versus 4 KB Pages

A forum analysis comparing eight ways to store Ethereum’s proposed Partitioned Binary Tree finds record-writing layouts cheaper than page-writing ones at 16 GB of DRAM. Its results table reports record-log figures at 8 GB, though the post’s summary says record layouts do not fit below 16 GB.

Ethereum’s PBT Debate Turns on Records Versus 4 KB Pages

Ethereum’s proposed Partitioned Binary Tree could make state proofs more efficient, but storing that tree on disk creates a different engineering trade-off: write individual records or rewrite whole 4 KB pages. A new analysis posted to the Fellowship of Ethereum Magicians on October 27 finds record-based layouts generally cheaper when the storage engine gets 16 GB of memory. The advantage does not settle the choice between record logs and log-structured merge trees, and the analysis says page-based storage performs better under tighter memory limits.

EIP-8297 adds a storage-engine problem

EIP-8297 proposes replacing Ethereum’s hexary Merkle Patricia Trie with a partitioned binary tree, or PBT. The proposal changes the state tree’s shape and key organization; it does not prescribe one physical database layout for client teams. In the new forum post, account leaves have 32 branch records above them, while a written storage leaf has 45 to 48, increasing the records a storage layer must manage for updates.

The author, posting as cocoyoon, replayed two roughly one-week windows of Ethereum mainnet activity into a PBT and compared storage approaches under equal memory budgets. The comparison includes layouts that write individual records and layouts that write pages, using in-place updates, copy-on-write, append-only logs or sorted runs. Two implementations were built; six layouts were modeled from the replay, and the results are grouped into six layout families.

Records beat pages at 16 GB, but not by a clear margin

The study’s central finding is that record-writing layouts cost less than page-writing layouts once the storage engine has 16 GB of DRAM. At that budget, the modeled path-keyed LSM used by Geth, Nethermind and Besu scored 5,854–6,908 in one sample window, compared with 64,378 for the modeled copy-on-write B+tree associated with Reth’s MDBX storage. The figures are per-block IO-cost results, not dollar costs or a direct measurement of complete client performance.

“Among record layouts, the LSM and the log are within 1.6x of each other, and neither clears the 1.3x bar we use to name a winner.”

cocoyoon, author of the forum post

The post explains the gap between records and pages with the amount of data each update touches: a block changes about 18,000 records spread across roughly 2,400 Merkle pages, and rewriting a page moves 4 KB to alter only a handful of records. Even so, the comparison does not identify a consistent winner between the record log and record LSM at 16 GB. The post’s 1.3x threshold requires a layout to beat alternatives by a meaningful margin across both replay windows.

Memory changes which layout makes sense

The post’s summary says record layouts do not fit below 16 GB, but its results table reports record-log costs at 8 GB: 20,433 and 19,428 for one compaction setting, and 18,788 and 17,779 for another, across the two windows. At 4 GB, the table shows no record-log results; at 8 GB, the record LSM variants are also marked as not fitting. The post therefore gives conflicting information about the record log’s fit below 16 GB. Its summary identifies the page log as the cheapest layout in the 4 GB and 8 GB comparisons, while the table shows that this does not mean every record layout is absent at 8 GB.

The post says the record log’s index needs 7.5 GB of filters and buffers in memory, while the record LSM needs 9.3 GB. The page log is the lowest-cost option in the 4 GB and 8 GB comparisons, while an in-place page store is cheapest at 2 GB. The results make memory capacity—not just write efficiency—part of the implementation decision.

The post uses 16 GB as a working storage-engine budget based on EIP-7870’s 32 GB full-node RAM recommendation, with the rest shared by the consensus client and operating system. Under that assumption, its practical guidance differs by client architecture: existing path-keyed LSM users can keep their storage engine, while Reth’s page-based copy-on-write B+tree is the largest target for a different PBT layout. A page-aligned key for an LSM reduces read misses in the model, but compaction writes account for about 70% of its cost.

The benchmark is not a full client test

The results come from two mainnet replay windows dating to late 2025, with costs measured over the final 1,000 blocks after a 49,000-block warm-up. Six of the eight layouts are models rather than complete database engines running the replay. A RocksDB test checks some write-amplification assumptions, but it does not turn the modeled comparisons into a full-client benchmark.

The author also lists limits on the device tests: they replay modeled IO counts on two small cloud instances and a MacBook SSD, and say a typical node’s Linux NVMe has not yet been measured. The post’s next steps include testing read IO on a real engine, comparing path-keyed and page-keyed records, and measuring on a commodity NVMe drive under Linux. It ends by asking client teams whether allocating about 16 GB to execution-state storage is a fair assumption for a 32 GB full node.

Sources

  1. Original source Fellowship of Ethereum Magicians ethereum-magicians.org

Other pages read

  1. Ethereum Improvement Proposals · page 1 eips.ethereum.org
  2. Ethereum Improvement Proposals · page 2 eips.ethereum.org

Related stories

Explore

More articles