types_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_TYPES_TT_TARGET_METAL_H_
#define FLATBUFFERS_GENERATED_TYPES_TT_TARGET_METAL_H_
 
#include "flatbuffers/flatbuffers.h"
 
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
              FLATBUFFERS_VERSION_MINOR == 3 &&
              FLATBUFFERS_VERSION_REVISION == 25,
             "Non-compatible flatbuffers version included");
 
#include "ttmlir/Target/Common/types_generated.h"
 
namespace tt {
namespace target {
namespace metal {
 
struct ShardSpec;
struct ShardSpecBuilder;
 
struct ShardSpecBuffer;
struct ShardSpecBufferBuilder;
 
struct ShardedBufferConfig;
struct ShardedBufferConfigBuilder;
 
struct CircularBufferConfig;
struct CircularBufferConfigBuilder;
 
struct BufferDesc;
struct BufferDescBuilder;
 
struct BufferRef;
struct BufferRefBuilder;
 
struct CBRef;
struct CBRefBuilder;
 
struct ShardSpec FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShardSpecBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.ShardSpec";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CORE_RANGE_SET = 4,
    VT_SHARD_SHAPE = 6
  };
  const ::flatbuffers::Vector<const tt::target::Dim2dRange *> *core_range_set() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::Dim2dRange *> *>(VT_CORE_RANGE_SET);
  }
  const tt::target::Dim2d *shard_shape() const {
    return GetStruct<const tt::target::Dim2d *>(VT_SHARD_SHAPE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CORE_RANGE_SET) &&
           verifier.VerifyVector(core_range_set()) &&
           VerifyField<tt::target::Dim2d>(verifier, VT_SHARD_SHAPE, 4) &&
           verifier.EndTable();
  }
};
 
struct ShardSpecBuilder {
  typedef ShardSpec Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_core_range_set(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2dRange *>> core_range_set) {
    fbb_.AddOffset(ShardSpec::VT_CORE_RANGE_SET, core_range_set);
  }
  void add_shard_shape(const tt::target::Dim2d *shard_shape) {
    fbb_.AddStruct(ShardSpec::VT_SHARD_SHAPE, shard_shape);
  }
  explicit ShardSpecBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ShardSpec> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ShardSpec>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ShardSpec> CreateShardSpec(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2dRange *>> core_range_set = 0,
    const tt::target::Dim2d *shard_shape = nullptr) {
  ShardSpecBuilder builder_(_fbb);
  builder_.add_shard_shape(shard_shape);
  builder_.add_core_range_set(core_range_set);
  return builder_.Finish();
}
 
struct ShardSpec::Traits {
  using type = ShardSpec;
  static auto constexpr Create = CreateShardSpec;
};
 
inline ::flatbuffers::Offset<ShardSpec> CreateShardSpecDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<tt::target::Dim2dRange> *core_range_set = nullptr,
    const tt::target::Dim2d *shard_shape = nullptr) {
  auto core_range_set__ = core_range_set ? _fbb.CreateVectorOfStructs<tt::target::Dim2dRange>(*core_range_set) : 0;
  return tt::target::metal::CreateShardSpec(
      _fbb,
      core_range_set__,
      shard_shape);
}
 
struct ShardSpecBuffer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShardSpecBufferBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.ShardSpecBuffer";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHARD_SPEC = 4,
    VT_PAGE_SHAPE = 6,
    VT_TENSOR_SHAPE_IN_PAGES = 8
  };
  const tt::target::metal::ShardSpec *shard_spec() const {
    return GetPointer<const tt::target::metal::ShardSpec *>(VT_SHARD_SPEC);
  }
  const tt::target::Dim2d *page_shape() const {
    return GetStruct<const tt::target::Dim2d *>(VT_PAGE_SHAPE);
  }
  const tt::target::Dim2d *tensor_shape_in_pages() const {
    return GetStruct<const tt::target::Dim2d *>(VT_TENSOR_SHAPE_IN_PAGES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHARD_SPEC) &&
           verifier.VerifyTable(shard_spec()) &&
           VerifyField<tt::target::Dim2d>(verifier, VT_PAGE_SHAPE, 4) &&
           VerifyField<tt::target::Dim2d>(verifier, VT_TENSOR_SHAPE_IN_PAGES, 4) &&
           verifier.EndTable();
  }
};
 
