Data types

shape

struct migraphx::internal::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 tuple_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)

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)

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 elements() const

std::size_t bytes() const

std::size_t type_size() const

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 i) const

void multi_copy(std::size_t i, std::size_t *start, const std::size_t *end) const

bool packed() const

Returns true if the shape is packed with no padding.

bool transposed() const

Returns true is 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)

shape normalize_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

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

std::string type_string() const

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

Public Static Functions

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

static std::string name(type_t t)

static std::string cpp_type(type_t t)

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

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 friend bool operator== (const shape &x, const shape &y)

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

friend 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

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

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

template<class T, class = void>
struct get_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>
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 migraphx::internal::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()

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__ && (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 migraphx::internal::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

argument(const shape &s)

template<class F, long PrivateRequires__LINE__ = __LINE__, typename std::enable_if<(PrivateRequires__LINE__ == __LINE__ && (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, 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.

raw_data

template<class Derived>
struct migraphx::internal::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>
inline void visit_at(Visitor v, std::size_t 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>

inline bool single() const

Returns true if the raw data is only one element.

template<class T>
inline T at(std::size_t 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.

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

Cast the data pointer.

inline std::string to_string() const

Friends

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

struct auto_cast

Public Types

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>>{})>

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

Warning

doxygenfunction: Unable to resolve function “migraphx::internal::visit_all” with arguments None in doxygen xml output for project “proj” from directory: /code/AMDMIGraphX/build/doc/doxygen/xml. Potential matches:

- template<class T, class ...Ts> auto visit_all(T &&x, Ts&&... xs)
- template<class T> auto visit_all(const std::vector<T> &x)

tensor_view

template<class T>
struct migraphx::internal::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__ && (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__ && (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__ && (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__ && (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

inline T &front()

inline const T &front() const

inline T &back()

inline const T &back() const

inline iterator begin()

inline iterator end()

inline const_iterator begin() const

inline const_iterator end() const

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

Friends

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