Struct MemoryMerkleSubTree 

pub struct MemoryMerkleSubTree {
    pub stream: Arc<CudaStream>,
    pub event: Option<CudaEvent>,
    pub buf: DeviceBuffer<[F; 8]>,
    pub height: usize,
    pub path_len: usize,
}

A Merkle subtree stored in a single flat buffer, combining a vertical path and a heap-ordered binary tree.

Memory layout:

• The first path_len elements form a vertical path (one node per level), used when the actual size is smaller than the max size.
• The remaining elements store the subtree nodes in heap-order (breadth-first), with size leaves and 2 * size - 1 total nodes.

The call of filling the buffer is done async on the new stream. Option is used to wait for the completion.

Fields

stream: Arc<CudaStream>

event: Option<CudaEvent>

buf: DeviceBuffer<[F; 8]>

height: usize

path_len: usize

Implementations

impl MemoryMerkleSubTree

pub fn new(addr_space_size: usize, max_size: usize) -> Self

Constructs a new Merkle subtree with a vertical path and heap-ordered tree. The buffer is sized based on the actual address space and the maximum size.

addr_space_size is the number of leaf digest nodes necessary for this address space. The max_size is the number of leaf digest nodes in the full balanced tree dictated by addr_space_height from the MemoryConfig.

pub fn dummy() -> Self

pub fn build_async( &mut self, d_data: &DeviceBuffer<u8>, addr_space_idx: usize, zero_hash: &DeviceBuffer<[F; 8]>, )

Asynchronously builds the Merkle subtree on its dedicated CUDA stream. Also reconstructs the vertical path if path_len > 0, and records a completion event.

Here addr_space_idx is the address space shifted by ADDR_SPACE_OFFSET = 1

pub fn layer_bounds(&self, depth: usize) -> (usize, usize)

Returns the bounds [start, end) of the layer at the given depth. These bounds correspond to the indices of the layer in the buffer. depth: 0 = root, 1 = root’s children, …, height-1 = leaves