struct ShardSpecBufferBuilder {
  typedef ShardSpecBuffer Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shard_spec(::flatbuffers::Offset<tt::target::metal::ShardSpec> shard_spec) {
    fbb_.AddOffset(ShardSpecBuffer::VT_SHARD_SPEC, shard_spec);
  }
  void add_page_shape(const tt::target::Dim2d *page_shape) {
    fbb_.AddStruct(ShardSpecBuffer::VT_PAGE_SHAPE, page_shape);
  }
  void add_tensor_shape_in_pages(const tt::target::Dim2d *tensor_shape_in_pages) {
    fbb_.AddStruct(ShardSpecBuffer::VT_TENSOR_SHAPE_IN_PAGES, tensor_shape_in_pages);
  }
  explicit ShardSpecBufferBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ShardSpecBuffer> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ShardSpecBuffer>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ShardSpecBuffer> CreateShardSpecBuffer(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::metal::ShardSpec> shard_spec = 0,
    const tt::target::Dim2d *page_shape = nullptr,
    const tt::target::Dim2d *tensor_shape_in_pages = nullptr) {
  ShardSpecBufferBuilder builder_(_fbb);
  builder_.add_tensor_shape_in_pages(tensor_shape_in_pages);
  builder_.add_page_shape(page_shape);
  builder_.add_shard_spec(shard_spec);
  return builder_.Finish();
}
 
struct ShardSpecBuffer::Traits {
  using type = ShardSpecBuffer;
  static auto constexpr Create = CreateShardSpecBuffer;
};
 
struct ShardedBufferConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShardedBufferConfigBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.ShardedBufferConfig";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SIZE = 4,
    VT_PAGE_SIZE = 6,
    VT_SHARD_SPEC_BUFFER = 8
  };
  uint64_t size() const {
    return GetField<uint64_t>(VT_SIZE, 0);
  }
  uint64_t page_size() const {
    return GetField<uint64_t>(VT_PAGE_SIZE, 0);
  }
  const tt::target::metal::ShardSpecBuffer *shard_spec_buffer() const {
    return GetPointer<const tt::target::metal::ShardSpecBuffer *>(VT_SHARD_SPEC_BUFFER);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
           VerifyField<uint64_t>(verifier, VT_PAGE_SIZE, 8) &&
           VerifyOffset(verifier, VT_SHARD_SPEC_BUFFER) &&
           verifier.VerifyTable(shard_spec_buffer()) &&
           verifier.EndTable();
  }
};
 
