Struct RudaTensor 

pub struct RudaTensor<R>
where
    R: Runtime,
{
    pub client: ComputeClient<R>,
    pub handle: Handle,
    pub meta: Box<Metadata>,
    pub device: <R as Runtime>::Device,
    pub dtype: DType,
    pub qparams: Option<QParams<QParamTensor>>,
}

The basic tensor primitive struct.

Fields

client: ComputeClient<R>

Compute client for the runtime.

handle: Handle

The buffer where the data are stored.

meta: Box<Metadata>

The metadata of the tensor.

device: <R as Runtime>::Device

The device of the tensor.

dtype: DType

The datatype of the tensor.

qparams: Option<QParams<QParamTensor>>

Runtime quantization parameters, if applicable

Implementations

impl<R> RudaTensor<R>

where R: Runtime,

pub fn autotune_signature(&self) -> String

Exact tuning metadata, including view offsets and accessible storage size. Deliberately excludes allocation ids so equivalent invocations can share a cache entry.

pub fn new( client: ComputeClient<R>, handle: Handle, metadata: Metadata, device: <R as Runtime>::Device, dtype: DType, ) -> RudaTensor<R>

Create a new standard tensor

pub fn new_contiguous( client: ComputeClient<R>, device: <R as Runtime>::Device, shape: Shape, handle: Handle, dtype: DType, ) -> RudaTensor<R>

Create a new tensor with a contiguous memory layout.

pub fn to_client( &mut self, client: ComputeClient<R>, device: <R as Runtime>::Device, ) -> RudaTensor<R>

Change the context of the current tensor and return the newly transferred tensor.

pub fn binding(self) -> TensorBinding<R>

Return the reference to a tensor handle.

pub fn elem_size(&self) -> usize

Returns the element size of this tensor

pub fn into_tensor_arg(self) -> TensorArg<R>

Return the reference to a tensor argument.

pub fn into_array_arg(self) -> ArrayArg<R>

Return the reference to an array argument.

pub fn as_tensor_alias(&self, input_pos: usize) -> TensorArg<R>

Returns a reference to the aliased tensor argument.

pub fn into_linear_view(self) -> ViewArg<usize, R>

Return a linear view of this tensor.

pub fn as_linear_view_alias(&self, input_pos: usize) -> ViewArg<usize, R>

Return an aliased linear view of this tensor

pub fn into_linear_view_like( self, reference: &RudaTensor<R>, ) -> ViewArg<usize, R>

Return a linear view broadcast to the reference tensor’s shape

pub fn required_address_type(&self) -> AddressType

Returns the address type required to index this tensor

pub fn try_scheme(&self) -> Option<&QuantScheme>

Return the QuantScheme if present

pub fn can_mut_broadcast(&self, rhs: &RudaTensor<R>) -> bool

pub fn copy(&self) -> RudaTensor<R>

Copy the current tensor.

pub fn can_mut(&self) -> bool

Check if the tensor is safe to mutate.

pub fn assert_is_on_same_device(&self, other: &RudaTensor<R>)

where <R as Runtime>::Device: PartialEq,

Assert that both tensors are on the same device.

pub fn is_contiguous(&self) -> bool

Check if the current tensor is contiguous.

A tensor is contiguous if the elements are stored in memory if the strides in non-increasing order and the strides at position k is equal to the product of the shapes at all positions greater than k. However, all axes with a shape of 1 are ignored.

pub fn is_contiguous_buffer(&self) -> bool

Check if the current tensor has a contiguous backing buffer (no overlap and no empty memory regions within the shape).

pub fn is_nonoverlapping(&self) -> bool

Checks if the tensor is non-overlapping (can be safely written to).

impl<R> RudaTensor<R>

where R: Runtime,

pub fn new_quantized( client: ComputeClient<R>, handle: Handle, shape: Shape, device: <R as Runtime>::Device, strides: Strides, dtype: DType, qparams: QParams<QParamTensor>, ) -> RudaTensor<R>

Create a new quantized tensor

pub fn quantized_handles(&self) -> Option<(RudaTensor<R>, RudaTensor<R>)>

Returns the two tensors: (values, params) for a quantized tensor. For the values, native types that aren’t supported as a normal DType will be returned as an unsigned integer tensor representing the bits. Should be reconstructed using from_bits in kernels.

pub fn scales(&self) -> Option<RudaTensor<R>>

Construct a separate tensor for the quantization scales, if present

Trait Implementations

impl<R> AutotuneOutput for RudaTensor<R>

where R: Runtime,

fn validate_for_tuning( &self, other: &RudaTensor<R>, absolute: f64, relative: f64, max_bytes: u64, ) -> Result<bool, String>

Fallible correctness gate for stack autotuning. Ok(false) explicitly means that this output has no validator; a successful launch alone is NOT a correctness check. Existing implementers need not add a method. Strict stack policy rejects unsupported output.

impl<R> Clone for RudaTensor<R>

where R: Runtime,

fn clone(&self) -> RudaTensor<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R> Debug for RudaTensor<R>

where R: Runtime,

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

Formats the value using the given formatter.

impl<R> QTensorPrimitive for RudaTensor<R>

where R: Runtime,

fn scheme(&self) -> &QuantScheme

Returns the quantization settings for the given tensor.

fn acc_precision(&self) -> QuantAcc

The precision used for the accumulation in various kernels.

fn propagation(&self) -> QuantPropagation

How quantization is propagated during computation.

fn default_scheme() -> QuantScheme

Returns the default tensor quantization scheme.

impl<R> RequiredAddrType for RudaTensor<R>

where R: Runtime,

fn required_address_type(&self) -> AddressType

impl<R> TensorMetadata for RudaTensor<R>

where R: Runtime,

fn dtype(&self) -> DType

The dtype of the tensor.

fn shape(&self) -> Shape

The shape of the tensor.

fn rank(&self) -> usize

The number of dimensions of the tensor.