Struct pjrt_sys::protos::xla::LayoutProto

pub struct LayoutProto {

    pub dim_level_types: Vec<i32>,
    pub dim_unique: Vec<bool>,
    pub dim_ordered: Vec<bool>,
    pub minor_to_major: Vec<i64>,
    pub tiles: Vec<TileProto>,
    pub tail_padding_alignment_in_elements: i64,
    pub element_size_in_bits: i64,
    pub memory_space: i64,
    pub index_primitive_type: i32,
    pub pointer_primitive_type: i32,
    pub physical_shape: Option<Box<ShapeProto>>,
    pub dynamic_shape_metadata_prefix_bytes: i64,
    pub split_configs: Vec<SplitConfigProto>,
}

A layout describes how the array is placed in (1D) memory space. This includes the minor-to-major ordering of dimensions within a shape.

Clients must specify the layouts of input Literals to the computation. Layouts specified in interior operations which take Shapes (for example, Convert) are ignored.

See the XLA documentation for more information on shapes and layouts.

LINT.IfChange

Fields

dim_level_types: Vec<i32>

The dimension level type list for this array, specifying the way in which each array dimension is represented in memory. If this list is empty, the array is assumed to be dense.

dim_unique: Vec<bool>

Whether each dimension is unique or ordered. Each of the following lists must be empty, or have one entry for each entry of dim_level_types. If either list is empty, all dimensions are assumed to be unique and ordered, respectively. Entries in this list may not be false for some DimLevelType values (such as DIM_DENSE in particular).

dim_ordered: Vec<bool>

minor_to_major: Vec<i64>

Sequence of dimension numbers, from minor (fastest varying index) to major (slowest varying index). This field is required.

tiles: Vec<TileProto>

A sequence of tiles, starting from the tile that’s applied first to the Shape.

TODO(b/119839262): implement tiling in each backend or add Unimplemented error.

tail_padding_alignment_in_elements: i64

The shape is padded at the end to multiple of, in terms of number of elements. This is useful when tiling does not bring the shape to certain desired granules. Tiling effectively pads/reshapes/transposes the shape to another shape. This field pads the total number of elements of that new shape to a multiple of certain number of elements. This is useful such as we want a layout which does not tile the data but still requires it to be padded to certain number of elements.

element_size_in_bits: i64

(Optional) Bit size of each element. When unspecified or being 0, default to ShapeUtil::ByteSizeOfPrimitiveType.

memory_space: i64

Memory space where this array resides. The integer field is interpreted in a backend-specific manner.

index_primitive_type: i32

The integer types to be used for indices and pointers. These fields must not be used unless the layout represents a sparse array. The PrimitiveType must correspond to an unsigned integer (U8, U16, U32, or U64). If not provided, the compiler will use the largest unsigned integer that is naturally supported by the target device (U32 or U64 in currently supported devices).

pointer_primitive_type: i32

physical_shape: Option<Box<ShapeProto>>

The physical, on-device shape used to represent the shape this layout belongs to. Only used for sparse arrays. The layout(s) contained within the physical shape should not also contain a physical shape.

dynamic_shape_metadata_prefix_bytes: i64

The dynamic shape metadata size in bytes in front of the shape data. The field may be non-zero for a static shape whose associated buffer is for a dynamic shape, e.g. a result of SliceToDynamic.

split_configs: Vec<SplitConfigProto>

The split configurations which describe if/how the data is split between different memories.

Implementations

impl LayoutProto

pub fn dim_level_types( &self, ) -> FilterMap<Cloned<Iter<'_, i32>>, fn(_: i32) -> Option<DimLevelType>>

Returns an iterator which yields the valid enum values contained in dim_level_types.

pub fn push_dim_level_types(&mut self, value: DimLevelType)

Appends the provided enum value to dim_level_types.

pub fn index_primitive_type(&self) -> PrimitiveType

Returns the enum value of index_primitive_type, or the default if the field is set to an invalid enum value.

pub fn set_index_primitive_type(&mut self, value: PrimitiveType)

Sets index_primitive_type to the provided enum value.

pub fn pointer_primitive_type(&self) -> PrimitiveType

Returns the enum value of pointer_primitive_type, or the default if the field is set to an invalid enum value.

pub fn set_pointer_primitive_type(&mut self, value: PrimitiveType)

Sets pointer_primitive_type to the provided enum value.

Trait Implementations

impl Clone for LayoutProto

fn clone(&self) -> LayoutProto

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LayoutProto

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

Formats the value using the given formatter.

impl Default for LayoutProto

fn default() -> Self

Returns the “default value” for a type.

impl Message for LayoutProto

fn encoded_len(&self) -> usize

Returns the encoded length of the message without a length delimiter.

fn clear(&mut self)

Clears the message, resetting all fields to their default.

fn encode(&self, buf: &mut impl BufMut) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message to a buffer.

fn encode_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message to a newly allocated buffer.

fn encode_length_delimited( &self, buf: &mut impl BufMut, ) -> Result<(), EncodeError>

where Self: Sized,

Encodes the message with a length-delimiter to a buffer.

fn encode_length_delimited_to_vec(&self) -> Vec<u8>

where Self: Sized,

Encodes the message with a length-delimiter to a newly allocated buffer.

fn decode(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes an instance of the message from a buffer.

fn decode_length_delimited(buf: impl Buf) -> Result<Self, DecodeError>

where Self: Default,

Decodes a length-delimited instance of the message from the buffer.

fn merge(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes an instance of the message from a buffer, and merges it into self.

fn merge_length_delimited(&mut self, buf: impl Buf) -> Result<(), DecodeError>

where Self: Sized,

Decodes a length-delimited instance of the message from buffer, and merges it into self.

impl PartialEq for LayoutProto

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