struct ShardedBufferConfigBuilder {
  typedef ShardedBufferConfig Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_size(uint64_t size) {
    fbb_.AddElement<uint64_t>(ShardedBufferConfig::VT_SIZE, size, 0);
  }
  void add_page_size(uint64_t page_size) {
    fbb_.AddElement<uint64_t>(ShardedBufferConfig::VT_PAGE_SIZE, page_size, 0);
  }
  void add_shard_spec_buffer(::flatbuffers::Offset<tt::target::metal::ShardSpecBuffer> shard_spec_buffer) {
    fbb_.AddOffset(ShardedBufferConfig::VT_SHARD_SPEC_BUFFER, shard_spec_buffer);
  }
  explicit ShardedBufferConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ShardedBufferConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ShardedBufferConfig>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ShardedBufferConfig> CreateShardedBufferConfig(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint64_t size = 0,
    uint64_t page_size = 0,
    ::flatbuffers::Offset<tt::target::metal::ShardSpecBuffer> shard_spec_buffer = 0) {
  ShardedBufferConfigBuilder builder_(_fbb);
  builder_.add_page_size(page_size);
  builder_.add_size(size);
  builder_.add_shard_spec_buffer(shard_spec_buffer);
  return builder_.Finish();
}
 
struct ShardedBufferConfig::Traits {
  using type = ShardedBufferConfig;
  static auto constexpr Create = CreateShardedBufferConfig;
};
 
struct CircularBufferConfig FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CircularBufferConfigBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.CircularBufferConfig";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CORE_RANGE_SET = 4,
    VT_TOTAL_SIZE = 6,
    VT_PAGE_SIZE = 8,
    VT_NUM_BUFFERS = 10
  };
  const ::flatbuffers::Vector<const tt::target::Dim2dRange *> *core_range_set() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::Dim2dRange *> *>(VT_CORE_RANGE_SET);
  }
  uint64_t total_size() const {
    return GetField<uint64_t>(VT_TOTAL_SIZE, 0);
  }
  uint64_t page_size() const {
    return GetField<uint64_t>(VT_PAGE_SIZE, 0);
  }
  uint64_t num_buffers() const {
    return GetField<uint64_t>(VT_NUM_BUFFERS, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CORE_RANGE_SET) &&
           verifier.VerifyVector(core_range_set()) &&
           VerifyField<uint64_t>(verifier, VT_TOTAL_SIZE, 8) &&
           VerifyField<uint64_t>(verifier, VT_PAGE_SIZE, 8) &&
           VerifyField<uint64_t>(verifier, VT_NUM_BUFFERS, 8) &&
           verifier.EndTable();
  }
};
 
struct CircularBufferConfigBuilder {
  typedef CircularBufferConfig Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_core_range_set(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2dRange *>> core_range_set) {
    fbb_.AddOffset(CircularBufferConfig::VT_CORE_RANGE_SET, core_range_set);
  }
  void add_total_size(uint64_t total_size) {
    fbb_.AddElement<uint64_t>(CircularBufferConfig::VT_TOTAL_SIZE, total_size, 0);
  }
  void add_page_size(uint64_t page_size) {
    fbb_.AddElement<uint64_t>(CircularBufferConfig::VT_PAGE_SIZE, page_size, 0);
  }
  void add_num_buffers(uint64_t num_buffers) {
    fbb_.AddElement<uint64_t>(CircularBufferConfig::VT_NUM_BUFFERS, num_buffers, 0);
  }
  explicit CircularBufferConfigBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CircularBufferConfig> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CircularBufferConfig>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CircularBufferConfig> CreateCircularBufferConfig(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2dRange *>> core_range_set = 0,
    uint64_t total_size = 0,
    uint64_t page_size = 0,
    uint64_t num_buffers = 0) {
  CircularBufferConfigBuilder builder_(_fbb);
  builder_.add_num_buffers(num_buffers);
  builder_.add_page_size(page_size);
  builder_.add_total_size(total_size);
  builder_.add_core_range_set(core_range_set);
  return builder_.Finish();
}
 
struct CircularBufferConfig::Traits {
  using type = CircularBufferConfig;
  static auto constexpr Create = CreateCircularBufferConfig;
};
 
inline ::flatbuffers::Offset<CircularBufferConfig> CreateCircularBufferConfigDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<tt::target::Dim2dRange> *core_range_set = nullptr,
    uint64_t total_size = 0,
    uint64_t page_size = 0,
    uint64_t num_buffers = 0) {
  auto core_range_set__ = core_range_set ? _fbb.CreateVectorOfStructs<tt::target::Dim2dRange>(*core_range_set) : 0;
  return tt::target::metal::CreateCircularBufferConfig(
      _fbb,
      core_range_set__,
      total_size,
      page_size,
      num_buffers);
}
 
