Struct CacheKey 

pub struct CacheKey {
    pub tenant_id: u64,
    pub blueprint: u64,
    pub sm_version: u32,
    pub emit_config_hash: u64,
}

Cache key.

tenant_id is the first field so that it dominates the derived Hash (field-order) and lexicographic Ord orderings. Keeping the cache keyed by tenant is the only thing preventing tenant A from looking up — and on the CUDA path executing — a compiled kernel that tenant B installed (exec S-7, cross-tenant confused-deputy). Every host-side get / put MUST therefore include the calling tenant; constructing a key without one (e.g. directly from guest-supplied bytes) is the bug we are fixing.

Fields

tenant_id: u64

Owning tenant. Cache lookups MUST be scoped to the caller’s tenant — see the type-level docs. Use CacheKey::for_tenant to construct.

blueprint: u64

TensorWasmKernelBlueprint::fingerprint().

sm_version: u32

CUDA compute capability (e.g. 80 for sm_80, 89 for sm_89).

emit_config_hash: u64

Hash of the full crate::ptx_emit::EmitConfig used at emit time (jit S-2). sm_version covers the compute capability number but NOT the architecture suffix (e.g. "sm_80" vs "sm_80a"), the PTX language version, or the launch_bounds flag — two EmitConfigs that differ in any of those produce non-interchangeable PTX. Without this field two such configs would collide on the same key and the second caller would silently get the first caller’s PTX.

Callers that don’t have an EmitConfig (rewriter pre-population, benches) pass 0. Construct via CacheKey::for_tenant (defaults to 0) or CacheKey::for_tenant_with_emit_config (computes a stable hash over the config).

Implementations

impl CacheKey

pub fn for_tenant(tenant_id: TenantId, blueprint: u64, sm_version: u32) -> Self

Construct a tenant-scoped cache key with no EmitConfig hash.

Equivalent to passing emit_config_hash: 0 — appropriate for the rewriter and bench paths that use the default emitter config. The tenant_id MUST come from trusted store state (e.g. InstanceState::tenant_id), never from guest-supplied fingerprint bytes. See the CacheKey docs for the confused-deputy primitive this guards against.

pub fn for_tenant_with_emit_config( tenant_id: TenantId, blueprint: u64, sm_version: u32, cfg: &EmitConfig, ) -> Self

Construct a tenant-scoped cache key that also covers the emitter config. Use this when the lookup must distinguish between PTX-version variants, target-architecture suffixes, or launch-bounds settings (jit S-2).

Cost note: each call builds a fresh blake3::Hasher and finalises over a handful of bytes. The amortised wall cost is ~µs on a modern x86-64 box — negligible compared to a kernel dispatch but non-zero on the hot path. Callers that resolve the same EmitConfig for every lookup (the typical pattern: emit-config is pinned at instance-spawn time) should hash it once at spawn and reuse the CacheKey rather than re-deriving it for every dispatch. The hasher itself is intentionally inline here (not memoised) so the function stays pure and Send-friendly for the rewriter’s rayon::par_iter callers.

Trait Implementations

impl Clone for CacheKey

fn clone(&self) -> CacheKey

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for CacheKey

impl Debug for CacheKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Eq for CacheKey

impl Hash for CacheKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for CacheKey

fn cmp(&self, other: &CacheKey) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for CacheKey

fn eq(&self, other: &CacheKey) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for CacheKey

fn partial_cmp(&self, other: &CacheKey) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for CacheKey