Data types

Data types#

2026-01-28

20 min read time

Applies to Linux

shape#

struct shape#

Public Types

enum type_t#

Values:

enumerator bool_type#

enumerator half_type#

enumerator float_type#

enumerator double_type#

enumerator uint8_type#

enumerator int8_type#

enumerator uint16_type#

enumerator int16_type#

enumerator int32_type#

enumerator int64_type#

enumerator uint32_type#

enumerator uint64_type#

enumerator fp8e4m3fnuz_type#

enumerator fp8e4m3fn_type#

enumerator fp8e5m2_type#

enumerator bf16_type#

enumerator fp8e5m2fnuz_type#

enumerator tuple_type#

enumerator fp4x2_type#

Public Functions

shape()#

shape(type_t t)#

shape(type_t t, std::vector<std::size_t> l)#

shape(type_t t, std::vector<std::size_t> l, std::vector<std::size_t> s)#

shape(type_t t, std::initializer_list<std::size_t> d)#

shape(type_t t, std::vector<dynamic_dimension> dims)#

shape(type_t t, std::vector<std::size_t> mins, std::vector<std::size_t> maxes, std::vector<std::set<std::size_t>> optimals_list)#

template<class Range> inline shape(type_t t, const Range &l)#

template<class Range1, class Range2> inline shape(type_t t, const Range1 &l, const Range2 &s)#

explicit shape(const std::vector<shape> &subs)#

type_t type() const#

const std::vector<std::size_t> &lens() const#

const std::vector<std::size_t> &strides() const#

std::size_t ndim() const#: The number of dimensions in the shape, either static or dynamic. Same as the number of indices required to get a data value.

std::size_t elements() const#: Return the number of elements in the tensor.

std::size_t bytes() const#: Return the number of total bytes used for storage of the tensor data; includes subshapes. For dynamic shape, returns the maximum number of bytes presuming a packed shape.

std::size_t type_size() const#: Return the size of the type of the main shape. Returns 0 if there are subshapes.

const std::vector<dynamic_dimension> &dyn_dims() const#

std::vector<std::size_t> min_lens() const#: Minimum lengths for dynamic shape. lens() for static shape.

std::vector<std::size_t> max_lens() const#: Maximum lengths for dynamic shape. lens() for static shape.

std::vector<std::set<std::size_t>> opt_lens() const#: Optimum lengths for dynamic shape. Empty for static shape.

std::size_t index(std::initializer_list<std::size_t> l) const#: Map multiple indices to space index.

std::size_t index(const std::vector<std::size_t> &l) const#: Map multiple indices to space index.

template<class Iterator> inline std::size_t index(Iterator start, Iterator last) const#: Map multiple indices from a range of iterator to a space index.

std::size_t index(std::size_t i) const#: Map element index to space index.

std::vector<std::size_t> multi(std::size_t idx) const#: Map element index to multi-dimensional index.

void multi_copy(std::size_t idx, std::size_t *start, const std::size_t *end) const#: Map element index to multi-dimensional index and put them them into location provided by pointers

template<std::size_t N> inline std::array<std::size_t, N> multi(std::size_t idx) const#: Map element index to multi-dimensional index and return them as an array of size N. If the rank is smaller then N, the remaining dimensions will be set to 0. If the rank is larger than N, an exception will be thrown.

bool multi_within_bounds(std::vector<std::size_t> multi) const#: Check if a multi-dimensional index is within bounds for the shape.

template<class Iterator> inline std::size_t single(Iterator start, Iterator last) const#: Convert multi-dimensional index into a single element index.

std::size_t single(const std::vector<std::size_t> &idx) const#: Convert multi-dimensional index into a single element index.

bool packed() const#: Returns true if the shape is packed (number of elements and buffer size the same) with no padding

bool transposed() const#: Returns true if the shape has been transposed. That is the strides are not in descending order

