autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
#include <mim/plug/btensor/autogen.h>
 
/// @namespace mim::plug::tensor @ref tensor
namespace mim {
namespace plug::tensor {
 
static constexpr plugin_t Plugin_Id = 0x5463d44130000000;
 
using Ring = plug::btensor::Ring;
using Sched = plug::btensor::Sched;
using SchedT = plug::btensor::SchedT;
using mk_sched = plug::btensor::mk_sched;
using proj_map = plug::btensor::proj_map;
 
/// @name `tensor.generate`
///@{
enum class generate : flags_t {
};
 
///@}
 
/// @name `tensor.splat`
///@{
enum class splat : flags_t {
};
 
///@}
 
/// @name `tensor.buf`
///@{
enum class buf : flags_t {
};
 
///@}
 
/// @name `tensor.shape`
///@{
enum class shape : flags_t {
};
 
const Def* normalize_shape(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.id`
///@{
enum class id : flags_t {
};
 
///@}
 
/// @name `tensor.map_reduce_post`
///@{
enum class map_reduce_post : flags_t {
};
 
///@}
 
/// @name `tensor.map_reduce`
///@{
enum class map_reduce : 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.concat`
///@{
enum class concat : flags_t {
};
 
const Def* normalize_concat(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.flip`
///@{
enum class flip : flags_t {
};
 
const Def* normalize_flip(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.pad`
///@{
enum class pad : flags_t {
};
 
const Def* normalize_pad(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.repeat`
///@{
enum class repeat : flags_t {
};
 
const Def* normalize_repeat(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.reshape`
///@{
enum class reshape : flags_t {
};
 
const Def* normalize_reshape(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.slice`
///@{
enum class slice : flags_t {
};
 
const Def* normalize_slice(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.transpose`
///@{
enum class transpose : flags_t {
};
 
const Def* normalize_transpose(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.transpose_2d`
///@{
enum class transpose_2d : flags_t {
};
 
///@}
 
/// @name `tensor.binary`
///@{
enum class binary : flags_t {
};
 
///@}
 
/// @name `tensor.map`
///@{
enum class map : flags_t {
};
 
///@}
 
/// @name `tensor.select`
///@{
enum class select : flags_t {
};
 
///@}
 
/// @name `tensor.unary`
///@{
enum class unary : flags_t {
};
 
///@}
 
/// @name `tensor.bmm`
///@{
enum class bmm : flags_t {
};
 
///@}
 
/// @name `tensor.conv`
///@{
enum class conv : flags_t {
};
 
///@}
 
/// @name `tensor.conv_grouped`
///@{
enum class conv_grouped : flags_t {
};
 
///@}
 
/// @name `tensor.dot_product`
///@{
enum class dot_product : flags_t {
};
 
///@}
 
/// @name `tensor.pool`
///@{
enum class pool : flags_t {
};
 
///@}
 
/// @name `tensor.product_2d`
///@{
enum class product_2d : flags_t {
};
 
///@}
 
/// @name `tensor.gather`
///@{
enum class gather : flags_t {
};
 
///@}
 
/// @name `tensor.scatter`
///@{
enum class scatter : flags_t {
};
 
///@}
 
/// @name `tensor.fastest_axis`
///@{
enum class fastest_axis : flags_t {
};
 
const Def* normalize_fastest_axis(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.if_static`
///@{
enum class if_static : flags_t {
};
 
const Def* normalize_if_static(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.vec_width`
///@{
enum class vec_width : flags_t {
};
 
const Def* normalize_vec_width(const Def*, const Def*, const Def*);
///@}
 
/// @name `tensor.interchange`
///@{
enum class interchange : flags_t {
};
 
///@}
 
/// @name `tensor.materialize`
///@{
enum class materialize : flags_t {
};
 
///@}
 
/// @name `tensor.mr_tileable`
///@{
enum class mr_tileable : flags_t {
};
 
///@}
 
/// @name `tensor.strip_mine_par`
///@{
enum class strip_mine_par : flags_t {
};
 
///@}
 
/// @name `tensor.strip_mine_red`
///@{
enum class strip_mine_red : flags_t {
};
 
///@}
 
/// @name `tensor.broadcast_in_dim_impl`
///@{
enum class broadcast_in_dim_impl : flags_t {
};
 
///@}
 
/// @name `tensor.flip_impl`
///@{
enum class flip_impl : flags_t {
};
 
///@}
 
/// @name `tensor.gather_pointwise_elem_impl`
///@{
enum class gather_pointwise_elem_impl : flags_t {
};
 
///@}
 
/// @name `tensor.map_impl`
///@{
enum class map_impl : flags_t {
};
 
///@}
 
/// @name `tensor.pool_impl`
///@{
enum class pool_impl : flags_t {
};
 
///@}
 
/// @name `tensor.repeat_impl`
///@{
enum class repeat_impl : flags_t {
};
 
///@}
 
/// @name `tensor.reshape_map`
///@{
enum class reshape_map : flags_t {
};
 
///@}
 
/// @name `tensor.reshape_impl`
///@{
enum class reshape_impl : flags_t {
};
 
///@}
 
/// @name `tensor.conv_impl`
///@{
enum class conv_impl : flags_t {
};
 
///@}
 
/// @name `tensor.conv_grouped_impl`
///@{
enum class conv_grouped_impl : flags_t {
};
 
///@}
 
/// @name `tensor.dot_product_impl`
///@{
enum class dot_product_impl : flags_t {
};
 
///@}
 
/// @name `tensor.bmm_impl`
///@{
enum class bmm_impl : flags_t {
};
 
///@}
 
/// @name `tensor.product_2d_impl`
///@{
enum class product_2d_impl : flags_t {
};
 
///@}
 
/// @name `tensor.scatter_step_impl`
///@{
enum class scatter_step_impl : flags_t {
};
 
///@}
 
/// @name `tensor.slice_impl`
///@{
enum class slice_impl : flags_t {
};
 
///@}
 
/// @name `tensor.transpose_impl`
///@{
enum class transpose_impl : flags_t {
};
 
///@}
 
/// @name `tensor.binary_impl`
///@{
enum class binary_impl : flags_t {
};
 
///@}
 
/// @name `tensor.select_impl`
///@{
enum class select_impl : flags_t {
};
 
///@}
 
/// @name `tensor.unary_impl`
///@{
enum class unary_impl : flags_t {
};
 
///@}
 
/// @name `tensor.reassoc`
///@{
enum class reassoc : 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.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<shape>)] = &normalize_shape; \
        normalizers[flags_t(Annex::Base<broadcast>)] = &normalize_broadcast; \
        normalizers[flags_t(Annex::Base<broadcast_in_dim>)] = &normalize_broadcast_in_dim; \
        normalizers[flags_t(Annex::Base<concat>)] = &normalize_concat; \
        normalizers[flags_t(Annex::Base<flip>)] = &normalize_flip; \
        normalizers[flags_t(Annex::Base<pad>)] = &normalize_pad; \
        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<transpose>)] = &normalize_transpose; \
        normalizers[flags_t(Annex::Base<fastest_axis>)] = &normalize_fastest_axis; \
        normalizers[flags_t(Annex::Base<if_static>)] = &normalize_if_static; \
        normalizers[flags_t(Annex::Base<vec_width>)] = &normalize_vec_width; \
    }
} // namespace plug::tensor
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::tensor::generate> = 0x5463d44130000000;
template<> constexpr size_t Annex::Num<plug::tensor::generate> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::splat> = 0x5463d44130000100;
template<> constexpr size_t Annex::Num<plug::tensor::splat> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::buf> = 0x5463d44130000200;
template<> constexpr size_t Annex::Num<plug::tensor::buf> = 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::id> = 0x5463d44130000400;
template<> constexpr size_t Annex::Num<plug::tensor::id> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::map_reduce_post> = 0x5463d44130000500;
template<> constexpr size_t Annex::Num<plug::tensor::map_reduce_post> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::map_reduce> = 0x5463d44130000600;
template<> constexpr size_t Annex::Num<plug::tensor::map_reduce> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::broadcast> = 0x5463d44130000700;
template<> constexpr size_t Annex::Num<plug::tensor::broadcast> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::broadcast_in_dim> = 0x5463d44130000800;
template<> constexpr size_t Annex::Num<plug::tensor::broadcast_in_dim> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::concat> = 0x5463d44130000900;
template<> constexpr size_t Annex::Num<plug::tensor::concat> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::flip> = 0x5463d44130000a00;
template<> constexpr size_t Annex::Num<plug::tensor::flip> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::pad> = 0x5463d44130000b00;
template<> constexpr size_t Annex::Num<plug::tensor::pad> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::repeat> = 0x5463d44130000c00;
template<> constexpr size_t Annex::Num<plug::tensor::repeat> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::reshape> = 0x5463d44130000d00;
template<> constexpr size_t Annex::Num<plug::tensor::reshape> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::slice> = 0x5463d44130000e00;
template<> constexpr size_t Annex::Num<plug::tensor::slice> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::transpose> = 0x5463d44130000f00;
template<> constexpr size_t Annex::Num<plug::tensor::transpose> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::transpose_2d> = 0x5463d44130001000;
template<> constexpr size_t Annex::Num<plug::tensor::transpose_2d> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::binary> = 0x5463d44130001100;
template<> constexpr size_t Annex::Num<plug::tensor::binary> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::map> = 0x5463d44130001200;
template<> constexpr size_t Annex::Num<plug::tensor::map> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::select> = 0x5463d44130001300;
template<> constexpr size_t Annex::Num<plug::tensor::select> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::unary> = 0x5463d44130001400;
template<> constexpr size_t Annex::Num<plug::tensor::unary> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::bmm> = 0x5463d44130001500;
template<> constexpr size_t Annex::Num<plug::tensor::bmm> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::conv> = 0x5463d44130001600;
template<> constexpr size_t Annex::Num<plug::tensor::conv> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::conv_grouped> = 0x5463d44130001700;
template<> constexpr size_t Annex::Num<plug::tensor::conv_grouped> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::dot_product> = 0x5463d44130001800;
template<> constexpr size_t Annex::Num<plug::tensor::dot_product> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::pool> = 0x5463d44130001900;
template<> constexpr size_t Annex::Num<plug::tensor::pool> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::product_2d> = 0x5463d44130001a00;
template<> constexpr size_t Annex::Num<plug::tensor::product_2d> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::gather> = 0x5463d44130001b00;
template<> constexpr size_t Annex::Num<plug::tensor::gather> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::scatter> = 0x5463d44130001c00;
template<> constexpr size_t Annex::Num<plug::tensor::scatter> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::fastest_axis> = 0x5463d44130001d00;
template<> constexpr size_t Annex::Num<plug::tensor::fastest_axis> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::if_static> = 0x5463d44130001e00;
template<> constexpr size_t Annex::Num<plug::tensor::if_static> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::vec_width> = 0x5463d44130001f00;
template<> constexpr size_t Annex::Num<plug::tensor::vec_width> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::interchange> = 0x5463d44130002000;
template<> constexpr size_t Annex::Num<plug::tensor::interchange> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::materialize> = 0x5463d44130002100;
template<> constexpr size_t Annex::Num<plug::tensor::materialize> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::mr_tileable> = 0x5463d44130002200;
template<> constexpr size_t Annex::Num<plug::tensor::mr_tileable> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::strip_mine_par> = 0x5463d44130002300;
template<> constexpr size_t Annex::Num<plug::tensor::strip_mine_par> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::strip_mine_red> = 0x5463d44130002400;
template<> constexpr size_t Annex::Num<plug::tensor::strip_mine_red> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::broadcast_in_dim_impl> = 0x5463d44130002500;
template<> constexpr size_t Annex::Num<plug::tensor::broadcast_in_dim_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::flip_impl> = 0x5463d44130002600;
template<> constexpr size_t Annex::Num<plug::tensor::flip_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::gather_pointwise_elem_impl> = 0x5463d44130002700;
template<> constexpr size_t Annex::Num<plug::tensor::gather_pointwise_elem_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::map_impl> = 0x5463d44130002800;
template<> constexpr size_t Annex::Num<plug::tensor::map_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::pool_impl> = 0x5463d44130002900;
template<> constexpr size_t Annex::Num<plug::tensor::pool_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::repeat_impl> = 0x5463d44130002a00;
template<> constexpr size_t Annex::Num<plug::tensor::repeat_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::reshape_map> = 0x5463d44130002b00;
template<> constexpr size_t Annex::Num<plug::tensor::reshape_map> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::reshape_impl> = 0x5463d44130002c00;
template<> constexpr size_t Annex::Num<plug::tensor::reshape_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::conv_impl> = 0x5463d44130002d00;
template<> constexpr size_t Annex::Num<plug::tensor::conv_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::conv_grouped_impl> = 0x5463d44130002e00;
template<> constexpr size_t Annex::Num<plug::tensor::conv_grouped_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::dot_product_impl> = 0x5463d44130002f00;
template<> constexpr size_t Annex::Num<plug::tensor::dot_product_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::bmm_impl> = 0x5463d44130003000;
template<> constexpr size_t Annex::Num<plug::tensor::bmm_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::product_2d_impl> = 0x5463d44130003100;
template<> constexpr size_t Annex::Num<plug::tensor::product_2d_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::scatter_step_impl> = 0x5463d44130003200;
template<> constexpr size_t Annex::Num<plug::tensor::scatter_step_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::slice_impl> = 0x5463d44130003300;
template<> constexpr size_t Annex::Num<plug::tensor::slice_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::transpose_impl> = 0x5463d44130003400;
template<> constexpr size_t Annex::Num<plug::tensor::transpose_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::binary_impl> = 0x5463d44130003500;
template<> constexpr size_t Annex::Num<plug::tensor::binary_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::select_impl> = 0x5463d44130003600;
template<> constexpr size_t Annex::Num<plug::tensor::select_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::unary_impl> = 0x5463d44130003700;
template<> constexpr size_t Annex::Num<plug::tensor::unary_impl> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::reassoc> = 0x5463d44130003800;
template<> constexpr size_t Annex::Num<plug::tensor::reassoc> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::lower_tensor> = 0x5463d44130003900;
template<> constexpr size_t Annex::Num<plug::tensor::lower_tensor> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::lower_map_reduce> = 0x5463d44130003a00;
template<> constexpr size_t Annex::Num<plug::tensor::lower_map_reduce> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::fuse_tensor> = 0x5463d44130003b00;
template<> constexpr size_t Annex::Num<plug::tensor::fuse_tensor> = 0;
template<> constexpr flags_t Annex::Base<plug::tensor::lower_to_mem> = 0x5463d44130003c00;
template<> constexpr size_t Annex::Num<plug::tensor::lower_to_mem> = 0;
 
template<> struct Axm::IsANode<plug::tensor::id> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::map_reduce> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::transpose_2d> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::interchange> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::materialize> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::mr_tileable> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::strip_mine_par> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::strip_mine_red> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::broadcast_in_dim_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::flip_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::gather_pointwise_elem_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::map_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::pool_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::repeat_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::reshape_map> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::reshape_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::conv_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::conv_grouped_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::dot_product_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::bmm_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::product_2d_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::scatter_step_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::slice_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::transpose_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::unary_impl> { using type = Axm; };
template<> struct Axm::IsANode<plug::tensor::reassoc> { 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::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