struct BufferDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BufferDescBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.BufferDesc";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_TILE_SHAPE = 6,
    VT_DATA_TYPE = 8,
    VT_MEMORY_SPACE = 10,
    VT_SHARDED_BUFFER_CONFIG = 12,
    VT_CIRCULAR_BUFFER_CONFIG = 14
  };
  const ::flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  const tt::target::Dim2d *tile_shape() const {
    return GetStruct<const tt::target::Dim2d *>(VT_TILE_SHAPE);
  }
  tt::target::DataType data_type() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DATA_TYPE, 0));
  }
  tt::target::MemorySpace memory_space() const {
    return static_cast<tt::target::MemorySpace>(GetField<uint16_t>(VT_MEMORY_SPACE, 0));
  }
  const tt::target::metal::ShardedBufferConfig *sharded_buffer_config() const {
    return GetPointer<const tt::target::metal::ShardedBufferConfig *>(VT_SHARDED_BUFFER_CONFIG);
  }
  const tt::target::metal::CircularBufferConfig *circular_buffer_config() const {
    return GetPointer<const tt::target::metal::CircularBufferConfig *>(VT_CIRCULAR_BUFFER_CONFIG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyField<tt::target::Dim2d>(verifier, VT_TILE_SHAPE, 4) &&
           VerifyField<uint16_t>(verifier, VT_DATA_TYPE, 2) &&
           VerifyField<uint16_t>(verifier, VT_MEMORY_SPACE, 2) &&
           VerifyOffset(verifier, VT_SHARDED_BUFFER_CONFIG) &&
           verifier.VerifyTable(sharded_buffer_config()) &&
           VerifyOffset(verifier, VT_CIRCULAR_BUFFER_CONFIG) &&
           verifier.VerifyTable(circular_buffer_config()) &&
           verifier.EndTable();
  }
};
 
struct BufferDescBuilder {
  typedef BufferDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(BufferDesc::VT_SHAPE, shape);
  }
  void add_tile_shape(const tt::target::Dim2d *tile_shape) {
    fbb_.AddStruct(BufferDesc::VT_TILE_SHAPE, tile_shape);
  }
  void add_data_type(tt::target::DataType data_type) {
    fbb_.AddElement<uint16_t>(BufferDesc::VT_DATA_TYPE, static_cast<uint16_t>(data_type), 0);
  }
  void add_memory_space(tt::target::MemorySpace memory_space) {
    fbb_.AddElement<uint16_t>(BufferDesc::VT_MEMORY_SPACE, static_cast<uint16_t>(memory_space), 0);
  }
  void add_sharded_buffer_config(::flatbuffers::Offset<tt::target::metal::ShardedBufferConfig> sharded_buffer_config) {
    fbb_.AddOffset(BufferDesc::VT_SHARDED_BUFFER_CONFIG, sharded_buffer_config);
  }
  void add_circular_buffer_config(::flatbuffers::Offset<tt::target::metal::CircularBufferConfig> circular_buffer_config) {
    fbb_.AddOffset(BufferDesc::VT_CIRCULAR_BUFFER_CONFIG, circular_buffer_config);
  }
  explicit BufferDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BufferDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BufferDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<BufferDesc> CreateBufferDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
    const tt::target::Dim2d *tile_shape = nullptr,
    tt::target::DataType data_type = tt::target::DataType::Float32,
    tt::target::MemorySpace memory_space = tt::target::MemorySpace::System,
    ::flatbuffers::Offset<tt::target::metal::ShardedBufferConfig> sharded_buffer_config = 0,
    ::flatbuffers::Offset<tt::target::metal::CircularBufferConfig> circular_buffer_config = 0) {
  BufferDescBuilder builder_(_fbb);
  builder_.add_circular_buffer_config(circular_buffer_config);
  builder_.add_sharded_buffer_config(sharded_buffer_config);
  builder_.add_tile_shape(tile_shape);
  builder_.add_shape(shape);
  builder_.add_memory_space(memory_space);
  builder_.add_data_type(data_type);
  return builder_.Finish();
}
 
struct BufferDesc::Traits {
  using type = BufferDesc;
  static auto constexpr Create = CreateBufferDesc;
};
 
