IMPORTANT: To view this page as Markdown, append `.md` to the URL (e.g. /get-started.md). For the complete documentation index, see llms.txt.
Skip to main content
For the complete documentation index, see llms.txt. Markdown versions of all pages are available by appending .md to any URL (e.g. /get-started.md).

Mojo struct

StaticOffsetStorage

struct StaticOffsetStorage[*, static_offset: Int, element_width: Int = Int(1)]

Stub of the planned static-offset storage policy family.

Views externally owned memory like PointerStorage, but starts every access static_offset scalar elements past the handle. The offset is encoded in the policy's parameters, so it costs nothing at runtime and survives unsafe_cast. This is a minimal placeholder used by the TensorOps binary-op tests to exercise per-operand storage policies until the full static-offset design lands.

Parameters​

  • ​static_offset (Int): The number of scalar elements every access is advanced by.
  • ​element_width (Int): Number of scalar elements per logical element. A value of 1 (the default) is a non-vectorized tensor; larger values describe a vectorized view whose logical elements are SIMD vectors.

Implemented traits​

AnyType, ImplicitlyDeletable, TensorStorage

comptime members​

element_size​

comptime element_size = element_width

Number of scalar elements per logical element (alias of element_width).

OffsetResultType​

comptime OffsetResultType[offset_types: TypeList[values]] = StaticOffsetStorage[static_offset=static_offset, element_width=element_width]

The storage type produced by offsetting with a given coordinate.

Dynamic offsetting never changes the storage policy, so this is Self; the static offset stays encoded in the parameters.

Parameters​

  • ​offset_types (TypeList[values]): The coordinate element types of the applied offset.

StorageType​

