Struct MemoryMerkleTree

pub struct MemoryMerkleTree {
    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 the default stream.
• CudaEvents are used to synchronize subtree completion.

Fields

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(&mut 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.

Caution: this method destroys all subtree streams and events. For safety, we force synchronize all subtree streams and the default stream (cudaStreamPerThread) with host before deallocating buffers.

pub fn update_with_touched_blocks( &mut 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.

Trait Implementations

impl Drop for MemoryMerkleTree

fn drop(&mut self)

Executes the destructor for this type.