Enum PtxType 

pub enum PtxType {
    U8,
    U16,
    U32,
    U64,
    S8,
    S16,
    S32,
    S64,
    F16,
    F16x2,
    BF16,
    BF16x2,
    F32,
    F64,
    TF32,
    E4M3,
    E5M2,
    E2M3,
    E3M2,
    E2M1,
    B8,
    B16,
    B32,
    B64,
    B128,
    Pred,
}

PTX data types as defined in the PTX ISA.

Covers unsigned/signed integers, all floating-point widths (including FP8/FP6/FP4 formats introduced in Hopper and Blackwell architectures), untyped bit-width types, and predicates.

Variants

U8

8-bit unsigned integer.

U16

16-bit unsigned integer.

U32

32-bit unsigned integer.

U64

64-bit unsigned integer.

S8

8-bit signed integer.

S16

16-bit signed integer.

S32

32-bit signed integer.

S64

64-bit signed integer.

F16

IEEE 754 half-precision (16-bit) float.

F16x2

Packed pair of half-precision floats.

BF16

Brain floating-point (16-bit, 8-bit exponent).

BF16x2

Packed pair of BF16 floats.

F32

IEEE 754 single-precision (32-bit) float.

F64

IEEE 754 double-precision (64-bit) float.

TF32

TensorFloat-32 (19-bit, used in Tensor Cores).

E4M3

FP8 E4M3 format (Hopper+).

E5M2

FP8 E5M2 format (Hopper+).

E2M3

FP6 E2M3 format (Blackwell).

E3M2

FP6 E3M2 format (Blackwell).

E2M1

FP4 E2M1 format (Blackwell).

B8

8-bit untyped.

B16

16-bit untyped.

B32

32-bit untyped.

B64

64-bit untyped.

B128

128-bit untyped.

Pred

1-bit predicate register type.

Implementations

impl PtxType

pub const fn as_ptx_str(&self) -> &'static str

Returns the PTX ISA string representation of this type (e.g., ".f32", ".u64").

pub const fn size_bytes(&self) -> usize

Returns the size in bytes of a single value of this type.

Packed types (e.g., F16x2) return the size of the packed value. Predicates return 1 byte (the minimum addressable unit).

pub const fn reg_type(&self) -> Self

Returns the register-width class type used in .reg declarations.

PTX uses register classes based on width: 16-bit, 32-bit, 64-bit, and predicate. Sub-32-bit types are promoted to 32-bit registers; 128-bit uses 64-bit pairs.

pub const fn is_integer(&self) -> bool

Returns true if this is an integer type (signed or unsigned).

pub const fn is_float(&self) -> bool

Returns true if this is a floating-point type (including packed and special formats).

pub const fn bit_width(&self) -> u32

Returns the bit-width of a single element of this type.

For sub-byte types (E2M1 = FP4), returns 4. For packed types like F16x2 and BF16x2, returns the total packed width (32 bits). Predicates are reported as 1 bit.

pub const fn is_signed(&self) -> bool

Returns true if this is a signed type (signed integers or all floats).

Trait Implementations

impl Clone for PtxType

fn clone(&self) -> PtxType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PtxType

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

Formats the value using the given formatter.

impl Display for PtxType

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

Formats the type as its PTX ISA string without the leading dot.

For example, PtxType::F32 displays as "f32", and PtxType::E2M1 displays as "e2m1".

impl Hash for PtxType

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 PartialEq for PtxType

fn eq(&self, other: &PtxType) -> 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 Copy for PtxType

impl Eq for PtxType

impl StructuralPartialEq for PtxType