bool broadcasted() const#: Returns true if the shape is broadcasting a dimension. That is, one of the strides are zero.

bool standard() const#: Returns true if the shape is in its standard format. That is, the shape is both packed and not transposed.

bool scalar() const#: Returns true if all strides are equal to 0 (scalar tensor)

bool dynamic() const#: Return true if the shape is dynamic.

bool any_of_dynamic() const#: Return true if this shape or any of the sub_shapes are dynamic.

bool computable() const#: If type is computable (can do math ops like add or divide) and has a visitor function.

shape normalize_standard() const#

shape as_standard() const#

shape with_lens(type_t t, const std::vector<std::size_t> &l) const#

shape with_lens(const std::vector<std::size_t> &l) const#

shape with_type(type_t t) const#

shape to_dynamic() const#

shape to_static(std::size_t x) const#

template<class ...Visitors> inline void visit_type(Visitors... vs) const#

std::string type_string() const#

const std::vector<shape> &sub_shapes() const#

std::size_t tuple_size() const#

std::size_t element_space() const#: Returns the number of elements in the data buffer. For a dynamic shape, returns the maximum number of elements of the data buffer and assumes it is packed. Will clip to the maximum of size_t if overflows for dynamic shapes.

void debug_print() const#

Public Static Functions

static std::string to_sizes_string(const std::vector<shape> &shapes)#

static const std::vector<type_t> &types()#

static std::string name(type_t t)#

static std::string cpp_type(type_t t)#

static bool is_integral(type_t t)#

static bool is_compatible(const shape &actual, const shape &expected)#

static bool is_compatible_lens(const shape &actual, const shape &expected)#

static bool is_unsigned(type_t t)#

static bool is_computable(type_t t)#

static shape from_permutation(type_t t, const std::vector<std::size_t> &l, const std::vector<int64_t> &perm)#

Creates an output shape with dimensions l and strides computed to fulfill the given permutation.

t = shape type l = output dimensions perm = order dimensions from slowest dimension to fastest dimension

Example: t = float_type, l = [2, 3, 4], perm = [1, 2, 0] axis=1 to slowest dimension, axis=2 to second slowest, axis=0 to fastest returns shape{type = float, lens = [2, 3, 4], strides = [1, 8 ,2]}

static bool same_lens(const shape &x, const shape &y)#

template<class Visitor, class TupleVisitor> static inline void visit(type_t t, Visitor v, TupleVisitor tv)#

template<class Visitor> static inline void visit(type_t t, Visitor v)#

template<class Visitor> static inline void visit_types(Visitor v)#

static type_t parse_type(const std::string &s)#

Friends

friend bool operator==(const shape &x, const shape &y)#

friend bool operator!=(const shape &x, const shape &y)#

friend std::ostream &operator<<(std::ostream &os, const shape &x)#

template<class T> struct as#

Public Types

using type = std::conditional_t<std::is_same<T, bool>{}, int8_t, T>#

Public Functions

inline type max() const#

inline type min() const#

inline type nan() const#

inline type epsilon() const#

template<class U> inline type operator()(U u) const#

template<class U> inline type *operator()(U *u) const#

template<class U> inline const type *operator()(const U *u) const#

inline type operator()() const#

inline std::size_t size(std::size_t n = 1) const#

inline bool is_integral() const#

inline bool is_signed() const#

inline bool is_unsigned() const#

template<class U> inline type *from(U *buffer, std::size_t n = 0) const#

template<class U> inline const type *from(const U *buffer, std::size_t n = 0) const#

inline type_t type_enum() const#

struct dynamic_dimension#

Public Functions

bool is_fixed() const#

bool has_optimal() const#

inline std::optional<dynamic_dimension> intersection(const dynamic_dimension &other) const#: Return a dynamic_dimension with the intersection of two dynamic_dimension ranges if possible.

dynamic_dimension &operator+=(const std::size_t &x)#

