Struct MemoryMerkleTree 

pub struct MemoryMerkleTree {
    pub stream: Arc<CudaStream>,
    pub subtrees: Vec<MemoryMerkleSubTree>,
    pub top_roots: DeviceBuffer<[F; 8]>,
    pub height: usize,
    pub hasher_buffer: SharedBuffer<F>,
    /* private fields */
}

A Memory Merkle tree composed of independent subtrees (one per address space), each built asynchronously and finalized into a top-level Merkle root.

Layout:

• The memory is split across multiple MemoryMerkleSubTree instances, one per address space.
• The top-level tree is formed by hashing all subtree roots into a single buffer (top_roots).
  • top_roots layout: [root, hash(root_addr_space_1, root_addr_space_2), hash(root_addr_space_3), hash(root_addr_space_4), …]
  • if we have > 4 address spaces, top_roots will be extended with the next hash, etc.

Execution:

• Subtrees are built asynchronously on individual CUDA streams.
• The final root is computed after all subtrees complete, on a shared stream.
• CudaEvents are used to synchronize subtree completion.

Fields

stream: Arc<CudaStream>

subtrees: Vec<MemoryMerkleSubTree>

top_roots: DeviceBuffer<[F; 8]>

height: usize

hasher_buffer: SharedBuffer<F>

Implementations

impl MemoryMerkleTree

pub fn new( mem_config: MemoryConfig, hasher_chip: Arc<Poseidon2PeripheryChipGPU>, ) -> Self

Creates a full Merkle tree with one subtree per address space. Initializes all buffers and precomputes the zero hash chain.

pub fn mem_config(&self) -> &MemoryConfig

pub fn build_async(&mut self, d_data: &DeviceBuffer<u8>, addr_space: usize)

Starts asynchronous construction of the specified address space’s Merkle subtree. Uses internal zero hashes and launches kernels on the subtree’s own CUDA stream.

Here addr_space is the unshifted address space, so addr_space = 0 is the immediate address space, which should be ignored.

pub fn finalize(&self)

Finalizes the Merkle tree by collecting all subtree roots and computing the final root. Waits for all subtrees to complete and then performs the final hash operation.

pub fn drop_subtrees(&mut self)

Drops all massive buffers to free memory. Used at the end of an execution segment.

pub fn update_with_touched_blocks( &self, unpadded_height: usize, d_touched_blocks: &DeviceBuffer<u32>, empty_touched_blocks: bool, ) -> AirProvingContext<GpuBackend>

Updates the tree and returns the merkle trace.

pub fn calculate_unpadded_height( &self, touched_memory: &TimestampedEquipartition<F, DIGEST_WIDTH>, ) -> usize

An auxiliary function to calculate the required number of rows for the merkle trace.