autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::tensor @ref tensor
namespace mim {
namespace plug::tensor {
 
static constexpr plugin_t Plugin_Id = 0x5463d44130000000;
 
/// @name %%tensor.Ring
///@{
enum class Ring : flags_t {
};
 
///@}
 
/// @name %%tensor.get
///@{
enum class get : flags_t {
};
 
const Def* normalize_get(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.set
///@{
enum class set : flags_t {
};
 
const Def* normalize_set(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.shape
///@{
enum class shape : flags_t {
};
 
const Def* normalize_shape(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.map_reduce
///@{
enum class map_reduce : flags_t {
};
 
const Def* normalize_map_reduce(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.proj_map
///@{
enum class proj_map : flags_t {
};
 
///@}
 
/// @name %%tensor.repeat
///@{
enum class repeat : flags_t {
};
 
const Def* normalize_repeat(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.repeat_impl
///@{
enum class repeat_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.reshape
///@{
enum class reshape : flags_t {
};
 
const Def* normalize_reshape(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.reshape_impl
///@{
enum class reshape_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.slice
///@{
enum class slice : flags_t {
};
 
const Def* normalize_slice(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.slice_impl
///@{
enum class slice_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.flip
///@{
enum class flip : flags_t {
};
 
const Def* normalize_flip(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.flip_impl
///@{
enum class flip_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.pad
///@{
enum class pad : flags_t {
};
 
const Def* normalize_pad(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.concat
///@{
enum class concat : flags_t {
};
 
const Def* normalize_concat(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.conv
///@{
enum class conv : flags_t {
};
 
///@}
 
/// @name %%tensor.conv_impl
///@{
enum class conv_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.pool
///@{
enum class pool : flags_t {
};
 
///@}
 
/// @name %%tensor.pool_impl
///@{
enum class pool_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.dot_product
///@{
enum class dot_product : flags_t {
};
 
///@}
 
/// @name %%tensor.dot_product_impl
///@{
enum class dot_product_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.product_2d
///@{
enum class product_2d : flags_t {
};
 
///@}
 
/// @name %%tensor.product_2d_impl
///@{
enum class product_2d_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.bmm
///@{
enum class bmm : flags_t {
};
 
///@}
 
/// @name %%tensor.bmm_impl
///@{
enum class bmm_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.transpose
///@{
enum class transpose : flags_t {
};
 
///@}
 
/// @name %%tensor.transpose_impl
///@{
enum class transpose_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.transpose_2d
///@{
enum class transpose_2d : flags_t {
};
 
///@}
 
/// @name %%tensor.transpose_2d_impl
///@{
enum class transpose_2d_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.broadcast
///@{
enum class broadcast : flags_t {
};
 
const Def* normalize_broadcast(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.broadcast_in_dim
///@{
enum class broadcast_in_dim : flags_t {
};
 
const Def* normalize_broadcast_in_dim(const Def*, const Def*, const Def*);
///@}
 
/// @name %%tensor.broadcast_in_dim_impl
///@{
enum class broadcast_in_dim_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.map
///@{
enum class map : flags_t {
};
 
///@}
 
/// @name %%tensor.map_impl
///@{
enum class map_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.unary
///@{
enum class unary : flags_t {
};
 
///@}
 
/// @name %%tensor.unary_impl
///@{
enum class unary_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.binary
///@{
enum class binary : flags_t {
};
 
///@}
 
/// @name %%tensor.binary_impl
///@{
enum class binary_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.select
///@{
enum class select : flags_t {
};
 
///@}
 
/// @name %%tensor.select_impl
///@{
enum class select_impl : flags_t {
};
 
///@}
 
/// @name %%tensor.lower_tensor
///@{
enum class lower_tensor : flags_t {
};
 
///@}
 
/// @name %%tensor.lower_map_reduce
///@{
enum class lower_map_reduce : flags_t {
};
 
///@}
 
/// @name %%tensor.lower_get_set
///@{
enum class lower_get_set : flags_t {
};
 
///@}
 
/// @name %%tensor.fuse_tensor
///@{
enum class fuse_tensor : flags_t {
};
 
///@}
 
/// @name %%tensor.lower_to_mem
///@{
enum class lower_to_mem : flags_t {
};
 
///@}
 
void register_normalizers(Normalizers& normalizers);
 
#define MIM_tensor_NORMALIZER_IMPL \
    void register_normalizers(Normalizers& normalizers) {\
        normalizers[flags_t(Annex::Base<get>)] = &normalize_get; \
        normalizers[flags_t(Annex::Base<set>)] = &normalize_set; \
        normalizers[flags_t(Annex::Base<shape>)] = &normalize_shape; \
        normalizers[flags_t(Annex::Base<map_reduce>)] = &normalize_map_reduce; \
        normalizers[flags_t(Annex::Base<repeat>)] = &normalize_repeat; \
        normalizers[flags_t(Annex::Base<reshape>)] = &normalize_reshape; \
        normalizers[flags_t(Annex::Base<slice>)] = &normalize_slice; \
        normalizers[flags_t(Annex::Base<flip>)] = &normalize_flip; \
        normalizers[flags_t(Annex::Base<pad>)] = &normalize_pad; \
        normalizers[flags_t(Annex::Base<concat>)] = &normalize_concat; \
        normalizers[flags_t(Annex::Base<broadcast>)] = &normalize_broadcast; \
        normalizers[flags_t(Annex::Base<broadcast_in_dim>)] = &normalize_broadcast_in_dim; \
    }
} // namespace plug::tensor
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::tensor::Ring> = 0x5463d44130000000;
template<> constexpr size_t Annex::Num<plug::tensor::Ring> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::get> = 0x5463d44130000100;
template<> constexpr size_t Annex::Num<plug::tensor::get> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::set> = 0x5463d44130000200;
template<> constexpr size_t Annex::Num<plug::tensor::set> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::shape> = 0x5463d44130000300;
template<> constexpr size_t Annex::Num<plug::tensor::shape> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::map_reduce> = 0x5463d44130000400;
template<> constexpr size_t Annex::Num<plug::tensor::map_reduce> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::proj_map> = 0x5463d44130000500;
template<> constexpr size_t Annex::Num<plug::tensor::proj_map> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::repeat> = 0x5463d44130000600;
template<> constexpr size_t Annex::Num<plug::tensor::repeat> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::repeat_impl> = 0x5463d44130000700;
template<> constexpr size_t Annex::Num<plug::tensor::repeat_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::reshape> = 0x5463d44130000800;
template<> constexpr size_t Annex::Num<plug::tensor::reshape> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::reshape_impl> = 0x5463d44130000900;
template<> constexpr size_t Annex::Num<plug::tensor::reshape_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::slice> = 0x5463d44130000a00;
template<> constexpr size_t Annex::Num<plug::tensor::slice> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::slice_impl> = 0x5463d44130000b00;
template<> constexpr size_t Annex::Num<plug::tensor::slice_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::flip> = 0x5463d44130000c00;
template<> constexpr size_t Annex::Num<plug::tensor::flip> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::flip_impl> = 0x5463d44130000d00;
template<> constexpr size_t Annex::Num<plug::tensor::flip_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::pad> = 0x5463d44130000e00;
template<> constexpr size_t Annex::Num<plug::tensor::pad> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::concat> = 0x5463d44130000f00;
template<> constexpr size_t Annex::Num<plug::tensor::concat> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::conv> = 0x5463d44130001000;
template<> constexpr size_t Annex::Num<plug::tensor::conv> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::conv_impl> = 0x5463d44130001100;
template<> constexpr size_t Annex::Num<plug::tensor::conv_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::pool> = 0x5463d44130001200;
template<> constexpr size_t Annex::Num<plug::tensor::pool> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::pool_impl> = 0x5463d44130001300;
template<> constexpr size_t Annex::Num<plug::tensor::pool_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::dot_product> = 0x5463d44130001400;
template<> constexpr size_t Annex::Num<plug::tensor::dot_product> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::dot_product_impl> = 0x5463d44130001500;
template<> constexpr size_t Annex::Num<plug::tensor::dot_product_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::product_2d> = 0x5463d44130001600;
template<> constexpr size_t Annex::Num<plug::tensor::product_2d> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::product_2d_impl> = 0x5463d44130001700;
template<> constexpr size_t Annex::Num<plug::tensor::product_2d_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::bmm> = 0x5463d44130001800;
template<> constexpr size_t Annex::Num<plug::tensor::bmm> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::bmm_impl> = 0x5463d44130001900;
template<> constexpr size_t Annex::Num<plug::tensor::bmm_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::transpose> = 0x5463d44130001a00;
template<> constexpr size_t Annex::Num<plug::tensor::transpose> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::transpose_impl> = 0x5463d44130001b00;
template<> constexpr size_t Annex::Num<plug::tensor::transpose_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::transpose_2d> = 0x5463d44130001c00;
template<> constexpr size_t Annex::Num<plug::tensor::transpose_2d> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::transpose_2d_impl> = 0x5463d44130001d00;
template<> constexpr size_t Annex::Num<plug::tensor::transpose_2d_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::broadcast> = 0x5463d44130001e00;
template<> constexpr size_t Annex::Num<plug::tensor::broadcast> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::broadcast_in_dim> = 0x5463d44130001f00;
template<> constexpr size_t Annex::Num<plug::tensor::broadcast_in_dim> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::broadcast_in_dim_impl> = 0x5463d44130002000;
template<> constexpr size_t Annex::Num<plug::tensor::broadcast_in_dim_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::map> = 0x5463d44130002100;
template<> constexpr size_t Annex::Num<plug::tensor::map> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::map_impl> = 0x5463d44130002200;
template<> constexpr size_t Annex::Num<plug::tensor::map_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::unary> = 0x5463d44130002300;
template<> constexpr size_t Annex::Num<plug::tensor::unary> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::unary_impl> = 0x5463d44130002400;
template<> constexpr size_t Annex::Num<plug::tensor::unary_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::binary> = 0x5463d44130002500;
template<> constexpr size_t Annex::Num<plug::tensor::binary> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::binary_impl> = 0x5463d44130002600;
template<> constexpr size_t Annex::Num<plug::tensor::binary_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::select> = 0x5463d44130002700;
template<> constexpr size_t Annex::Num<plug::tensor::select> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::select_impl> = 0x5463d44130002800;
template<> constexpr size_t Annex::Num<plug::tensor::select_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::lower_tensor> = 0x5463d44130002900;
template<> constexpr size_t Annex::Num<plug::tensor::lower_tensor> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::lower_map_reduce> = 0x5463d44130002a00;
template<> constexpr size_t Annex::Num<plug::tensor::lower_map_reduce> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::lower_get_set> = 0x5463d44130002b00;
template<> constexpr size_t Annex::Num<plug::tensor::lower_get_set> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::fuse_tensor> = 0x5463d44130002c00;
template<> constexpr size_t Annex::Num<plug::tensor::fuse_tensor> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::lower_to_mem> = 0x5463d44130002d00;
template<> constexpr size_t Annex::Num<plug::tensor::lower_to_mem> = 0;
 
template<> struct Axm::IsANode<plug::tensor::Ring> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::proj_map> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::repeat_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::reshape_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::slice_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::flip_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::conv_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::pool_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::dot_product_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::product_2d_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::bmm_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::transpose_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::transpose_2d_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::broadcast_in_dim_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::map_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::unary_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::binary_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::select_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::lower_tensor> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::lower_map_reduce> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::lower_get_set> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::fuse_tensor> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::lower_to_mem> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
 
#endif