dynamic_dimension &operator-=(const std::size_t &x)#

dynamic_dimension &operator*=(const std::size_t &x)#

Public Members

std::size_t min = 0#

std::size_t max = 0#

std::set<std::size_t> optimals = {}#

Public Static Functions

template<class Self, class F> static inline auto reflect(Self &self, F f)#

Friends

friend bool operator==(const dynamic_dimension &x, const dynamic_dimension &y)#

friend bool operator!=(const dynamic_dimension &x, const dynamic_dimension &y)#

friend std::ostream &operator<<(std::ostream &os, const dynamic_dimension &x)#

friend bool operator==(const dynamic_dimension &x, const std::size_t &y)#

friend bool operator==(const std::size_t &x, const dynamic_dimension &y)#

friend bool operator!=(const dynamic_dimension &x, const std::size_t &y)#

friend bool operator!=(const std::size_t &x, const dynamic_dimension &y)#

friend dynamic_dimension operator+(const dynamic_dimension &x, const std::size_t &y)#

friend dynamic_dimension operator+(const std::size_t &x, const dynamic_dimension &y)#

friend dynamic_dimension operator-(const dynamic_dimension &x, const std::size_t &y)#

friend dynamic_dimension operator*(const dynamic_dimension &x, const std::size_t &y)#

friend dynamic_dimension operator*(const std::size_t &x, const dynamic_dimension &y)#

template<class T, class = void> struct get_type#: Subclassed by migraphx::internal::shape::get_type< const T >

template<class T> struct get_type<bf16, T> : public std::integral_constant<type_t, bf16_type>#

template<class T> struct get_type<bool, T> : public std::integral_constant<type_t, bool_type>#

template<class T> struct get_type<const T> : public migraphx::internal::shape::get_type<T>#

template<class T> struct get_type<double, T> : public std::integral_constant<type_t, double_type>#

template<class T> struct get_type<float, T> : public std::integral_constant<type_t, float_type>#

template<class T> struct get_type<half, T> : public std::integral_constant<type_t, half_type>#

template<class T> struct get_type<int16_t, T> : public std::integral_constant<type_t, int16_type>#

template<class T> struct get_type<int32_t, T> : public std::integral_constant<type_t, int32_type>#

template<class T> struct get_type<int64_t, T> : public std::integral_constant<type_t, int64_type>#

template<class T> struct get_type<int8_t, T> : public std::integral_constant<type_t, int8_type>#

template<class T> fp8e4m3fn, T > : public std::integral_constant< type_t, fp8e4m3fn_type >

template<class T> fp8e4m3fnuz, T > : public std::integral_constant< type_t, fp8e4m3fnuz_type >

template<class T> fp8e5m2, T > : public std::integral_constant< type_t, fp8e5m2_type >

template<class T> fp8e5m2fnuz, T > : public std::integral_constant< type_t, fp8e5m2fnuz_type >

template<class T> struct get_type<uint16_t, T> : public std::integral_constant<type_t, uint16_type>#

template<class T> struct get_type<uint32_t, T> : public std::integral_constant<type_t, uint32_type>#

template<class T> struct get_type<uint64_t, T> : public std::integral_constant<type_t, uint64_type>#

template<class T> struct get_type<uint8_t, T> : public std::integral_constant<type_t, uint8_type>#

literal#

struct literal : public migraphx::internal::raw_data<literal>#

Represents a raw literal.

This stores the literal has a raw buffer that is owned by this class

Public Functions

inline literal()#

inline explicit literal(shape::type_t shape_type)#: Empty literal with a specific shape type

template<class U, class T = deduce<U>, shape::type_t ShapeType = shape::get_type<T>{}> inline literal(U x)#

template<class T> inline literal(const shape &s, const std::vector<T> &x)#

template<class T> inline literal(const shape &s, const std::initializer_list<T> &x)#

template<class Iterator> inline literal(const shape &s, Iterator start, Iterator end)#