inline ::flatbuffers::Offset<BufferDesc> CreateBufferDescDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *shape = nullptr,
    const tt::target::Dim2d *tile_shape = nullptr,
    tt::target::DataType data_type = tt::target::DataType::Float32,
    tt::target::MemorySpace memory_space = tt::target::MemorySpace::System,
    ::flatbuffers::Offset<tt::target::metal::ShardedBufferConfig> sharded_buffer_config = 0,
    ::flatbuffers::Offset<tt::target::metal::CircularBufferConfig> circular_buffer_config = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  return tt::target::metal::CreateBufferDesc(
      _fbb,
      shape__,
      tile_shape,
      data_type,
      memory_space,
      sharded_buffer_config,
      circular_buffer_config);
}
 
struct BufferRef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef BufferRefBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.BufferRef";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_GLOBAL_ID = 4,
    VT_ADDRESS = 6,
    VT_DESC = 8
  };
  uint32_t global_id() const {
    return GetField<uint32_t>(VT_GLOBAL_ID, 0);
  }
  uint64_t address() const {
    return GetField<uint64_t>(VT_ADDRESS, 0);
  }
  const tt::target::metal::BufferDesc *desc() const {
    return GetPointer<const tt::target::metal::BufferDesc *>(VT_DESC);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_GLOBAL_ID, 4) &&
           VerifyField<uint64_t>(verifier, VT_ADDRESS, 8) &&
           VerifyOffset(verifier, VT_DESC) &&
           verifier.VerifyTable(desc()) &&
           verifier.EndTable();
  }
};
 
struct BufferRefBuilder {
  typedef BufferRef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_global_id(uint32_t global_id) {
    fbb_.AddElement<uint32_t>(BufferRef::VT_GLOBAL_ID, global_id, 0);
  }
  void add_address(uint64_t address) {
    fbb_.AddElement<uint64_t>(BufferRef::VT_ADDRESS, address, 0);
  }
  void add_desc(::flatbuffers::Offset<tt::target::metal::BufferDesc> desc) {
    fbb_.AddOffset(BufferRef::VT_DESC, desc);
  }
  explicit BufferRefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<BufferRef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<BufferRef>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<BufferRef> CreateBufferRef(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t global_id = 0,
    uint64_t address = 0,
    ::flatbuffers::Offset<tt::target::metal::BufferDesc> desc = 0) {
  BufferRefBuilder builder_(_fbb);
  builder_.add_address(address);
  builder_.add_desc(desc);
  builder_.add_global_id(global_id);
  return builder_.Finish();
}
 
struct BufferRef::Traits {
  using type = BufferRef;
  static auto constexpr Create = CreateBufferRef;
};
 
struct CBRef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CBRefBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.metal.CBRef";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PORT = 4,
    VT_BUFFER_REF = 6
  };
  uint32_t port() const {
    return GetField<uint32_t>(VT_PORT, 0);
  }
  const tt::target::metal::BufferRef *buffer_ref() const {
    return GetPointer<const tt::target::metal::BufferRef *>(VT_BUFFER_REF);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_PORT, 4) &&
           VerifyOffset(verifier, VT_BUFFER_REF) &&
           verifier.VerifyTable(buffer_ref()) &&
           verifier.EndTable();
  }
};
 
struct CBRefBuilder {
  typedef CBRef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_port(uint32_t port) {
    fbb_.AddElement<uint32_t>(CBRef::VT_PORT, port, 0);
  }
  void add_buffer_ref(::flatbuffers::Offset<tt::target::metal::BufferRef> buffer_ref) {
    fbb_.AddOffset(CBRef::VT_BUFFER_REF, buffer_ref);
  }
  explicit CBRefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CBRef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CBRef>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CBRef> CreateCBRef(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t port = 0,
    ::flatbuffers::Offset<tt::target::metal::BufferRef> buffer_ref = 0) {
  CBRefBuilder builder_(_fbb);
  builder_.add_buffer_ref(buffer_ref);
  builder_.add_port(port);
  return builder_.Finish();
}
 
struct CBRef::Traits {
  using type = CBRef;
  static auto constexpr Create = CreateCBRef;
};
 
}  // namespace metal
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_TYPES_TT_TARGET_METAL_H_