autogen.h

Go to the documentation of this file.

#pragma once
 
#include <mim/axm.h>
#include <mim/plugin.h>
 
/// @namespace mim::plug::gpu @ref gpu
namespace mim {
namespace plug::gpu {
 
static constexpr plugin_t Plugin_Id = 0x2115800000000000;
 
/// @name %%gpu.addr_space_global
///@{
enum class addr_space_global : flags_t {
};
 
///@}
 
/// @name %%gpu.addr_space_shared
///@{
enum class addr_space_shared : flags_t {
};
 
///@}
 
/// @name %%gpu.addr_space_const
///@{
enum class addr_space_const : flags_t {
};
 
///@}
 
/// @name %%gpu.addr_space_local
///@{
enum class addr_space_local : flags_t {
};
 
///@}
 
/// @name %%gpu.GlobalM
///@{
enum class GlobalM : flags_t {
};
 
///@}
 
/// @name %%gpu.SharedM
///@{
enum class SharedM : flags_t {
};
 
///@}
 
/// @name %%gpu.ConstM
///@{
enum class ConstM : flags_t {
};
 
///@}
 
/// @name %%gpu.LocalM
///@{
enum class LocalM : flags_t {
};
 
///@}
 
/// @name %%gpu.GlobalPtr
///@{
enum class GlobalPtr : flags_t {
};
 
///@}
 
/// @name %%gpu.SharedPtr
///@{
enum class SharedPtr : flags_t {
};
 
///@}
 
/// @name %%gpu.ConstPtr
///@{
enum class ConstPtr : flags_t {
};
 
///@}
 
/// @name %%gpu.LocalPtr
///@{
enum class LocalPtr : flags_t {
};
 
///@}
 
/// @name %%gpu.Stream
///@{
enum class Stream : flags_t {
};
 
///@}
 
/// @name %%gpu.default_stream
///@{
enum class default_stream : flags_t {
};
 
///@}
 
/// @name %%gpu.init
///@{
enum class init : flags_t {
};
 
///@}
 
/// @name %%gpu.deinit
///@{
enum class deinit : flags_t {
};
 
///@}
 
/// @name %%gpu.stream_init
///@{
enum class stream_init : flags_t {
};
 
///@}
 
/// @name %%gpu.stream_deinit
///@{
enum class stream_deinit : flags_t {
};
 
///@}
 
/// @name %%gpu.stream_sync
///@{
enum class stream_sync : flags_t {
};
 
///@}
 
/// @name %%gpu.with_streams
///@{
enum class with_streams : flags_t {
};
 
///@}
 
/// @name %%gpu.alloc
///@{
enum class alloc : flags_t {
    block = 0x2115800000001400,
    asyn = 0x2115800000001401,
};
 
///@}
 
/// @name %%gpu.free
///@{
enum class free : flags_t {
    block = 0x2115800000001500,
    asyn = 0x2115800000001501,
};
 
///@}
 
/// @name %%gpu.copy_to_device
///@{
enum class copy_to_device : flags_t {
    block = 0x2115800000001600,
    asyn = 0x2115800000001601,
};
 
///@}
 
/// @name %%gpu.copy_to_host
///@{
enum class copy_to_host : flags_t {
    block = 0x2115800000001700,
    asyn = 0x2115800000001701,
};
 
///@}
 
/// @name %%gpu.alloc_copy
///@{
enum class alloc_copy : flags_t {
    block = 0x2115800000001800,
    asyn = 0x2115800000001801,
};
 
///@}
 
/// @name %%gpu.launch
///@{
enum class launch : flags_t {
};
 
///@}
 
/// @name %%gpu.sync_work_items
///@{
enum class sync_work_items : flags_t {
};
 
///@}
 
/// @name %%gpu.synced_scope
///@{
enum class synced_scope : flags_t {
};
 
///@}
 
/// @name %%gpu.check_addr_spaces_repl
///@{
enum class check_addr_spaces_repl : flags_t {
};
 
///@}
 
/// @name %%gpu.host_malloc2gpualloc_repl
///@{
enum class host_malloc2gpualloc_repl : flags_t {
};
 
///@}
 
/// @name %%gpu.mem_checks
///@{
enum class mem_checks : flags_t {
};
 
///@}
 
/// @name %%gpu.remove_double_syncs
///@{
enum class remove_double_syncs : flags_t {
};
 
///@}
 
/// @name %%gpu.split_apply
///@{
enum class split_apply : flags_t {
};
 
///@}
 
/// @name %%gpu.host_specific_phases
///@{
enum class host_specific_phases : flags_t {
};
 
///@}
 
/// @name %%gpu.device_specific_phases
///@{
enum class device_specific_phases : flags_t {
};
 
///@}
 
} // namespace plug::gpu
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> constexpr flags_t Annex::Base<plug::gpu::addr_space_global> = 0x2115800000000000;
template<> constexpr size_t Annex::Num<plug::gpu::addr_space_global> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::addr_space_shared> = 0x2115800000000100;
template<> constexpr size_t Annex::Num<plug::gpu::addr_space_shared> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::addr_space_const> = 0x2115800000000200;
template<> constexpr size_t Annex::Num<plug::gpu::addr_space_const> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::addr_space_local> = 0x2115800000000300;
template<> constexpr size_t Annex::Num<plug::gpu::addr_space_local> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::GlobalM> = 0x2115800000000400;
template<> constexpr size_t Annex::Num<plug::gpu::GlobalM> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::SharedM> = 0x2115800000000500;
template<> constexpr size_t Annex::Num<plug::gpu::SharedM> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::ConstM> = 0x2115800000000600;
template<> constexpr size_t Annex::Num<plug::gpu::ConstM> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::LocalM> = 0x2115800000000700;
template<> constexpr size_t Annex::Num<plug::gpu::LocalM> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::GlobalPtr> = 0x2115800000000800;
template<> constexpr size_t Annex::Num<plug::gpu::GlobalPtr> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::SharedPtr> = 0x2115800000000900;
template<> constexpr size_t Annex::Num<plug::gpu::SharedPtr> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::ConstPtr> = 0x2115800000000a00;
template<> constexpr size_t Annex::Num<plug::gpu::ConstPtr> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::LocalPtr> = 0x2115800000000b00;
template<> constexpr size_t Annex::Num<plug::gpu::LocalPtr> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::Stream> = 0x2115800000000c00;
template<> constexpr size_t Annex::Num<plug::gpu::Stream> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::default_stream> = 0x2115800000000d00;
template<> constexpr size_t Annex::Num<plug::gpu::default_stream> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::init> = 0x2115800000000e00;
template<> constexpr size_t Annex::Num<plug::gpu::init> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::deinit> = 0x2115800000000f00;
template<> constexpr size_t Annex::Num<plug::gpu::deinit> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::stream_init> = 0x2115800000001000;
template<> constexpr size_t Annex::Num<plug::gpu::stream_init> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::stream_deinit> = 0x2115800000001100;
template<> constexpr size_t Annex::Num<plug::gpu::stream_deinit> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::stream_sync> = 0x2115800000001200;
template<> constexpr size_t Annex::Num<plug::gpu::stream_sync> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::with_streams> = 0x2115800000001300;
template<> constexpr size_t Annex::Num<plug::gpu::with_streams> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::alloc> = 0x2115800000001400;
template<> constexpr size_t Annex::Num<plug::gpu::alloc> = 2;
template<> constexpr flags_t Annex::Base<plug::gpu::free> = 0x2115800000001500;
template<> constexpr size_t Annex::Num<plug::gpu::free> = 2;
template<> constexpr flags_t Annex::Base<plug::gpu::copy_to_device> = 0x2115800000001600;
template<> constexpr size_t Annex::Num<plug::gpu::copy_to_device> = 2;
template<> constexpr flags_t Annex::Base<plug::gpu::copy_to_host> = 0x2115800000001700;
template<> constexpr size_t Annex::Num<plug::gpu::copy_to_host> = 2;
template<> constexpr flags_t Annex::Base<plug::gpu::alloc_copy> = 0x2115800000001800;
template<> constexpr size_t Annex::Num<plug::gpu::alloc_copy> = 2;
template<> constexpr flags_t Annex::Base<plug::gpu::launch> = 0x2115800000001900;
template<> constexpr size_t Annex::Num<plug::gpu::launch> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::sync_work_items> = 0x2115800000001a00;
template<> constexpr size_t Annex::Num<plug::gpu::sync_work_items> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::synced_scope> = 0x2115800000001b00;
template<> constexpr size_t Annex::Num<plug::gpu::synced_scope> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::check_addr_spaces_repl> = 0x2115800000001c00;
template<> constexpr size_t Annex::Num<plug::gpu::check_addr_spaces_repl> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::host_malloc2gpualloc_repl> = 0x2115800000001d00;
template<> constexpr size_t Annex::Num<plug::gpu::host_malloc2gpualloc_repl> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::mem_checks> = 0x2115800000001e00;
template<> constexpr size_t Annex::Num<plug::gpu::mem_checks> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::remove_double_syncs> = 0x2115800000001f00;
template<> constexpr size_t Annex::Num<plug::gpu::remove_double_syncs> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::split_apply> = 0x2115800000002000;
template<> constexpr size_t Annex::Num<plug::gpu::split_apply> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::host_specific_phases> = 0x2115800000002100;
template<> constexpr size_t Annex::Num<plug::gpu::host_specific_phases> = 0;
template<> constexpr flags_t Annex::Base<plug::gpu::device_specific_phases> = 0x2115800000002200;
template<> constexpr size_t Annex::Num<plug::gpu::device_specific_phases> = 0;
 
template<> struct Axm::IsANode<plug::gpu::addr_space_global> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::addr_space_shared> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::addr_space_const> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::addr_space_local> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::GlobalM> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::SharedM> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::ConstM> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::LocalM> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::GlobalPtr> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::SharedPtr> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::ConstPtr> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::LocalPtr> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::Stream> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::default_stream> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::with_streams> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::alloc_copy> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::synced_scope> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::check_addr_spaces_repl> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::host_malloc2gpualloc_repl> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::mem_checks> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::remove_double_syncs> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::split_apply> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::host_specific_phases> { using type = Axm; };
template<> struct Axm::IsANode<plug::gpu::device_specific_phases> { using type = Axm; };
 
#endif
} // namespace mim
 
#ifndef DOXYGEN // don't include in Doxygen documentation
 
template<> struct fe::is_bit_enum<mim::plug::gpu::alloc> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::gpu::free> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::gpu::copy_to_device> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::gpu::copy_to_host> : std::true_type {};
template<> struct fe::is_bit_enum<mim::plug::gpu::alloc_copy> : std::true_type {};
 
#endif