template<class T, long PrivateRequires__LINE__ = __LINE__, typename std::enable_if<(PrivateRequires__LINE__ == __LINE__ and (migraphx::and_<sizeof(T) == 1>{})), int>::type = 0> inline literal(const shape &s, T *x)#

inline bool empty() const#: Whether data is available.

inline const char *data() const#: Provides a raw pointer to the data.

inline const shape &get_shape() const#

inline std::vector<literal> get_sub_objects() const#

inline argument get_argument() const#: Convert the data to an argument.

argument#

struct argument : public migraphx::internal::raw_data<argument>#

Arguments passed to instructions.

An argument can represent a raw buffer of data that either be referenced from another element or it can be owned by the argument.

Public Functions

argument() = default#

explicit argument(const shape &s)#

template<class F, long PrivateRequires__LINE__ = __LINE__, typename std::enable_if<(PrivateRequires__LINE__ == __LINE__ and (migraphx::and_<std::is_pointer<decltype(std::declval<F>()())>{}>{})), int>::type = 0> inline argument(shape s, F d)#

template<class T> inline argument(shape s, T *d)#

template<class T> inline argument(shape s, const std::shared_ptr<T> &d)#

argument(shape s, std::nullptr_t)#

argument(const std::vector<argument> &args)#

char *data() const#: Provides a raw pointer to the data.

bool empty() const#: Whether data is available.

const shape &get_shape() const#

argument reshape(const shape &s) const#

argument copy() const#

argument share() const#: Make copy of the argument that is always sharing the data.

std::vector<argument> get_sub_objects() const#

argument element(std::size_t i) const#: Return the ith element.

template<class Iterator> inline void fill(Iterator start, Iterator end)#

argument convert(shape::type_t t) const#

raw_data#

template<class Derived> struct raw_data : public migraphx::internal::raw_data_base#

Provides a base class for common operations with raw buffer.

For classes that handle a raw buffer of data, this will provide common operations such as equals, printing, and visitors. To use this class the derived class needs to provide a data() method to retrieve a raw pointer to the data, and get_shape method that provides the shape of the data.

Public Functions

template<class Visitor, class Index = std::size_t> inline void visit_at(Visitor v, Index n = 0) const#

Visits a single data element at a certain index.

Parameters:

v – A function which will be called with the type of data
n – The index to read from

template<class Visitor, class TupleVisitor> inline void visit(Visitor v, TupleVisitor tv) const#

template<class Visitor> inline void visit(Visitor v) const#

Visits the data.

This will call the visitor function with a tensor_view<T> based on the shape of the data.

Parameters:: v – A function to be called with tensor_view<T>

template<class Visitor, class TupleVisitor> inline void fallback_visit(Visitor v, TupleVisitor tv) const#: Visit the data using the normal visit function for computable types. For non-computable types, use a tensor_view<byte> with shape = {type = uint8_type, lens = {num bytes}};

template<class Visitor> inline void fallback_visit(Visitor v) const#

inline bool single() const#: Returns true if the raw data is only one element.

template<class T, class Index = std::size_t> inline T at(Index n = 0) const#

Retrieves a single element of data.

Parameters:: n – The index to retrieve the data from
Template Parameters:: T – The type of data to be retrieved
Returns:: The element as T

inline auto_cast implicit() const#: Implicit conversion of raw data pointer.

template<class T> inline tensor_view<T> get() const#: Get a tensor_view to the data. For get<byte>() returns a 1D tensor_view<const byte*>.

template<class T> inline T *cast() const#

inline std::string to_string() const#

template<class T> inline std::vector<T> to_vector() const#

Friends

template<class Stream> inline friend Stream &operator<<(Stream &os, const Derived &d)#

struct auto_cast#

Public Types

template<class T> using is_data_ptr = bool_c<(std::is_void<T>{} or std::is_same<char, std::remove_cv_t<T>>{} or std::is_same<unsigned char, std::remove_cv_t<T>>{})>#

