Enum PrimitiveType 

#[repr(i32)]
pub enum PrimitiveType {
    Invalid = 0,
    Pred = 1,
    S2 = 26,
    S4 = 21,
    S8 = 2,
    S16 = 3,
    S32 = 4,
    S64 = 5,
    U2 = 27,
    U4 = 22,
    U8 = 6,
    U16 = 7,
    U32 = 8,
    U64 = 9,
    F16 = 10,
    F32 = 11,
    Bf16 = 16,
    F64 = 12,
    F8e5m2 = 19,
    F8e4m3fn = 20,
    F8e4m3b11fnuz = 23,
    F8e5m2fnuz = 24,
    F8e4m3fnuz = 25,
    C64 = 15,
    C128 = 18,
    Tuple = 13,
    OpaqueType = 14,
    Token = 17,
}

Primitive types are the individual values that can be held in rectangular multidimensional arrays. A description of the rectangular multidimensional array dimensions / primitive type is given by Shape, below.

LINT.IfChange

Variants

Invalid = 0

Invalid primitive type to serve as default.

Pred = 1

Predicates are two-state booleans.

S2 = 26

Signed integral values of fixed width.

S4 = 21

S8 = 2

S16 = 3

S32 = 4

S64 = 5

U2 = 27

Unsigned integral values of fixed width.

U4 = 22

U8 = 6

U16 = 7

U32 = 8

U64 = 9

F16 = 10

Floating-point values of fixed width.

Note: if f16s are not natively supported on the device, they will be converted to f16 from f32 at arbirary points in the computation.

F32 = 11

Bf16 = 16

Truncated 16 bit floating-point format. This is similar to IEEE’s 16 bit floating-point format, but uses 1 bit for the sign, 8 bits for the exponent and 7 bits for the mantissa.

F64 = 12

F8e5m2 = 19

FP8 dtypes, as described in this paper: https://arxiv.org/abs/2209.05433

F8E5M2 has 5 exponent bits and 2 mantissa bits, and is similar to the existing IEEE types.

F8E4M3FN has 4 exponent bits and 3 mantissa bits. The “FN” means only Finite and NaN values are supported. Unlike IEEE types, infinities are not supported. NaN is represented when the exponent and mantissa bits are all 1s. All other values are finite.

F8E4M3B11FNUZ has 4 exponent bits and 3 mantissa bits and a bias of 11. The “FNUZ” means only Finite and NaN values are supported; zero is unsigned. Unlike IEEE types, infinities are not supported. NaN is represented when the exponent and mantissa bits are all 0s with a sign bit of 1. All other values are finite.

Support for these dtypes is under development. They do not yet work properly in most cases. TODO(b/259609697): Fully support FP8.

F8e4m3fn = 20

F8e4m3b11fnuz = 23

F8e5m2fnuz = 24

FP8 dtypes, as described in this paper: https://arxiv.org/abs/2206.02915

F8E5M2FNUZ has 5 exponent bits and 2 mantissa bits. F8E4M3FNUZ has 4 exponent bits and 3 mantissa bits.

The “FNUZ” means only Finite and NaN values are supported; zero is unsigned. Unlike IEEE types, infinities are not supported. NaN is represented when the exponent and mantissa bits are all 0s with a sign bit of 1. All other values are finite.

These differences mean there’s an additional exponent value available. To keep the same dynamic range as an IEEE-like FP8 type, the exponent is biased one more than would be expected given the number of exponent bits (8 for Float8E4M3FNUZ and 16 for Float8E5M2FNUZ).

F8e4m3fnuz = 25

C64 = 15

Complex values of fixed width.

Paired F32 (real, imag), as in std::complex.

C128 = 18

Paired F64 (real, imag), as in std::complex.

Tuple = 13

A tuple is a polymorphic sequence; e.g. a shape that holds different sub-shapes. They are used for things like returning multiple values from a computation; e.g. a computation that returns weights and biases may have a signature that results in a tuple like (f32[784x2000], f32[2000])

If a shape proto has the tuple element type, it may not have any entries in the dimensions field.

OpaqueType = 14

An opaque type used for passing context-specific data to a custom operation. Shapes of this primitive type will have empty dimensions and tuple_shapes fields.

(OPAQUE would be a better name for this identifier, but that conflicts with a macro defined in windows.h.)

Token = 17

A token type threaded between side-effecting operations. Shapes of this primitive type will have empty dimensions and tuple_shapes fields.

Implementations

impl PrimitiveType

pub fn is_valid(value: i32) -> bool

Returns true if value is a variant of PrimitiveType.

pub fn from_i32(value: i32) -> Option<PrimitiveType>

👎Deprecated: Use the TryFrom<i32> implementation instead

Converts an i32 to a PrimitiveType, or None if value is not a valid variant.

impl PrimitiveType

pub fn as_str_name(&self) -> &'static str

String value of the enum field names used in the ProtoBuf definition.

The values are not transformed in any way and thus are considered stable (if the ProtoBuf definition does not change) and safe for programmatic use.

pub fn from_str_name(value: &str) -> Option<Self>

Creates an enum from field names used in the ProtoBuf definition.

Trait Implementations

impl Clone for PrimitiveType

fn clone(&self) -> PrimitiveType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PrimitiveType

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

Formats the value using the given formatter.

impl Default for PrimitiveType

fn default() -> PrimitiveType

Returns the “default value” for a type.

impl From<PrimitiveType> for i32

fn from(value: PrimitiveType) -> i32

Converts to this type from the input type.

impl Hash for PrimitiveType

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 PrimitiveType

fn cmp(&self, other: &PrimitiveType) -> 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 PrimitiveType

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

fn partial_cmp(&self, other: &PrimitiveType) -> 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 TryFrom<i32> for PrimitiveType

type Error = UnknownEnumValue

The type returned in the event of a conversion error.

fn try_from(value: i32) -> Result<PrimitiveType, UnknownEnumValue>

Performs the conversion.

impl Copy for PrimitiveType

impl Eq for PrimitiveType

impl StructuralPartialEq for PrimitiveType