comptime StorageType[mut: Bool, //, dtype: DType, origin: Origin[mut=mut], address_space: AddressSpace] = Pointer[SIMD[dtype, element_width], origin, address_space=address_space]

A raw UnsafePointer borrowing the storage, static_offset scalar elements before the viewed region.

Parameters​

  • ​mut (Bool): The mutability of the borrowed storage, inferred from origin.
  • ​dtype (DType): The element data type of the borrowed storage.
  • ​origin (Origin[mut=mut]): The origin tracking the lifetime of the borrowed storage.
  • ​address_space (AddressSpace): The address space the borrowed storage resides in.

Methods​

unsafe_cast​

static def unsafe_cast[to_mut: Bool, //, to_dtype: DType, to_origin: Origin[mut=to_mut], to_address_space: AddressSpace](storage: Pointer[SIMD[dtype, element_width], address_space=storage.address_space]) -> Pointer[SIMD[to_dtype, element_width], to_origin, address_space=to_address_space]

Reinterprets a storage handle with new type parameters.

The static offset lives in the policy's parameters, so it is unaffected by the reinterpret.

Parameters:

  • ​to_mut (Bool): The mutability of the origin.
  • ​to_dtype (DType): The element data type to reinterpret the storage as.
  • ​to_origin (Origin[mut=to_mut]): The origin to reinterpret the storage as.
  • ​to_address_space (AddressSpace): The address space to reinterpret the storage as.

Args:

  • ​storage (Pointer[SIMD[dtype, element_width], address_space=storage.address_space]): The storage to reinterpret.

Returns:

Pointer[SIMD[to_dtype, element_width], to_origin, address_space=to_address_space]: A handle referring to the same storage, viewed with the new type parameters.

load​

static def load[dtype: DType, //, width: SIMDLength, alignment: Int, invariant: Bool = False, non_temporal: Bool = False](storage: Pointer[SIMD[dtype, element_width], address_space=storage.address_space]) -> SIMD[dtype, width]

Loads a SIMD value from the start of the viewed region.

Parameters:

  • ​dtype (DType): The element data type of the storage.
  • ​width (SIMDLength): The number of elements to load.
  • ​alignment (Int): The alignment guarantee for the load.
  • ​invariant (Bool): If True, the compiler may assume the memory won't be modified during the kernel, enabling load hoisting and caching.
  • ​non_temporal (Bool): If True, indicates the data will not be reused soon, allowing the hardware to bypass caches (e.g., streaming loads).

Args:

  • ​storage (Pointer[SIMD[dtype, element_width], address_space=storage.address_space]): The storage to load from.

Returns:

SIMD[dtype, width]: The loaded SIMD value.

static def load[dtype: DType, //, width: SIMDLength, alignment: Int, invariant: Bool = False, non_temporal: Bool = False](storage: Pointer[SIMD[dtype, element_width], address_space=storage.address_space], offset: T) -> SIMD[dtype, width]

Loads a SIMD value at a scalar-element offset into the region.

Parameters:

  • ​dtype (DType): The element data type of the storage.
  • ​width (SIMDLength): The number of elements to load.
  • ​alignment (Int): The alignment guarantee for the load.
  • ​invariant (Bool): If True, the compiler may assume the memory won't be modified during the kernel, enabling load hoisting and caching.
  • ​non_temporal (Bool): If True, indicates the data will not be reused soon, allowing the hardware to bypass caches (e.g., streaming loads).

Args:

  • ​storage (Pointer[SIMD[dtype, element_width], address_space=storage.address_space]): The storage to load from.
  • ​offset (T): The scalar-element offset to load at, relative to the start of the viewed region.

Returns:

SIMD[dtype, width]: The loaded SIMD value.

store​

static def store[dtype: DType, alignment: Int, *, non_temporal: Bool = False](storage: Pointer[SIMD[dtype, element_width], address_space=storage.address_space], value: SIMD[dtype])

Stores a SIMD value at the start of the viewed region.

Parameters:

  • ​dtype (DType): The element data type of the storage.
  • ​alignment (Int): The alignment guarantee for the store.
  • ​non_temporal (Bool): If True, indicates the data will not be reused soon, allowing the hardware to bypass caches (e.g., streaming stores).

Args:

  • ​storage (Pointer[SIMD[dtype, element_width], address_space=storage.address_space]): The storage to store into.
  • ​value (SIMD[dtype]): The SIMD value to store.

static def store[dtype: DType, alignment: Int, *, non_temporal: Bool = False](storage: Pointer[SIMD[dtype, element_width], address_space=storage.address_space], offset: T, value: SIMD[dtype])

Stores a SIMD value at a scalar-element offset into the region.

Parameters:

  • ​dtype (DType): The element data type of the storage.
  • ​alignment (Int): The alignment guarantee for the store.
  • ​non_temporal (Bool): If True, indicates the data will not be reused soon, allowing the hardware to bypass caches (e.g., streaming stores).

Args:

  • ​storage (Pointer[SIMD[dtype, element_width], address_space=storage.address_space]): The storage to store into.
  • ​offset (T): The scalar-element offset to store at, relative to the start of the viewed region.
  • ​value (SIMD[dtype]): The SIMD value to store.

offset​

static def offset[offset_mut: Bool, offset_types: TypeList[offset_types.values], //, offset_dtype: DType, offset_origin: Origin[mut=offset_mut], offset_address_space: AddressSpace](var storage: Pointer[SIMD[offset_dtype, element_width], offset_origin, address_space=offset_address_space], var offset_coord: Coord[offset_types]) -> Pointer[SIMD[offset_dtype, element_width], offset_origin, address_space=offset_address_space]

Returns a storage handle offset by a number of scalar elements.

The dynamic offset advances the handle itself; the static offset remains in the policy's parameters and continues to apply on top.

Parameters:

  • ​offset_mut (Bool): The mutability of the storage, inferred from offset_origin.
  • ​offset_types (TypeList[offset_types.values]): The coordinate element types of offset_coord.
  • ​offset_dtype (DType): The element data type of the storage.
  • ​offset_origin (Origin[mut=offset_mut]): The origin tracking the lifetime of the storage.
  • ​offset_address_space (AddressSpace): The address space the storage resides in.

Args:

  • ​storage (Pointer[SIMD[offset_dtype, element_width], offset_origin, address_space=offset_address_space]): The storage to offset from.
  • ​offset_coord (Coord[offset_types]): A rank-1 coordinate holding the number of scalar elements to advance the handle by.

Returns:

Pointer[SIMD[offset_dtype, element_width], offset_origin, address_space=offset_address_space]: A handle of the same type starting the given number of scalar elements into the referenced storage.

distance​

static def distance[dtype: DType, address_space: AddressSpace, //](storage: Pointer[SIMD[dtype, element_width], address_space=address_space], other: Pointer[SIMD[dtype, element_width], address_space=address_space]) -> Int

Returns the scalar-element distance from other to storage.

Both handles carry the same static offset, so it cancels out of the distance.

Parameters:

  • ​dtype (DType): The storages' DType.
  • ​address_space (AddressSpace): The storages' AddressSpace.

Args:

  • ​storage (Pointer[SIMD[dtype, element_width], address_space=address_space]): The storage to measure the distance to.
  • ​other (Pointer[SIMD[dtype, element_width], address_space=address_space]): The storage to measure the distance from.

Returns:

Int: The number of scalar elements separating the two handles. The value is positive when storage is ahead of other and negative when it precedes other.

copy_from​

static def copy_from[SelfLayoutType: TensorLayout, self_origin: MutOrigin, self_address_space: AddressSpace, OtherLayoutType: TensorLayout, other_mut: Bool, other_origin: Origin[mut=other_mut], other_address_space: AddressSpace, //, dst_dtype: DType, src_dtype: DType, OtherStorage: TensorStorage](storage: Tuple[Pointer[SIMD[dst_dtype, element_width], self_origin, address_space=self_address_space], SelfLayoutType], other: Tuple[OtherStorage.StorageType[other_mut, origin_of(other_origin), src_dtype, other_origin, other_address_space], OtherLayoutType])

Copies the elements of other into storage, in place.

Delegates to the shared _copy_from loop; destination accesses go through this policy's load/store, so the static offset applies.

Parameters:

  • ​SelfLayoutType (TensorLayout): The layout type of the destination storage.
  • ​self_origin (MutOrigin): The origin of the destination storage.
  • ​self_address_space (AddressSpace): The address space of the destination storage.
  • ​OtherLayoutType (TensorLayout): The layout type of the source storage.
  • ​other_mut (Bool): The mutability of the source storage.
  • ​other_origin (Origin[mut=other_mut]): The origin of the source storage.
  • ​other_address_space (AddressSpace): The address space of the source storage.
  • ​dst_dtype (DType): The element data type of the destination storage.
  • ​src_dtype (DType): The element data type of the source storage.
  • ​OtherStorage (TensorStorage): The storage policy of the source. May differ from Self as long as the two policies are copy-compatible (same logical element size).

Args:

View source

View source

Was this page helpful?

Models

Cookbook

Puzzles

Blog

Community

Contact