Struct Context 

pub struct Context<H> {
    pub tensors: HashMap<TensorId, TensorIr>,
    pub handles: HandleContainer<H>,
    pub scalars: HashMap<ScalarId, ScalarIr>,
    pub shapes_relative2global: HashMap<usize, usize>,
    pub ranges: Vec<Slice>,
}

The context contains the relative graph tensor mapping so that a relative tensor id can be mapped to an existing tensor that can be fetched and updated with the handle container.

It also contains all scalar values, which can change even for the same graph. They are sorted in the order in which they appear in the graph.

Fields

tensors: HashMap<TensorId, TensorIr>

The tensor mapping where local tensor id points to the updated tensor representation.

handles: HandleContainer<H>

Handle container to retrieve tensors based on their representation.

scalars: HashMap<ScalarId, ScalarIr>

Scalars found in the graph in the order they appeared.

shapes_relative2global: HashMap<usize, usize>

Shape mapping from relative shape ids to global (real) shape ids.

ranges: Vec<Slice>

Concrete slice ranges found in the graph, indexed by the placeholder id assigned during relativization (the value carried in a relativized range’s start field). Ranges can change for the same relative graph — like scalars — so they are kept out of the relative form and rebound per invocation.

Implementations

impl<H> Context<H>

where H: Clone,

pub fn fork(&self) -> Context<H>

Fork the context into an independent owned copy. Used by autotuning to give each benchmark run a sandbox — mutations stay local until the caller merges new handles back. HandleContainer::fork clones the id→handle map; actual GPU buffers are refcounted so only the map itself is duplicated.