template<class T> using get_data_type = std::conditional_t<is_data_ptr<T>{}, float, T>#

Public Functions

template<class T> inline operator T()#

template<class T> inline bool matches() const#

template<class T> inline operator T*()#

Public Members

const Derived *self#

template<class T, class ...Ts> auto migraphx::internal::visit_all(T &&x, Ts&&... xs)#

Visits every object together.

This will visit every object, but assumes each object is the same type. This can reduce the deeply nested visit calls. Returns a function that takes the visitor callback. Calling syntax is visit_all(xs...)([](auto... ys) {}) where xs... and ys... are the same number of parameters.

Parameters:

x – A raw data object
xs – Many raw data objects.

Returns:

A function to be called with the visitor

template<class T> auto migraphx::internal::visit_all(const std::vector<T> &x)#

Visits every object together.

This will visit every object, but assumes each object is the same type. This can reduce the deeply nested visit calls. Returns a function that takes the visitor callback.

Parameters:: x – A vector of raw data objects. Types must all be the same.
Returns:: A function to be called with the visitor

tensor_view#

template<class T> struct tensor_view#

Public Types

using value_type = T #

using iterator = basic_iota_iterator<tensor_view_iterator_read<tensor_view<T>>, std::size_t>#

using const_iterator = basic_iota_iterator<tensor_view_iterator_read<const tensor_view<T>>, std::size_t>#

Public Functions

inline tensor_view()#

inline tensor_view(shape s, T *d)#

inline const shape &get_shape() const#

inline bool empty() const#

inline std::size_t size() const#

inline T *data()#

inline const T *data() const#

template<class ...Ts, long PrivateRequires__LINE__ = __LINE__, typename std::enable_if<(PrivateRequires__LINE__ == __LINE__ and (migraphx::and_<std::is_integral<Ts>{}...>{})), int>::type = 0> inline const T &operator()(Ts... xs) const#

template<class ...Ts, long PrivateRequires__LINE__ = __LINE__, typename std::enable_if<(PrivateRequires__LINE__ == __LINE__ and (migraphx::and_<std::is_integral<Ts>{}...>{})), int>::type = 0> inline T &operator()(Ts... xs)#

template<class Iterator, long PrivateRequires__LINE__ = __LINE__, typename std::enable_if<(PrivateRequires__LINE__ == __LINE__ and (migraphx::and_<not std::is_integral<Iterator>{}>{})), int>::type = 0> inline const T &operator()(Iterator start, Iterator last) const#

template<class Iterator, long PrivateRequires__LINE__ = __LINE__, typename std::enable_if<(PrivateRequires__LINE__ == __LINE__ and (migraphx::and_<not std::is_integral<Iterator>{}>{})), int>::type = 0> inline T &operator()(Iterator start, Iterator last)#

inline T &operator[](std::size_t i)#

inline const T &operator[](std::size_t i) const#

template<class Range> inline auto operator[](const Range &r) -> decltype((*this)(r.begin(), r.end()))#

template<class Range> inline auto operator[](const Range &r) const -> decltype((*this)(r.begin(), r.end()))#

inline T &front()#

inline const T &front() const#

inline T &back()#

inline const T &back() const#

inline iterator begin()#

template<class Range> inline iterator begin_at(const Range &r)#

inline iterator end()#

inline const_iterator begin() const#

template<class Range> inline const_iterator begin_at(const Range &r) const#

inline const_iterator end() const#

template<class U = T> inline std::vector<U> to_vector() const#

template<class Range> inline tensor_view slice_at(std::initializer_list<std::int64_t> axes, Range &&r)#

Friends

inline friend std::ostream &operator<<(std::ostream &os, const tensor_view<T> &x)#

Data types

Contents

Data types#

shape#

literal#

argument#

raw_data#

tensor_view#