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
DevicePointerEngine
struct DevicePointerEngine[*, element_width: Int = Int(1)]
Implements TensorOps backed by a DevicePointer handle.
DevicePointerEngine is the device-pointer-backed analogue of
DefaultEngine, accepting the same element_width parameter. Its
StorageType handle is a DevicePointer, which on the host carries the
buffer's owning reference plus an element offset and size, and which
substitutes to a bare device Pointer at the kernel boundary
(DevicePointer.device_type).
Because the handle conforms to DevicePassable, a host-side
DevicePointer shrinks to a real device address when the enclosing
TileTensor encodes its fields for a kernel launch. The address is written
into the first bytes of the handle's slot, so the in-place TensorOps
here reinterpret those bytes (_device_leaf_ptr) on device. They abort on
host: device memory is not guaranteed to be host-dereferenceable.
unsafe_ptr, which TileTensor element loads and stores go through,
recovers the same device address on device and the raw buffer address
through the owning DeviceBuffer on host. The operations that don't
dereference storage (offset, distance, unsafe_cast) work on both
host and device using DevicePointer arithmetic or pure reinterprets.
Parameters
- element_width (
Int): Number of scalar elements per logical element. A value of1(the default) is a non-vectorized tensor; larger values describe a vectorized view whose logical elements are SIMD vectors. TheDevicePointerhandle is always scalar-typed and every operation works in scalar-element units, soelement_widthonly setselement_size(and thus the tile's vectorizedElementType), exactly as forDefaultEngine.
Implemented traits
AnyType,
Deinitable,
Movable,
TensorEngine,
TensorOps
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]] = DevicePointerEngine[element_width=element_width]
The storage type produced by offsetting with a given coordinate.
Offsetting never changes the engine, so this is Self.
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] = DevicePointer[dtype, origin]
A DevicePointer handle borrowing the storage.
The address_space is part of the TensorEngine interface but is unused:
a DevicePointer always refers to GENERIC device memory.
Parameters
- mut (
Bool): The mutability of the borrowed storage, inferred fromorigin. - 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
write_type_name_to
static def write_type_name_to(mut writer: T)
Writes the engine type name representation to the writer.
Args:
- writer (
T): TheWriterto output to.
unsafe_cast
static def unsafe_cast[to_mut: Bool, //, to_dtype: DType, to_origin: Origin[mut=to_mut], to_address_space: AddressSpace](storage: DevicePointer) -> DevicePointer[to_dtype, to_origin]
Reinterprets a storage handle with new type parameters.
DevicePointer has an identical layout across dtype and origin, so
this is a byte-for-byte reinterpret of the handle; no DeviceBuffer
element conversion takes place. The caller is responsible for ensuring
the new parameters are valid for the referenced storage.
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 (
DevicePointer): The storage to reinterpret.
Returns:
DevicePointer[to_dtype, to_origin]: A handle referring to the same storage, viewed with the new type
parameters.
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: DevicePointer[offset_dtype, offset_origin], var offset_coord: Coord[offset_types]) -> DevicePointer[offset_dtype, offset_origin]
Returns a storage handle offset by a number of scalar elements.
On host this advances the wrapped DevicePointer (bounds-checked
against the owning DeviceBuffer). On device it advances the encoded
device pointer held in the handle's first bytes, preserving the rest of
the handle's (unused) bytes.
Parameters:
- offset_mut (
Bool): The mutability of the storage, inferred fromoffset_origin. - offset_types (
TypeList[offset_types.values]): The coordinate element types ofoffset_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 (
DevicePointer[offset_dtype, offset_origin]): The storage to offset from. - offset_coord (
Coord[offset_types]): A flat coordinate whose components sum to the number of scalar elements to advance the handle by.
Returns:
DevicePointer[offset_dtype, offset_origin]: A handle of the same type starting the given number of scalar
elements into the referenced storage.
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, OtherEngine: TensorEngine](storage: Tuple[DevicePointer[dst_dtype, self_origin], SelfLayoutType], other: Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), src_dtype, other_origin, other_address_space], OtherLayoutType])
Copies the elements of other into storage, in place.
Loads each logical element from other through its (possibly
different) engine and stores it into storage through
DevicePointerEngine, casting to the destination dtype. Delegates to
the shared _copy_from loop. Device-only: the underlying loads and
stores reinterpret the encoded device pointer and abort on host.
- Both operands must have statically known shapes with matching total element count.
- Both operands must have the same logical element size.
- Source and destination dtypes may differ; each logical element is cast to the destination dtype.
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. - OtherEngine (
TensorEngine): The engine of the source. May differ fromSelfas long as the two engines are copy-compatible (same logical element size).
Args:
- storage (
Tuple[DevicePointer[dst_dtype, self_origin], SelfLayoutType]): A tuple of the destination storage (modified in place) and its layout. - other (
Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), src_dtype, other_origin, other_address_space], OtherLayoutType]): A tuple of the source storage and its layout.
iadd
static def iadd[SelfLayoutType: TensorLayout, self_origin: MutOrigin, self_address_space: AddressSpace, OtherLayoutType: TensorLayout, other_mut: Bool, other_origin: Origin[mut=other_mut], other_address_space: AddressSpace, //, dtype: DType, OtherEngine: TensorEngine](storage: Tuple[DevicePointer[dtype, self_origin], SelfLayoutType], other: Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType])
Adds other into storage elementwise, in place.
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 right-hand storage operand. - other_mut (
Bool): The mutability of the right-hand storage operand. - other_origin (
Origin[mut=other_mut]): The origin of the right-hand storage operand. - other_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of both storages. - OtherEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the two engines have the same logical element size.
Args:
- storage (
Tuple[DevicePointer[dtype, self_origin], SelfLayoutType]): A tuple of the destination storage (modified in place) and its layout. - other (
Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType]): A tuple of the right-hand storage operand and its layout.
imul
static def imul[SelfLayoutType: TensorLayout, self_origin: MutOrigin, self_address_space: AddressSpace, OtherLayoutType: TensorLayout, other_mut: Bool, other_origin: Origin[mut=other_mut], other_address_space: AddressSpace, //, dtype: DType, OtherEngine: TensorEngine](storage: Tuple[DevicePointer[dtype, self_origin], SelfLayoutType], other: Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType])
Multiplies storage by other elementwise, in place.
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 right-hand storage operand. - other_mut (
Bool): The mutability of the right-hand storage operand. - other_origin (
Origin[mut=other_mut]): The origin of the right-hand storage operand. - other_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of both storages. - OtherEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the two engines have the same logical element size.
Args:
- storage (
Tuple[DevicePointer[dtype, self_origin], SelfLayoutType]): A tuple of the destination storage (modified in place) and its layout. - other (
Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType]): A tuple of the right-hand storage operand and its layout.
isub
static def isub[SelfLayoutType: TensorLayout, self_origin: MutOrigin, self_address_space: AddressSpace, OtherLayoutType: TensorLayout, other_mut: Bool, other_origin: Origin[mut=other_mut], other_address_space: AddressSpace, //, dtype: DType, OtherEngine: TensorEngine](storage: Tuple[DevicePointer[dtype, self_origin], SelfLayoutType], other: Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType])
Subtracts other from storage elementwise, in place.
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 right-hand storage operand. - other_mut (
Bool): The mutability of the right-hand storage operand. - other_origin (
Origin[mut=other_mut]): The origin of the right-hand storage operand. - other_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of both storages. - OtherEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the two engines have the same logical element size.
Args:
- storage (
Tuple[DevicePointer[dtype, self_origin], SelfLayoutType]): A tuple of the destination storage (modified in place) and its layout. - other (
Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType]): A tuple of the right-hand storage operand and its layout.
ifloordiv
static def ifloordiv[SelfLayoutType: TensorLayout, self_origin: MutOrigin, self_address_space: AddressSpace, OtherLayoutType: TensorLayout, other_mut: Bool, other_origin: Origin[mut=other_mut], other_address_space: AddressSpace, //, dtype: DType, OtherEngine: TensorEngine](storage: Tuple[DevicePointer[dtype, self_origin], SelfLayoutType], other: Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType])
Floor-divides storage by other elementwise, in place.
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 right-hand storage operand. - other_mut (
Bool): The mutability of the right-hand storage operand. - other_origin (
Origin[mut=other_mut]): The origin of the right-hand storage operand. - other_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of both storages. - OtherEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the two engines have the same logical element size.
Args:
- storage (
Tuple[DevicePointer[dtype, self_origin], SelfLayoutType]): A tuple of the destination storage (modified in place) and its layout. - other (
Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType]): A tuple of the right-hand storage operand and its layout.
itruediv
static def itruediv[SelfLayoutType: TensorLayout, self_origin: MutOrigin, self_address_space: AddressSpace, OtherLayoutType: TensorLayout, other_mut: Bool, other_origin: Origin[mut=other_mut], other_address_space: AddressSpace, //, dtype: DType, OtherEngine: TensorEngine](storage: Tuple[DevicePointer[dtype, self_origin], SelfLayoutType], other: Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType])
True-divides storage by other elementwise, in place.
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 right-hand storage operand. - other_mut (
Bool): The mutability of the right-hand storage operand. - other_origin (
Origin[mut=other_mut]): The origin of the right-hand storage operand. - other_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of both storages. - OtherEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the two engines have the same logical element size.
Args:
- storage (
Tuple[DevicePointer[dtype, self_origin], SelfLayoutType]): A tuple of the destination storage (modified in place) and its layout. - other (
Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType]): A tuple of the right-hand storage operand and its layout.
imin
static def imin[SelfLayoutType: TensorLayout, self_origin: MutOrigin, self_address_space: AddressSpace, OtherLayoutType: TensorLayout, other_mut: Bool, other_origin: Origin[mut=other_mut], other_address_space: AddressSpace, //, dtype: DType, OtherEngine: TensorEngine](storage: Tuple[DevicePointer[dtype, self_origin], SelfLayoutType], other: Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType])
Takes the elementwise minimum of storage and other, in place.
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 right-hand storage operand. - other_mut (
Bool): The mutability of the right-hand storage operand. - other_origin (
Origin[mut=other_mut]): The origin of the right-hand storage operand. - other_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of both storages. - OtherEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the two engines have the same logical element size.
Args:
- storage (
Tuple[DevicePointer[dtype, self_origin], SelfLayoutType]): A tuple of the destination storage (modified in place) and its layout. - other (
Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType]): A tuple of the right-hand storage operand and its layout.
imax
static def imax[SelfLayoutType: TensorLayout, self_origin: MutOrigin, self_address_space: AddressSpace, OtherLayoutType: TensorLayout, other_mut: Bool, other_origin: Origin[mut=other_mut], other_address_space: AddressSpace, //, dtype: DType, OtherEngine: TensorEngine](storage: Tuple[DevicePointer[dtype, self_origin], SelfLayoutType], other: Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType])
Takes the elementwise maximum of storage and other, in place.
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 right-hand storage operand. - other_mut (
Bool): The mutability of the right-hand storage operand. - other_origin (
Origin[mut=other_mut]): The origin of the right-hand storage operand. - other_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of both storages. - OtherEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the two engines have the same logical element size.
Args:
- storage (
Tuple[DevicePointer[dtype, self_origin], SelfLayoutType]): A tuple of the destination storage (modified in place) and its layout. - other (
Tuple[OtherEngine.StorageType[other_mut, origin_of(other_origin), dtype, other_origin, other_address_space], OtherLayoutType]): A tuple of the right-hand storage operand and its layout.
iabs
static def iabs[dtype: DType, //](storage: DevicePointer[dtype], layout: T)
Takes the elementwise absolute value of storage, in place.
For unsigned dtypes this is the identity. Device-only: the underlying loads and stores reinterpret the encoded device pointer and abort on host.
Parameters:
- dtype (
DType): The element data type of the storage.
Args:
- storage (
DevicePointer[dtype]): The storage to modify in place. - layout (
T): The layout describing the storage's elements.
irecip
static def irecip[dtype: DType, //](storage: DevicePointer[dtype], layout: T)
Replaces each element of storage with its reciprocal, in place.
Elements equal to zero produce infinity, following IEEE 754 division semantics. Device-only: the underlying loads and stores reinterpret the encoded device pointer and abort on host.
Parameters:
- dtype (
DType): The element data type of the storage. Must be a floating-point type.
Args:
- storage (
DevicePointer[dtype]): The storage to modify in place. - layout (
T): The layout describing the storage's elements.
iexp
static def iexp[dtype: DType, scale_dtype: DType = dtype, //, scale: Scalar[scale_dtype]](storage: DevicePointer[dtype], layout: T)
Replaces each element x of storage with exp(scale * x), in place.
The scale factor is applied before exponentiation so that scaled
exponentials (for example softmax logit scaling) fuse into a single
pass over the elements. Pass a scale of 1 for a plain exponential.
Device-only: the underlying loads and stores reinterpret the encoded
device pointer and abort on host.
Parameters:
- dtype (
DType): The element data type of the storage. Must be a floating-point type. - scale_dtype (
DType): The data type of the scale factor. Defaults todtype; the scale is cast todtypebefore the multiplication. - scale (
Scalar[scale_dtype]): The compile-time factor each element is multiplied by before exponentiation.
Args:
- storage (
DevicePointer[dtype]): The storage to modify in place. - layout (
T): The layout describing the storage's elements.
add
static def add[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, LhsLayoutType: TensorLayout, lhs_mut: Bool, lhs_origin: Origin[mut=lhs_mut], lhs_address_space: AddressSpace, RhsLayoutType: TensorLayout, rhs_mut: Bool, rhs_origin: Origin[mut=rhs_mut], rhs_address_space: AddressSpace, //, dtype: DType, LhsEngine: TensorEngine, RhsEngine: TensorEngine](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], lhs: Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType], rhs: Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType])
Out-of-place elementwise add into dst.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - LhsLayoutType (
TensorLayout): The layout type of the left-hand storage operand. - lhs_mut (
Bool): The mutability of the left-hand storage operand. - lhs_origin (
Origin[mut=lhs_mut]): The origin of the left-hand storage operand. - lhs_address_space (
AddressSpace): The address space of the left-hand storage operand. - RhsLayoutType (
TensorLayout): The layout type of the right-hand storage operand. - rhs_mut (
Bool): The mutability of the right-hand storage operand. - rhs_origin (
Origin[mut=rhs_mut]): The origin of the right-hand storage operand. - rhs_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of all three storages. - LhsEngine (
TensorEngine): The engine of the left-hand operand. May differ fromSelfas long as the engines have the same logical element size. - RhsEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the engines have the same logical element size.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - lhs (
Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType]): A tuple of the left-hand storage operand and its layout. - rhs (
Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType]): A tuple of the right-hand storage operand and its layout.
mul
static def mul[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, LhsLayoutType: TensorLayout, lhs_mut: Bool, lhs_origin: Origin[mut=lhs_mut], lhs_address_space: AddressSpace, RhsLayoutType: TensorLayout, rhs_mut: Bool, rhs_origin: Origin[mut=rhs_mut], rhs_address_space: AddressSpace, //, dtype: DType, LhsEngine: TensorEngine, RhsEngine: TensorEngine](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], lhs: Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType], rhs: Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType])
Out-of-place elementwise mul into dst.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - LhsLayoutType (
TensorLayout): The layout type of the left-hand storage operand. - lhs_mut (
Bool): The mutability of the left-hand storage operand. - lhs_origin (
Origin[mut=lhs_mut]): The origin of the left-hand storage operand. - lhs_address_space (
AddressSpace): The address space of the left-hand storage operand. - RhsLayoutType (
TensorLayout): The layout type of the right-hand storage operand. - rhs_mut (
Bool): The mutability of the right-hand storage operand. - rhs_origin (
Origin[mut=rhs_mut]): The origin of the right-hand storage operand. - rhs_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of all three storages. - LhsEngine (
TensorEngine): The engine of the left-hand operand. May differ fromSelfas long as the engines have the same logical element size. - RhsEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the engines have the same logical element size.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - lhs (
Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType]): A tuple of the left-hand storage operand and its layout. - rhs (
Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType]): A tuple of the right-hand storage operand and its layout.
sub
static def sub[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, LhsLayoutType: TensorLayout, lhs_mut: Bool, lhs_origin: Origin[mut=lhs_mut], lhs_address_space: AddressSpace, RhsLayoutType: TensorLayout, rhs_mut: Bool, rhs_origin: Origin[mut=rhs_mut], rhs_address_space: AddressSpace, //, dtype: DType, LhsEngine: TensorEngine, RhsEngine: TensorEngine](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], lhs: Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType], rhs: Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType])
Out-of-place elementwise sub into dst.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - LhsLayoutType (
TensorLayout): The layout type of the left-hand storage operand. - lhs_mut (
Bool): The mutability of the left-hand storage operand. - lhs_origin (
Origin[mut=lhs_mut]): The origin of the left-hand storage operand. - lhs_address_space (
AddressSpace): The address space of the left-hand storage operand. - RhsLayoutType (
TensorLayout): The layout type of the right-hand storage operand. - rhs_mut (
Bool): The mutability of the right-hand storage operand. - rhs_origin (
Origin[mut=rhs_mut]): The origin of the right-hand storage operand. - rhs_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of all three storages. - LhsEngine (
TensorEngine): The engine of the left-hand operand. May differ fromSelfas long as the engines have the same logical element size. - RhsEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the engines have the same logical element size.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - lhs (
Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType]): A tuple of the left-hand storage operand and its layout. - rhs (
Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType]): A tuple of the right-hand storage operand and its layout.
floordiv
static def floordiv[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, LhsLayoutType: TensorLayout, lhs_mut: Bool, lhs_origin: Origin[mut=lhs_mut], lhs_address_space: AddressSpace, RhsLayoutType: TensorLayout, rhs_mut: Bool, rhs_origin: Origin[mut=rhs_mut], rhs_address_space: AddressSpace, //, dtype: DType, LhsEngine: TensorEngine, RhsEngine: TensorEngine](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], lhs: Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType], rhs: Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType])
Out-of-place elementwise floordiv into dst.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - LhsLayoutType (
TensorLayout): The layout type of the left-hand storage operand. - lhs_mut (
Bool): The mutability of the left-hand storage operand. - lhs_origin (
Origin[mut=lhs_mut]): The origin of the left-hand storage operand. - lhs_address_space (
AddressSpace): The address space of the left-hand storage operand. - RhsLayoutType (
TensorLayout): The layout type of the right-hand storage operand. - rhs_mut (
Bool): The mutability of the right-hand storage operand. - rhs_origin (
Origin[mut=rhs_mut]): The origin of the right-hand storage operand. - rhs_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of all three storages. - LhsEngine (
TensorEngine): The engine of the left-hand operand. May differ fromSelfas long as the engines have the same logical element size. - RhsEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the engines have the same logical element size.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - lhs (
Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType]): A tuple of the left-hand storage operand and its layout. - rhs (
Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType]): A tuple of the right-hand storage operand and its layout.
truediv
static def truediv[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, LhsLayoutType: TensorLayout, lhs_mut: Bool, lhs_origin: Origin[mut=lhs_mut], lhs_address_space: AddressSpace, RhsLayoutType: TensorLayout, rhs_mut: Bool, rhs_origin: Origin[mut=rhs_mut], rhs_address_space: AddressSpace, //, dtype: DType, LhsEngine: TensorEngine, RhsEngine: TensorEngine](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], lhs: Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType], rhs: Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType])
Out-of-place elementwise truediv into dst.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - LhsLayoutType (
TensorLayout): The layout type of the left-hand storage operand. - lhs_mut (
Bool): The mutability of the left-hand storage operand. - lhs_origin (
Origin[mut=lhs_mut]): The origin of the left-hand storage operand. - lhs_address_space (
AddressSpace): The address space of the left-hand storage operand. - RhsLayoutType (
TensorLayout): The layout type of the right-hand storage operand. - rhs_mut (
Bool): The mutability of the right-hand storage operand. - rhs_origin (
Origin[mut=rhs_mut]): The origin of the right-hand storage operand. - rhs_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of all three storages. - LhsEngine (
TensorEngine): The engine of the left-hand operand. May differ fromSelfas long as the engines have the same logical element size. - RhsEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the engines have the same logical element size.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - lhs (
Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType]): A tuple of the left-hand storage operand and its layout. - rhs (
Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType]): A tuple of the right-hand storage operand and its layout.
min
static def min[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, LhsLayoutType: TensorLayout, lhs_mut: Bool, lhs_origin: Origin[mut=lhs_mut], lhs_address_space: AddressSpace, RhsLayoutType: TensorLayout, rhs_mut: Bool, rhs_origin: Origin[mut=rhs_mut], rhs_address_space: AddressSpace, //, dtype: DType, LhsEngine: TensorEngine, RhsEngine: TensorEngine](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], lhs: Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType], rhs: Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType])
Out-of-place elementwise min into dst.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - LhsLayoutType (
TensorLayout): The layout type of the left-hand storage operand. - lhs_mut (
Bool): The mutability of the left-hand storage operand. - lhs_origin (
Origin[mut=lhs_mut]): The origin of the left-hand storage operand. - lhs_address_space (
AddressSpace): The address space of the left-hand storage operand. - RhsLayoutType (
TensorLayout): The layout type of the right-hand storage operand. - rhs_mut (
Bool): The mutability of the right-hand storage operand. - rhs_origin (
Origin[mut=rhs_mut]): The origin of the right-hand storage operand. - rhs_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of all three storages. - LhsEngine (
TensorEngine): The engine of the left-hand operand. May differ fromSelfas long as the engines have the same logical element size. - RhsEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the engines have the same logical element size.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - lhs (
Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType]): A tuple of the left-hand storage operand and its layout. - rhs (
Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType]): A tuple of the right-hand storage operand and its layout.
max
static def max[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, LhsLayoutType: TensorLayout, lhs_mut: Bool, lhs_origin: Origin[mut=lhs_mut], lhs_address_space: AddressSpace, RhsLayoutType: TensorLayout, rhs_mut: Bool, rhs_origin: Origin[mut=rhs_mut], rhs_address_space: AddressSpace, //, dtype: DType, LhsEngine: TensorEngine, RhsEngine: TensorEngine](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], lhs: Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType], rhs: Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType])
Out-of-place elementwise max into dst.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - LhsLayoutType (
TensorLayout): The layout type of the left-hand storage operand. - lhs_mut (
Bool): The mutability of the left-hand storage operand. - lhs_origin (
Origin[mut=lhs_mut]): The origin of the left-hand storage operand. - lhs_address_space (
AddressSpace): The address space of the left-hand storage operand. - RhsLayoutType (
TensorLayout): The layout type of the right-hand storage operand. - rhs_mut (
Bool): The mutability of the right-hand storage operand. - rhs_origin (
Origin[mut=rhs_mut]): The origin of the right-hand storage operand. - rhs_address_space (
AddressSpace): The address space of the right-hand storage operand. - dtype (
DType): The element data type of all three storages. - LhsEngine (
TensorEngine): The engine of the left-hand operand. May differ fromSelfas long as the engines have the same logical element size. - RhsEngine (
TensorEngine): The engine of the right-hand operand. May differ fromSelfas long as the engines have the same logical element size.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - lhs (
Tuple[LhsEngine.StorageType[lhs_mut, origin_of(lhs_origin), dtype, lhs_origin, lhs_address_space], LhsLayoutType]): A tuple of the left-hand storage operand and its layout. - rhs (
Tuple[RhsEngine.StorageType[rhs_mut, origin_of(rhs_origin), dtype, rhs_origin, rhs_address_space], RhsLayoutType]): A tuple of the right-hand storage operand and its layout.
abs
static def abs[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, SrcLayoutType: TensorLayout, src_mut: Bool, src_origin: Origin[mut=src_mut], src_address_space: AddressSpace, //, dtype: DType, SrcEngine: TensorEngine](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], src: Tuple[SrcEngine.StorageType[src_mut, origin_of(src_origin), dtype, src_origin, src_address_space], SrcLayoutType])
Out-of-place elementwise abs into dst. Device-only when Self or SrcEngine reinterprets a device pointer.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - SrcLayoutType (
TensorLayout): The layout type of the source storage. - src_mut (
Bool): The mutability of the source storage. - src_origin (
Origin[mut=src_mut]): The origin of the source storage. - src_address_space (
AddressSpace): The address space of the source storage. - dtype (
DType): The element data type of both storages. - SrcEngine (
TensorEngine): The engine of the source. May differ fromSelfas long as the two engines have the same logical element size.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - src (
Tuple[SrcEngine.StorageType[src_mut, origin_of(src_origin), dtype, src_origin, src_address_space], SrcLayoutType]): A tuple of the source storage and its layout.
recip
static def recip[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, SrcLayoutType: TensorLayout, src_mut: Bool, src_origin: Origin[mut=src_mut], src_address_space: AddressSpace, //, dtype: DType, SrcEngine: TensorEngine](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], src: Tuple[SrcEngine.StorageType[src_mut, origin_of(src_origin), dtype, src_origin, src_address_space], SrcLayoutType])
Out-of-place elementwise recip into dst. Device-only when Self or SrcEngine reinterprets a device pointer.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - SrcLayoutType (
TensorLayout): The layout type of the source storage. - src_mut (
Bool): The mutability of the source storage. - src_origin (
Origin[mut=src_mut]): The origin of the source storage. - src_address_space (
AddressSpace): The address space of the source storage. - dtype (
DType): The element data type of both storages. - SrcEngine (
TensorEngine): The engine of the source. May differ fromSelfas long as the two engines have the same logical element size.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - src (
Tuple[SrcEngine.StorageType[src_mut, origin_of(src_origin), dtype, src_origin, src_address_space], SrcLayoutType]): A tuple of the source storage and its layout.
exp
static def exp[DstLayoutType: TensorLayout, dst_origin: MutOrigin, dst_address_space: AddressSpace, SrcLayoutType: TensorLayout, src_mut: Bool, src_origin: Origin[mut=src_mut], src_address_space: AddressSpace, dtype: DType, SrcEngine: TensorEngine, scale_dtype: DType = dtype, //, scale: Scalar[scale_dtype] = 1](*, dst: Tuple[DevicePointer[dtype, dst_origin], DstLayoutType], src: Tuple[SrcEngine.StorageType[src_mut, origin_of(src_origin), dtype, src_origin, src_address_space], SrcLayoutType])
Writes exp(scale * x) for each element x of src into dst. Device-only when Self or SrcEngine reinterprets a device pointer.
Parameters:
- DstLayoutType (
TensorLayout): The layout type of the destination storage. - dst_origin (
MutOrigin): The origin of the destination storage. - dst_address_space (
AddressSpace): The address space of the destination storage. - SrcLayoutType (
TensorLayout): The layout type of the source storage. - src_mut (
Bool): The mutability of the source storage. - src_origin (
Origin[mut=src_mut]): The origin of the source storage. - src_address_space (
AddressSpace): The address space of the source storage. - dtype (
DType): The element data type of both storages. Must be a floating-point type. - SrcEngine (
TensorEngine): The engine of the source. May differ fromSelfas long as the two engines have the same logical element size. - scale_dtype (
DType): The data type of the scale factor. Defaults todtype; the scale is cast todtypebefore the multiplication. - scale (
Scalar[scale_dtype]): The compile-time factor each element is multiplied by before exponentiation.
Args:
- dst (
Tuple[DevicePointer[dtype, dst_origin], DstLayoutType]): A tuple of the destination storage and its layout. - src (
Tuple[SrcEngine.StorageType[src_mut, origin_of(src_origin), dtype, src_origin, src_address_space], SrcLayoutType]): A tuple of the source storage and its layout.