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_H_
#define FLATBUFFERS_GENERATED_TYPES_TT_TARGET_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");
 
namespace tt {
namespace target {
 
struct Dim2d;
 
struct Dim2dRange;
 
struct MemoryConfigDesc;
struct MemoryConfigDescBuilder;
 
struct MemoryDesc;
struct MemoryDescBuilder;
 
struct LayoutDesc;
struct LayoutDescBuilder;
 
struct TensorDesc;
struct TensorDescBuilder;
 
struct CBDesc;
struct CBDescBuilder;
 
struct TensorRef;
struct TensorRefBuilder;
 
struct CBRef;
struct CBRefBuilder;
 
struct ChipDesc;
struct ChipDescBuilder;
 
struct ChipCoord;
 
struct ChipChannel;
 
struct ChipPhysicalCores;
struct ChipPhysicalCoresBuilder;
 
struct SystemDesc;
struct SystemDescBuilder;
 
struct DeviceRef;
struct DeviceRefBuilder;
 
struct EventRef;
struct EventRefBuilder;
 
enum class Arch : uint32_t {
  Grayskull = 0,
  Wormhole_b0 = 1,
  Blackhole = 2,
  MIN = Grayskull,
  MAX = Blackhole
};
 
inline const Arch (&EnumValuesArch())[3] {
  static const Arch values[] = {
    Arch::Grayskull,
    Arch::Wormhole_b0,
    Arch::Blackhole
  };
  return values;
}
 
inline const char * const *EnumNamesArch() {
  static const char * const names[4] = {
    "Grayskull",
    "Wormhole_b0",
    "Blackhole",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameArch(Arch e) {
  if (::flatbuffers::IsOutRange(e, Arch::Grayskull, Arch::Blackhole)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesArch()[index];
}
 
enum class DataType : uint16_t {
  Float32 = 0,
  Float16 = 1,
  BFloat16 = 2,
  BFP_Float8 = 3,
  BFP_BFloat8 = 4,
  BFP_Float4 = 5,
  BFP_BFloat4 = 6,
  BFP_Float2 = 7,
  BFP_BFloat2 = 8,
  UInt32 = 9,
  UInt16 = 10,
  UInt8 = 11,
  MIN = Float32,
  MAX = UInt8
};
 
inline const DataType (&EnumValuesDataType())[12] {
  static const DataType values[] = {
    DataType::Float32,
    DataType::Float16,
    DataType::BFloat16,
    DataType::BFP_Float8,
    DataType::BFP_BFloat8,
    DataType::BFP_Float4,
    DataType::BFP_BFloat4,
    DataType::BFP_Float2,
    DataType::BFP_BFloat2,
    DataType::UInt32,
    DataType::UInt16,
    DataType::UInt8
  };
  return values;
}
 
inline const char * const *EnumNamesDataType() {
  static const char * const names[13] = {
    "Float32",
    "Float16",
    "BFloat16",
    "BFP_Float8",
    "BFP_BFloat8",
    "BFP_Float4",
    "BFP_BFloat4",
    "BFP_Float2",
    "BFP_BFloat2",
    "UInt32",
    "UInt16",
    "UInt8",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameDataType(DataType e) {
  if (::flatbuffers::IsOutRange(e, DataType::Float32, DataType::UInt8)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesDataType()[index];
}
 
enum class OOBVal : uint16_t {
  Undef = 0,
  Zero = 1,
  One = 2,
  Inf = 3,
  NegInf = 4,
  MIN = Undef,
  MAX = NegInf
};
 
inline const OOBVal (&EnumValuesOOBVal())[5] {
  static const OOBVal values[] = {
    OOBVal::Undef,
    OOBVal::Zero,
    OOBVal::One,
    OOBVal::Inf,
    OOBVal::NegInf
  };
  return values;
}
 
inline const char * const *EnumNamesOOBVal() {
  static const char * const names[6] = {
    "Undef",
    "Zero",
    "One",
    "Inf",
    "NegInf",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameOOBVal(OOBVal e) {
  if (::flatbuffers::IsOutRange(e, OOBVal::Undef, OOBVal::NegInf)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesOOBVal()[index];
}
 
enum class MemorySpace : uint16_t {
  System = 0,
  SystemMMIO = 1,
  DeviceDRAM = 2,
  DeviceL1 = 3,
  MIN = System,
  MAX = DeviceL1
};
 
inline const MemorySpace (&EnumValuesMemorySpace())[4] {
  static const MemorySpace values[] = {
    MemorySpace::System,
    MemorySpace::SystemMMIO,
    MemorySpace::DeviceDRAM,
    MemorySpace::DeviceL1
  };
  return values;
}
 
inline const char * const *EnumNamesMemorySpace() {
  static const char * const names[5] = {
    "System",
    "SystemMMIO",
    "DeviceDRAM",
    "DeviceL1",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameMemorySpace(MemorySpace e) {
  if (::flatbuffers::IsOutRange(e, MemorySpace::System, MemorySpace::DeviceL1)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMemorySpace()[index];
}
 
enum class ChipCapability : uint32_t {
  PCIE = 1,
  HostMMIO = 2,
  NONE = 0,
  ANY = 3
};
FLATBUFFERS_DEFINE_BITMASK_OPERATORS(ChipCapability, uint32_t)
 
inline const ChipCapability (&EnumValuesChipCapability())[2] {
  static const ChipCapability values[] = {
    ChipCapability::PCIE,
    ChipCapability::HostMMIO
  };
  return values;
}
 
inline const char * const *EnumNamesChipCapability() {
  static const char * const names[3] = {
    "PCIE",
    "HostMMIO",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameChipCapability(ChipCapability e) {
  if (::flatbuffers::IsOutRange(e, ChipCapability::PCIE, ChipCapability::HostMMIO)) return "";
  const size_t index = static_cast<size_t>(e) - static_cast<size_t>(ChipCapability::PCIE);
  return EnumNamesChipCapability()[index];
}
 
enum class TensorMemoryLayout : uint16_t {
  None = 0,
  Interleaved = 1,
  SingleBank = 2,
  HeightSharded = 3,
  WidthSharded = 4,
  BlockSharded = 5,
  MIN = None,
  MAX = BlockSharded
};
 
inline const TensorMemoryLayout (&EnumValuesTensorMemoryLayout())[6] {
  static const TensorMemoryLayout values[] = {
    TensorMemoryLayout::None,
    TensorMemoryLayout::Interleaved,
    TensorMemoryLayout::SingleBank,
    TensorMemoryLayout::HeightSharded,
    TensorMemoryLayout::WidthSharded,
    TensorMemoryLayout::BlockSharded
  };
  return values;
}
 
inline const char * const *EnumNamesTensorMemoryLayout() {
  static const char * const names[7] = {
    "None",
    "Interleaved",
    "SingleBank",
    "HeightSharded",
    "WidthSharded",
    "BlockSharded",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameTensorMemoryLayout(TensorMemoryLayout e) {
  if (::flatbuffers::IsOutRange(e, TensorMemoryLayout::None, TensorMemoryLayout::BlockSharded)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesTensorMemoryLayout()[index];
}
 
enum class TensorLayout : uint16_t {
  RowMajor = 0,
  Tile = 1,
  Invalid = 2,
  MIN = RowMajor,
  MAX = Invalid
};
 
inline const TensorLayout (&EnumValuesTensorLayout())[3] {
  static const TensorLayout values[] = {
    TensorLayout::RowMajor,
    TensorLayout::Tile,
    TensorLayout::Invalid
  };
  return values;
}
 
inline const char * const *EnumNamesTensorLayout() {
  static const char * const names[4] = {
    "RowMajor",
    "Tile",
    "Invalid",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameTensorLayout(TensorLayout e) {
  if (::flatbuffers::IsOutRange(e, TensorLayout::RowMajor, TensorLayout::Invalid)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesTensorLayout()[index];
}
 
enum class BufferType : uint16_t {
  DRAM = 0,
  L1 = 1,
  SystemMemory = 2,
  L1Small = 3,
  Trace = 4,
  MIN = DRAM,
  MAX = Trace
};
 
inline const BufferType (&EnumValuesBufferType())[5] {
  static const BufferType values[] = {
    BufferType::DRAM,
    BufferType::L1,
    BufferType::SystemMemory,
    BufferType::L1Small,
    BufferType::Trace
  };
  return values;
}
 
inline const char * const *EnumNamesBufferType() {
  static const char * const names[6] = {
    "DRAM",
    "L1",
    "SystemMemory",
    "L1Small",
    "Trace",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameBufferType(BufferType e) {
  if (::flatbuffers::IsOutRange(e, BufferType::DRAM, BufferType::Trace)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesBufferType()[index];
}
 
enum class MathFidelity : uint8_t {
  LoFi = 0,
  HiFi2 = 2,
  HiFi3 = 3,
  HiFi4 = 4,
  MIN = LoFi,
  MAX = HiFi4
};
 
inline const MathFidelity (&EnumValuesMathFidelity())[4] {
  static const MathFidelity values[] = {
    MathFidelity::LoFi,
    MathFidelity::HiFi2,
    MathFidelity::HiFi3,
    MathFidelity::HiFi4
  };
  return values;
}
 
inline const char * const *EnumNamesMathFidelity() {
  static const char * const names[6] = {
    "LoFi",
    "",
    "HiFi2",
    "HiFi3",
    "HiFi4",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameMathFidelity(MathFidelity e) {
  if (::flatbuffers::IsOutRange(e, MathFidelity::LoFi, MathFidelity::HiFi4)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesMathFidelity()[index];
}
 
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Dim2d FLATBUFFERS_FINAL_CLASS {
 private:
  int32_t y_;
  int32_t x_;
 
 public:
  struct Traits;
  Dim2d()
      : y_(0),
        x_(0) {
  }
  Dim2d(int32_t _y, int32_t _x)
      : y_(::flatbuffers::EndianScalar(_y)),
        x_(::flatbuffers::EndianScalar(_x)) {
  }
  int32_t y() const {
    return ::flatbuffers::EndianScalar(y_);
  }
  int32_t x() const {
    return ::flatbuffers::EndianScalar(x_);
  }
};
FLATBUFFERS_STRUCT_END(Dim2d, 8);
 
struct Dim2d::Traits {
  using type = Dim2d;
};
 
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Dim2dRange FLATBUFFERS_FINAL_CLASS {
 private:
  tt::target::Dim2d loc_;
  tt::target::Dim2d size_;
 
 public:
  struct Traits;
  Dim2dRange()
      : loc_(),
        size_() {
  }
  Dim2dRange(const tt::target::Dim2d &_loc, const tt::target::Dim2d &_size)
      : loc_(_loc),
        size_(_size) {
  }
  const tt::target::Dim2d &loc() const {
    return loc_;
  }
  const tt::target::Dim2d &size() const {
    return size_;
  }
};
FLATBUFFERS_STRUCT_END(Dim2dRange, 16);
 
struct Dim2dRange::Traits {
  using type = Dim2dRange;
};
 
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) ChipCoord FLATBUFFERS_FINAL_CLASS {
 private:
  uint32_t rack_;
  uint32_t shelf_;
  uint32_t y_;
  uint32_t x_;
 
 public:
  struct Traits;
  ChipCoord()
      : rack_(0),
        shelf_(0),
        y_(0),
        x_(0) {
  }
  ChipCoord(uint32_t _rack, uint32_t _shelf, uint32_t _y, uint32_t _x)
      : rack_(::flatbuffers::EndianScalar(_rack)),
        shelf_(::flatbuffers::EndianScalar(_shelf)),
        y_(::flatbuffers::EndianScalar(_y)),
        x_(::flatbuffers::EndianScalar(_x)) {
  }
  uint32_t rack() const {
    return ::flatbuffers::EndianScalar(rack_);
  }
  uint32_t shelf() const {
    return ::flatbuffers::EndianScalar(shelf_);
  }
  uint32_t y() const {
    return ::flatbuffers::EndianScalar(y_);
  }
  uint32_t x() const {
    return ::flatbuffers::EndianScalar(x_);
  }
};
FLATBUFFERS_STRUCT_END(ChipCoord, 16);
 
struct ChipCoord::Traits {
  using type = ChipCoord;
};
 
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) ChipChannel FLATBUFFERS_FINAL_CLASS {
 private:
  uint32_t device_id0_;
  tt::target::Dim2d ethernet_core_coord0_;
  uint32_t device_id1_;
  tt::target::Dim2d ethernet_core_coord1_;
 
 public:
  struct Traits;
  ChipChannel()
      : device_id0_(0),
        ethernet_core_coord0_(),
        device_id1_(0),
        ethernet_core_coord1_() {
  }
  ChipChannel(uint32_t _device_id0, const tt::target::Dim2d &_ethernet_core_coord0, uint32_t _device_id1, const tt::target::Dim2d &_ethernet_core_coord1)
      : device_id0_(::flatbuffers::EndianScalar(_device_id0)),
        ethernet_core_coord0_(_ethernet_core_coord0),
        device_id1_(::flatbuffers::EndianScalar(_device_id1)),
        ethernet_core_coord1_(_ethernet_core_coord1) {
  }
  uint32_t device_id0() const {
    return ::flatbuffers::EndianScalar(device_id0_);
  }
  const tt::target::Dim2d &ethernet_core_coord0() const {
    return ethernet_core_coord0_;
  }
  uint32_t device_id1() const {
    return ::flatbuffers::EndianScalar(device_id1_);
  }
  const tt::target::Dim2d &ethernet_core_coord1() const {
    return ethernet_core_coord1_;
  }
};
FLATBUFFERS_STRUCT_END(ChipChannel, 24);
 
struct ChipChannel::Traits {
  using type = ChipChannel;
};
 
struct MemoryConfigDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MemoryConfigDescBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TENSOR_MEMORY_LAYOUT = 4,
    VT_BUFFER_TYPE = 6
  };
  tt::target::TensorMemoryLayout tensor_memory_layout() const {
    return static_cast<tt::target::TensorMemoryLayout>(GetField<uint16_t>(VT_TENSOR_MEMORY_LAYOUT, 0));
  }
  tt::target::BufferType buffer_type() const {
    return static_cast<tt::target::BufferType>(GetField<uint16_t>(VT_BUFFER_TYPE, 0));
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint16_t>(verifier, VT_TENSOR_MEMORY_LAYOUT, 2) &&
           VerifyField<uint16_t>(verifier, VT_BUFFER_TYPE, 2) &&
           verifier.EndTable();
  }
};
 
struct MemoryConfigDescBuilder {
  typedef MemoryConfigDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_tensor_memory_layout(tt::target::TensorMemoryLayout tensor_memory_layout) {
    fbb_.AddElement<uint16_t>(MemoryConfigDesc::VT_TENSOR_MEMORY_LAYOUT, static_cast<uint16_t>(tensor_memory_layout), 0);
  }
  void add_buffer_type(tt::target::BufferType buffer_type) {
    fbb_.AddElement<uint16_t>(MemoryConfigDesc::VT_BUFFER_TYPE, static_cast<uint16_t>(buffer_type), 0);
  }
  explicit MemoryConfigDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MemoryConfigDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MemoryConfigDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MemoryConfigDesc> CreateMemoryConfigDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::TensorMemoryLayout tensor_memory_layout = tt::target::TensorMemoryLayout::None,
    tt::target::BufferType buffer_type = tt::target::BufferType::DRAM) {
  MemoryConfigDescBuilder builder_(_fbb);
  builder_.add_buffer_type(buffer_type);
  builder_.add_tensor_memory_layout(tensor_memory_layout);
  return builder_.Finish();
}
 
struct MemoryConfigDesc::Traits {
  using type = MemoryConfigDesc;
  static auto constexpr Create = CreateMemoryConfigDesc;
};
 
struct MemoryDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MemoryDescBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_TILE_SHAPE = 6,
    VT_DATA_TYPE = 8,
    VT_MEMORY_SPACE = 10,
    VT_MEMORY_LAYOUT = 12,
    VT_SIZE = 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));
  }
  tt::target::TensorMemoryLayout memory_layout() const {
    return static_cast<tt::target::TensorMemoryLayout>(GetField<uint16_t>(VT_MEMORY_LAYOUT, 0));
  }
  uint64_t size() const {
    return GetField<uint64_t>(VT_SIZE, 0);
  }
  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) &&
           VerifyField<uint16_t>(verifier, VT_MEMORY_LAYOUT, 2) &&
           VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
           verifier.EndTable();
  }
};
 
struct MemoryDescBuilder {
  typedef MemoryDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(MemoryDesc::VT_SHAPE, shape);
  }
  void add_tile_shape(const tt::target::Dim2d *tile_shape) {
    fbb_.AddStruct(MemoryDesc::VT_TILE_SHAPE, tile_shape);
  }
  void add_data_type(tt::target::DataType data_type) {
    fbb_.AddElement<uint16_t>(MemoryDesc::VT_DATA_TYPE, static_cast<uint16_t>(data_type), 0);
  }
  void add_memory_space(tt::target::MemorySpace memory_space) {
    fbb_.AddElement<uint16_t>(MemoryDesc::VT_MEMORY_SPACE, static_cast<uint16_t>(memory_space), 0);
  }
  void add_memory_layout(tt::target::TensorMemoryLayout memory_layout) {
    fbb_.AddElement<uint16_t>(MemoryDesc::VT_MEMORY_LAYOUT, static_cast<uint16_t>(memory_layout), 0);
  }
  void add_size(uint64_t size) {
    fbb_.AddElement<uint64_t>(MemoryDesc::VT_SIZE, size, 0);
  }
  explicit MemoryDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MemoryDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MemoryDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MemoryDesc> CreateMemoryDesc(
    ::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,
    tt::target::TensorMemoryLayout memory_layout = tt::target::TensorMemoryLayout::None,
    uint64_t size = 0) {
  MemoryDescBuilder builder_(_fbb);
  builder_.add_size(size);
  builder_.add_tile_shape(tile_shape);
  builder_.add_shape(shape);
  builder_.add_memory_layout(memory_layout);
  builder_.add_memory_space(memory_space);
  builder_.add_data_type(data_type);
  return builder_.Finish();
}
 
struct MemoryDesc::Traits {
  using type = MemoryDesc;
  static auto constexpr Create = CreateMemoryDesc;
};
 
inline ::flatbuffers::Offset<MemoryDesc> CreateMemoryDescDirect(
    ::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,
    tt::target::TensorMemoryLayout memory_layout = tt::target::TensorMemoryLayout::None,
    uint64_t size = 0) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  return tt::target::CreateMemoryDesc(
      _fbb,
      shape__,
      tile_shape,
      data_type,
      memory_space,
      memory_layout,
      size);
}
 
struct LayoutDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef LayoutDescBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STRIDE = 4,
    VT_OOB_VAL = 6,
    VT_CORE_RANGE_SET = 8,
    VT_MEMORY_DESC = 10
  };
  const ::flatbuffers::Vector<int32_t> *stride() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_STRIDE);
  }
  tt::target::OOBVal oob_val() const {
    return static_cast<tt::target::OOBVal>(GetField<uint16_t>(VT_OOB_VAL, 0));
  }
  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::MemoryDesc *memory_desc() const {
    return GetPointer<const tt::target::MemoryDesc *>(VT_MEMORY_DESC);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_STRIDE) &&
           verifier.VerifyVector(stride()) &&
           VerifyField<uint16_t>(verifier, VT_OOB_VAL, 2) &&
           VerifyOffset(verifier, VT_CORE_RANGE_SET) &&
           verifier.VerifyVector(core_range_set()) &&
           VerifyOffset(verifier, VT_MEMORY_DESC) &&
           verifier.VerifyTable(memory_desc()) &&
           verifier.EndTable();
  }
};
 
struct LayoutDescBuilder {
  typedef LayoutDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_stride(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride) {
    fbb_.AddOffset(LayoutDesc::VT_STRIDE, stride);
  }
  void add_oob_val(tt::target::OOBVal oob_val) {
    fbb_.AddElement<uint16_t>(LayoutDesc::VT_OOB_VAL, static_cast<uint16_t>(oob_val), 0);
  }
  void add_core_range_set(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2dRange *>> core_range_set) {
    fbb_.AddOffset(LayoutDesc::VT_CORE_RANGE_SET, core_range_set);
  }
  void add_memory_desc(::flatbuffers::Offset<tt::target::MemoryDesc> memory_desc) {
    fbb_.AddOffset(LayoutDesc::VT_MEMORY_DESC, memory_desc);
  }
  explicit LayoutDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<LayoutDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<LayoutDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<LayoutDesc> CreateLayoutDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride = 0,
    tt::target::OOBVal oob_val = tt::target::OOBVal::Undef,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2dRange *>> core_range_set = 0,
    ::flatbuffers::Offset<tt::target::MemoryDesc> memory_desc = 0) {
  LayoutDescBuilder builder_(_fbb);
  builder_.add_memory_desc(memory_desc);
  builder_.add_core_range_set(core_range_set);
  builder_.add_stride(stride);
  builder_.add_oob_val(oob_val);
  return builder_.Finish();
}
 
struct LayoutDesc::Traits {
  using type = LayoutDesc;
  static auto constexpr Create = CreateLayoutDesc;
};
 
inline ::flatbuffers::Offset<LayoutDesc> CreateLayoutDescDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *stride = nullptr,
    tt::target::OOBVal oob_val = tt::target::OOBVal::Undef,
    const std::vector<tt::target::Dim2dRange> *core_range_set = nullptr,
    ::flatbuffers::Offset<tt::target::MemoryDesc> memory_desc = 0) {
  auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
  auto core_range_set__ = core_range_set ? _fbb.CreateVectorOfStructs<tt::target::Dim2dRange>(*core_range_set) : 0;
  return tt::target::CreateLayoutDesc(
      _fbb,
      stride__,
      oob_val,
      core_range_set__,
      memory_desc);
}
 
struct TensorDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TensorDescBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHAPE = 4,
    VT_LAYOUT = 6,
    VT_CONSTANT_DATA = 8
  };
  const ::flatbuffers::Vector<int32_t> *shape() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SHAPE);
  }
  const tt::target::LayoutDesc *layout() const {
    return GetPointer<const tt::target::LayoutDesc *>(VT_LAYOUT);
  }
  const ::flatbuffers::Vector<uint8_t> *constant_data() const {
    return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_CONSTANT_DATA);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyOffset(verifier, VT_LAYOUT) &&
           verifier.VerifyTable(layout()) &&
           VerifyOffset(verifier, VT_CONSTANT_DATA) &&
           verifier.VerifyVector(constant_data()) &&
           verifier.EndTable();
  }
};
 
struct TensorDescBuilder {
  typedef TensorDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shape(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape) {
    fbb_.AddOffset(TensorDesc::VT_SHAPE, shape);
  }
  void add_layout(::flatbuffers::Offset<tt::target::LayoutDesc> layout) {
    fbb_.AddOffset(TensorDesc::VT_LAYOUT, layout);
  }
  void add_constant_data(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> constant_data) {
    fbb_.AddOffset(TensorDesc::VT_CONSTANT_DATA, constant_data);
  }
  explicit TensorDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TensorDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TensorDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TensorDesc> CreateTensorDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> shape = 0,
    ::flatbuffers::Offset<tt::target::LayoutDesc> layout = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> constant_data = 0) {
  TensorDescBuilder builder_(_fbb);
  builder_.add_constant_data(constant_data);
  builder_.add_layout(layout);
  builder_.add_shape(shape);
  return builder_.Finish();
}
 
struct TensorDesc::Traits {
  using type = TensorDesc;
  static auto constexpr Create = CreateTensorDesc;
};
 
inline ::flatbuffers::Offset<TensorDesc> CreateTensorDescDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *shape = nullptr,
    ::flatbuffers::Offset<tt::target::LayoutDesc> layout = 0,
    const std::vector<uint8_t> *constant_data = nullptr) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  auto constant_data__ = constant_data ? _fbb.CreateVector<uint8_t>(*constant_data) : 0;
  return tt::target::CreateTensorDesc(
      _fbb,
      shape__,
      layout,
      constant_data__);
}
 
struct CBDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CBDescBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_PORT = 4,
    VT_MEMORY_DESC = 6,
    VT_PAGE_SIZE = 8,
    VT_NUM_BUFFERS = 10
  };
  uint32_t port() const {
    return GetField<uint32_t>(VT_PORT, 0);
  }
  const tt::target::MemoryDesc *memory_desc() const {
    return GetPointer<const tt::target::MemoryDesc *>(VT_MEMORY_DESC);
  }
  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) &&
           VerifyField<uint32_t>(verifier, VT_PORT, 4) &&
           VerifyOffset(verifier, VT_MEMORY_DESC) &&
           verifier.VerifyTable(memory_desc()) &&
           VerifyField<uint64_t>(verifier, VT_PAGE_SIZE, 8) &&
           VerifyField<uint64_t>(verifier, VT_NUM_BUFFERS, 8) &&
           verifier.EndTable();
  }
};
 
struct CBDescBuilder {
  typedef CBDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_port(uint32_t port) {
    fbb_.AddElement<uint32_t>(CBDesc::VT_PORT, port, 0);
  }
  void add_memory_desc(::flatbuffers::Offset<tt::target::MemoryDesc> memory_desc) {
    fbb_.AddOffset(CBDesc::VT_MEMORY_DESC, memory_desc);
  }
  void add_page_size(uint64_t page_size) {
    fbb_.AddElement<uint64_t>(CBDesc::VT_PAGE_SIZE, page_size, 0);
  }
  void add_num_buffers(uint64_t num_buffers) {
    fbb_.AddElement<uint64_t>(CBDesc::VT_NUM_BUFFERS, num_buffers, 0);
  }
  explicit CBDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CBDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CBDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CBDesc> CreateCBDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t port = 0,
    ::flatbuffers::Offset<tt::target::MemoryDesc> memory_desc = 0,
    uint64_t page_size = 0,
    uint64_t num_buffers = 0) {
  CBDescBuilder builder_(_fbb);
  builder_.add_num_buffers(num_buffers);
  builder_.add_page_size(page_size);
  builder_.add_memory_desc(memory_desc);
  builder_.add_port(port);
  return builder_.Finish();
}
 
struct CBDesc::Traits {
  using type = CBDesc;
  static auto constexpr Create = CreateCBDesc;
};
 
struct TensorRef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TensorRefBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_GLOBAL_ID = 4,
    VT_ADDRESS = 6,
    VT_SIZE = 8,
    VT_DESC = 10
  };
  uint32_t global_id() const {
    return GetField<uint32_t>(VT_GLOBAL_ID, 0);
  }
  uint64_t address() const {
    return GetField<uint64_t>(VT_ADDRESS, 0);
  }
  uint64_t size() const {
    return GetField<uint64_t>(VT_SIZE, 0);
  }
  const tt::target::TensorDesc *desc() const {
    return GetPointer<const tt::target::TensorDesc *>(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) &&
           VerifyField<uint64_t>(verifier, VT_SIZE, 8) &&
           VerifyOffset(verifier, VT_DESC) &&
           verifier.VerifyTable(desc()) &&
           verifier.EndTable();
  }
};
 
struct TensorRefBuilder {
  typedef TensorRef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_global_id(uint32_t global_id) {
    fbb_.AddElement<uint32_t>(TensorRef::VT_GLOBAL_ID, global_id, 0);
  }
  void add_address(uint64_t address) {
    fbb_.AddElement<uint64_t>(TensorRef::VT_ADDRESS, address, 0);
  }
  void add_size(uint64_t size) {
    fbb_.AddElement<uint64_t>(TensorRef::VT_SIZE, size, 0);
  }
  void add_desc(::flatbuffers::Offset<tt::target::TensorDesc> desc) {
    fbb_.AddOffset(TensorRef::VT_DESC, desc);
  }
  explicit TensorRefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TensorRef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TensorRef>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TensorRef> CreateTensorRef(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t global_id = 0,
    uint64_t address = 0,
    uint64_t size = 0,
    ::flatbuffers::Offset<tt::target::TensorDesc> desc = 0) {
  TensorRefBuilder builder_(_fbb);
  builder_.add_size(size);
  builder_.add_address(address);
  builder_.add_desc(desc);
  builder_.add_global_id(global_id);
  return builder_.Finish();
}
 
struct TensorRef::Traits {
  using type = TensorRef;
  static auto constexpr Create = CreateTensorRef;
};
 
struct CBRef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CBRefBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_GLOBAL_ID = 4,
    VT_TENSOR_REF = 6,
    VT_ADDRESS = 8,
    VT_DESC = 10
  };
  uint32_t global_id() const {
    return GetField<uint32_t>(VT_GLOBAL_ID, 0);
  }
  const tt::target::TensorRef *tensor_ref() const {
    return GetPointer<const tt::target::TensorRef *>(VT_TENSOR_REF);
  }
  uint64_t address() const {
    return GetField<uint64_t>(VT_ADDRESS, 0);
  }
  const tt::target::CBDesc *desc() const {
    return GetPointer<const tt::target::CBDesc *>(VT_DESC);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_GLOBAL_ID, 4) &&
           VerifyOffset(verifier, VT_TENSOR_REF) &&
           verifier.VerifyTable(tensor_ref()) &&
           VerifyField<uint64_t>(verifier, VT_ADDRESS, 8) &&
           VerifyOffset(verifier, VT_DESC) &&
           verifier.VerifyTable(desc()) &&
           verifier.EndTable();
  }
};
 
struct CBRefBuilder {
  typedef CBRef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_global_id(uint32_t global_id) {
    fbb_.AddElement<uint32_t>(CBRef::VT_GLOBAL_ID, global_id, 0);
  }
  void add_tensor_ref(::flatbuffers::Offset<tt::target::TensorRef> tensor_ref) {
    fbb_.AddOffset(CBRef::VT_TENSOR_REF, tensor_ref);
  }
  void add_address(uint64_t address) {
    fbb_.AddElement<uint64_t>(CBRef::VT_ADDRESS, address, 0);
  }
  void add_desc(::flatbuffers::Offset<tt::target::CBDesc> desc) {
    fbb_.AddOffset(CBRef::VT_DESC, desc);
  }
  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 global_id = 0,
    ::flatbuffers::Offset<tt::target::TensorRef> tensor_ref = 0,
    uint64_t address = 0,
    ::flatbuffers::Offset<tt::target::CBDesc> desc = 0) {
  CBRefBuilder builder_(_fbb);
  builder_.add_address(address);
  builder_.add_desc(desc);
  builder_.add_tensor_ref(tensor_ref);
  builder_.add_global_id(global_id);
  return builder_.Finish();
}
 
struct CBRef::Traits {
  using type = CBRef;
  static auto constexpr Create = CreateCBRef;
};
 
struct ChipDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ChipDescBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ARCH = 4,
    VT_GRID_SIZE = 6,
    VT_L1_SIZE = 8,
    VT_NUM_DRAM_CHANNELS = 10,
    VT_DRAM_CHANNEL_SIZE = 12,
    VT_NOC_L1_ADDRESS_ALIGN_BYTES = 14,
    VT_PCIE_ADDRESS_ALIGN_BYTES = 16,
    VT_NOC_DRAM_ADDRESS_ALIGN_BYTES = 18,
    VT_L1_UNRESERVED_BASE = 20,
    VT_ERISC_L1_UNRESERVED_BASE = 22,
    VT_DRAM_UNRESERVED_BASE = 24,
    VT_DRAM_UNRESERVED_END = 26,
    VT_PHYSICAL_CORES = 28,
    VT_SUPPORTED_DATA_TYPES = 30,
    VT_SUPPORTED_TILE_SIZES = 32
  };
  tt::target::Arch arch() const {
    return static_cast<tt::target::Arch>(GetField<uint32_t>(VT_ARCH, 0));
  }
  const tt::target::Dim2d *grid_size() const {
    return GetStruct<const tt::target::Dim2d *>(VT_GRID_SIZE);
  }
  uint64_t l1_size() const {
    return GetField<uint64_t>(VT_L1_SIZE, 0);
  }
  uint32_t num_dram_channels() const {
    return GetField<uint32_t>(VT_NUM_DRAM_CHANNELS, 0);
  }
  uint64_t dram_channel_size() const {
    return GetField<uint64_t>(VT_DRAM_CHANNEL_SIZE, 0);
  }
  uint32_t noc_l1_address_align_bytes() const {
    return GetField<uint32_t>(VT_NOC_L1_ADDRESS_ALIGN_BYTES, 0);
  }
  uint32_t pcie_address_align_bytes() const {
    return GetField<uint32_t>(VT_PCIE_ADDRESS_ALIGN_BYTES, 0);
  }
  uint32_t noc_dram_address_align_bytes() const {
    return GetField<uint32_t>(VT_NOC_DRAM_ADDRESS_ALIGN_BYTES, 0);
  }
  uint32_t l1_unreserved_base() const {
    return GetField<uint32_t>(VT_L1_UNRESERVED_BASE, 0);
  }
  uint32_t erisc_l1_unreserved_base() const {
    return GetField<uint32_t>(VT_ERISC_L1_UNRESERVED_BASE, 0);
  }
  uint32_t dram_unreserved_base() const {
    return GetField<uint32_t>(VT_DRAM_UNRESERVED_BASE, 0);
  }
  uint32_t dram_unreserved_end() const {
    return GetField<uint32_t>(VT_DRAM_UNRESERVED_END, 0);
  }
  const tt::target::ChipPhysicalCores *physical_cores() const {
    return GetPointer<const tt::target::ChipPhysicalCores *>(VT_PHYSICAL_CORES);
  }
  const ::flatbuffers::Vector<tt::target::DataType> *supported_data_types() const {
    return GetPointer<const ::flatbuffers::Vector<tt::target::DataType> *>(VT_SUPPORTED_DATA_TYPES);
  }
  const ::flatbuffers::Vector<const tt::target::Dim2d *> *supported_tile_sizes() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::Dim2d *> *>(VT_SUPPORTED_TILE_SIZES);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_ARCH, 4) &&
           VerifyField<tt::target::Dim2d>(verifier, VT_GRID_SIZE, 4) &&
           VerifyField<uint64_t>(verifier, VT_L1_SIZE, 8) &&
           VerifyField<uint32_t>(verifier, VT_NUM_DRAM_CHANNELS, 4) &&
           VerifyField<uint64_t>(verifier, VT_DRAM_CHANNEL_SIZE, 8) &&
           VerifyField<uint32_t>(verifier, VT_NOC_L1_ADDRESS_ALIGN_BYTES, 4) &&
           VerifyField<uint32_t>(verifier, VT_PCIE_ADDRESS_ALIGN_BYTES, 4) &&
           VerifyField<uint32_t>(verifier, VT_NOC_DRAM_ADDRESS_ALIGN_BYTES, 4) &&
           VerifyField<uint32_t>(verifier, VT_L1_UNRESERVED_BASE, 4) &&
           VerifyField<uint32_t>(verifier, VT_ERISC_L1_UNRESERVED_BASE, 4) &&
           VerifyField<uint32_t>(verifier, VT_DRAM_UNRESERVED_BASE, 4) &&
           VerifyField<uint32_t>(verifier, VT_DRAM_UNRESERVED_END, 4) &&
           VerifyOffset(verifier, VT_PHYSICAL_CORES) &&
           verifier.VerifyTable(physical_cores()) &&
           VerifyOffset(verifier, VT_SUPPORTED_DATA_TYPES) &&
           verifier.VerifyVector(supported_data_types()) &&
           VerifyOffset(verifier, VT_SUPPORTED_TILE_SIZES) &&
           verifier.VerifyVector(supported_tile_sizes()) &&
           verifier.EndTable();
  }
};
 
struct ChipDescBuilder {
  typedef ChipDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_arch(tt::target::Arch arch) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_ARCH, static_cast<uint32_t>(arch), 0);
  }
  void add_grid_size(const tt::target::Dim2d *grid_size) {
    fbb_.AddStruct(ChipDesc::VT_GRID_SIZE, grid_size);
  }
  void add_l1_size(uint64_t l1_size) {
    fbb_.AddElement<uint64_t>(ChipDesc::VT_L1_SIZE, l1_size, 0);
  }
  void add_num_dram_channels(uint32_t num_dram_channels) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_NUM_DRAM_CHANNELS, num_dram_channels, 0);
  }
  void add_dram_channel_size(uint64_t dram_channel_size) {
    fbb_.AddElement<uint64_t>(ChipDesc::VT_DRAM_CHANNEL_SIZE, dram_channel_size, 0);
  }
  void add_noc_l1_address_align_bytes(uint32_t noc_l1_address_align_bytes) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_NOC_L1_ADDRESS_ALIGN_BYTES, noc_l1_address_align_bytes, 0);
  }
  void add_pcie_address_align_bytes(uint32_t pcie_address_align_bytes) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_PCIE_ADDRESS_ALIGN_BYTES, pcie_address_align_bytes, 0);
  }
  void add_noc_dram_address_align_bytes(uint32_t noc_dram_address_align_bytes) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_NOC_DRAM_ADDRESS_ALIGN_BYTES, noc_dram_address_align_bytes, 0);
  }
  void add_l1_unreserved_base(uint32_t l1_unreserved_base) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_L1_UNRESERVED_BASE, l1_unreserved_base, 0);
  }
  void add_erisc_l1_unreserved_base(uint32_t erisc_l1_unreserved_base) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_ERISC_L1_UNRESERVED_BASE, erisc_l1_unreserved_base, 0);
  }
  void add_dram_unreserved_base(uint32_t dram_unreserved_base) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_DRAM_UNRESERVED_BASE, dram_unreserved_base, 0);
  }
  void add_dram_unreserved_end(uint32_t dram_unreserved_end) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_DRAM_UNRESERVED_END, dram_unreserved_end, 0);
  }
  void add_physical_cores(::flatbuffers::Offset<tt::target::ChipPhysicalCores> physical_cores) {
    fbb_.AddOffset(ChipDesc::VT_PHYSICAL_CORES, physical_cores);
  }
  void add_supported_data_types(::flatbuffers::Offset<::flatbuffers::Vector<tt::target::DataType>> supported_data_types) {
    fbb_.AddOffset(ChipDesc::VT_SUPPORTED_DATA_TYPES, supported_data_types);
  }
  void add_supported_tile_sizes(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> supported_tile_sizes) {
    fbb_.AddOffset(ChipDesc::VT_SUPPORTED_TILE_SIZES, supported_tile_sizes);
  }
  explicit ChipDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ChipDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ChipDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ChipDesc> CreateChipDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::Arch arch = tt::target::Arch::Grayskull,
    const tt::target::Dim2d *grid_size = nullptr,
    uint64_t l1_size = 0,
    uint32_t num_dram_channels = 0,
    uint64_t dram_channel_size = 0,
    uint32_t noc_l1_address_align_bytes = 0,
    uint32_t pcie_address_align_bytes = 0,
    uint32_t noc_dram_address_align_bytes = 0,
    uint32_t l1_unreserved_base = 0,
    uint32_t erisc_l1_unreserved_base = 0,
    uint32_t dram_unreserved_base = 0,
    uint32_t dram_unreserved_end = 0,
    ::flatbuffers::Offset<tt::target::ChipPhysicalCores> physical_cores = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<tt::target::DataType>> supported_data_types = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> supported_tile_sizes = 0) {
  ChipDescBuilder builder_(_fbb);
  builder_.add_dram_channel_size(dram_channel_size);
  builder_.add_l1_size(l1_size);
  builder_.add_supported_tile_sizes(supported_tile_sizes);
  builder_.add_supported_data_types(supported_data_types);
  builder_.add_physical_cores(physical_cores);
  builder_.add_dram_unreserved_end(dram_unreserved_end);
  builder_.add_dram_unreserved_base(dram_unreserved_base);
  builder_.add_erisc_l1_unreserved_base(erisc_l1_unreserved_base);
  builder_.add_l1_unreserved_base(l1_unreserved_base);
  builder_.add_noc_dram_address_align_bytes(noc_dram_address_align_bytes);
  builder_.add_pcie_address_align_bytes(pcie_address_align_bytes);
  builder_.add_noc_l1_address_align_bytes(noc_l1_address_align_bytes);
  builder_.add_num_dram_channels(num_dram_channels);
  builder_.add_grid_size(grid_size);
  builder_.add_arch(arch);
  return builder_.Finish();
}
 
struct ChipDesc::Traits {
  using type = ChipDesc;
  static auto constexpr Create = CreateChipDesc;
};
 
inline ::flatbuffers::Offset<ChipDesc> CreateChipDescDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::Arch arch = tt::target::Arch::Grayskull,
    const tt::target::Dim2d *grid_size = nullptr,
    uint64_t l1_size = 0,
    uint32_t num_dram_channels = 0,
    uint64_t dram_channel_size = 0,
    uint32_t noc_l1_address_align_bytes = 0,
    uint32_t pcie_address_align_bytes = 0,
    uint32_t noc_dram_address_align_bytes = 0,
    uint32_t l1_unreserved_base = 0,
    uint32_t erisc_l1_unreserved_base = 0,
    uint32_t dram_unreserved_base = 0,
    uint32_t dram_unreserved_end = 0,
    ::flatbuffers::Offset<tt::target::ChipPhysicalCores> physical_cores = 0,
    const std::vector<tt::target::DataType> *supported_data_types = nullptr,
    const std::vector<tt::target::Dim2d> *supported_tile_sizes = nullptr) {
  auto supported_data_types__ = supported_data_types ? _fbb.CreateVector<tt::target::DataType>(*supported_data_types) : 0;
  auto supported_tile_sizes__ = supported_tile_sizes ? _fbb.CreateVectorOfStructs<tt::target::Dim2d>(*supported_tile_sizes) : 0;
  return tt::target::CreateChipDesc(
      _fbb,
      arch,
      grid_size,
      l1_size,
      num_dram_channels,
      dram_channel_size,
      noc_l1_address_align_bytes,
      pcie_address_align_bytes,
      noc_dram_address_align_bytes,
      l1_unreserved_base,
      erisc_l1_unreserved_base,
      dram_unreserved_base,
      dram_unreserved_end,
      physical_cores,
      supported_data_types__,
      supported_tile_sizes__);
}
 
struct ChipPhysicalCores FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ChipPhysicalCoresBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_WORKER = 4,
    VT_DRAM = 6,
    VT_ETH = 8,
    VT_ETH_INACTIVE = 10
  };
  const ::flatbuffers::Vector<const tt::target::Dim2d *> *worker() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::Dim2d *> *>(VT_WORKER);
  }
  const ::flatbuffers::Vector<const tt::target::Dim2d *> *dram() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::Dim2d *> *>(VT_DRAM);
  }
  const ::flatbuffers::Vector<const tt::target::Dim2d *> *eth() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::Dim2d *> *>(VT_ETH);
  }
  const ::flatbuffers::Vector<const tt::target::Dim2d *> *eth_inactive() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::Dim2d *> *>(VT_ETH_INACTIVE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_WORKER) &&
           verifier.VerifyVector(worker()) &&
           VerifyOffset(verifier, VT_DRAM) &&
           verifier.VerifyVector(dram()) &&
           VerifyOffset(verifier, VT_ETH) &&
           verifier.VerifyVector(eth()) &&
           VerifyOffset(verifier, VT_ETH_INACTIVE) &&
           verifier.VerifyVector(eth_inactive()) &&
           verifier.EndTable();
  }
};
 
struct ChipPhysicalCoresBuilder {
  typedef ChipPhysicalCores Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_worker(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> worker) {
    fbb_.AddOffset(ChipPhysicalCores::VT_WORKER, worker);
  }
  void add_dram(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> dram) {
    fbb_.AddOffset(ChipPhysicalCores::VT_DRAM, dram);
  }
  void add_eth(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> eth) {
    fbb_.AddOffset(ChipPhysicalCores::VT_ETH, eth);
  }
  void add_eth_inactive(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> eth_inactive) {
    fbb_.AddOffset(ChipPhysicalCores::VT_ETH_INACTIVE, eth_inactive);
  }
  explicit ChipPhysicalCoresBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ChipPhysicalCores> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ChipPhysicalCores>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ChipPhysicalCores> CreateChipPhysicalCores(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> worker = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> dram = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> eth = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::Dim2d *>> eth_inactive = 0) {
  ChipPhysicalCoresBuilder builder_(_fbb);
  builder_.add_eth_inactive(eth_inactive);
  builder_.add_eth(eth);
  builder_.add_dram(dram);
  builder_.add_worker(worker);
  return builder_.Finish();
}
 
struct ChipPhysicalCores::Traits {
  using type = ChipPhysicalCores;
  static auto constexpr Create = CreateChipPhysicalCores;
};
 
inline ::flatbuffers::Offset<ChipPhysicalCores> CreateChipPhysicalCoresDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<tt::target::Dim2d> *worker = nullptr,
    const std::vector<tt::target::Dim2d> *dram = nullptr,
    const std::vector<tt::target::Dim2d> *eth = nullptr,
    const std::vector<tt::target::Dim2d> *eth_inactive = nullptr) {
  auto worker__ = worker ? _fbb.CreateVectorOfStructs<tt::target::Dim2d>(*worker) : 0;
  auto dram__ = dram ? _fbb.CreateVectorOfStructs<tt::target::Dim2d>(*dram) : 0;
  auto eth__ = eth ? _fbb.CreateVectorOfStructs<tt::target::Dim2d>(*eth) : 0;
  auto eth_inactive__ = eth_inactive ? _fbb.CreateVectorOfStructs<tt::target::Dim2d>(*eth_inactive) : 0;
  return tt::target::CreateChipPhysicalCores(
      _fbb,
      worker__,
      dram__,
      eth__,
      eth_inactive__);
}
 
struct SystemDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SystemDescBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CHIP_DESCS = 4,
    VT_CHIP_DESC_INDICES = 6,
    VT_CHIP_CAPABILITIES = 8,
    VT_CHIP_COORDS = 10,
    VT_CHIP_CHANNELS = 12
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ChipDesc>> *chip_descs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ChipDesc>> *>(VT_CHIP_DESCS);
  }
  const ::flatbuffers::Vector<uint32_t> *chip_desc_indices() const {
    return GetPointer<const ::flatbuffers::Vector<uint32_t> *>(VT_CHIP_DESC_INDICES);
  }
  const ::flatbuffers::Vector<tt::target::ChipCapability> *chip_capabilities() const {
    return GetPointer<const ::flatbuffers::Vector<tt::target::ChipCapability> *>(VT_CHIP_CAPABILITIES);
  }
  const ::flatbuffers::Vector<const tt::target::ChipCoord *> *chip_coords() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::ChipCoord *> *>(VT_CHIP_COORDS);
  }
  const ::flatbuffers::Vector<const tt::target::ChipChannel *> *chip_channels() const {
    return GetPointer<const ::flatbuffers::Vector<const tt::target::ChipChannel *> *>(VT_CHIP_CHANNELS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_CHIP_DESCS) &&
           verifier.VerifyVector(chip_descs()) &&
           verifier.VerifyVectorOfTables(chip_descs()) &&
           VerifyOffset(verifier, VT_CHIP_DESC_INDICES) &&
           verifier.VerifyVector(chip_desc_indices()) &&
           VerifyOffset(verifier, VT_CHIP_CAPABILITIES) &&
           verifier.VerifyVector(chip_capabilities()) &&
           VerifyOffset(verifier, VT_CHIP_COORDS) &&
           verifier.VerifyVector(chip_coords()) &&
           VerifyOffset(verifier, VT_CHIP_CHANNELS) &&
           verifier.VerifyVector(chip_channels()) &&
           verifier.EndTable();
  }
};
 
struct SystemDescBuilder {
  typedef SystemDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_chip_descs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ChipDesc>>> chip_descs) {
    fbb_.AddOffset(SystemDesc::VT_CHIP_DESCS, chip_descs);
  }
  void add_chip_desc_indices(::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> chip_desc_indices) {
    fbb_.AddOffset(SystemDesc::VT_CHIP_DESC_INDICES, chip_desc_indices);
  }
  void add_chip_capabilities(::flatbuffers::Offset<::flatbuffers::Vector<tt::target::ChipCapability>> chip_capabilities) {
    fbb_.AddOffset(SystemDesc::VT_CHIP_CAPABILITIES, chip_capabilities);
  }
  void add_chip_coords(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::ChipCoord *>> chip_coords) {
    fbb_.AddOffset(SystemDesc::VT_CHIP_COORDS, chip_coords);
  }
  void add_chip_channels(::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::ChipChannel *>> chip_channels) {
    fbb_.AddOffset(SystemDesc::VT_CHIP_CHANNELS, chip_channels);
  }
  explicit SystemDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<SystemDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<SystemDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<SystemDesc> CreateSystemDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ChipDesc>>> chip_descs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<uint32_t>> chip_desc_indices = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<tt::target::ChipCapability>> chip_capabilities = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::ChipCoord *>> chip_coords = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<const tt::target::ChipChannel *>> chip_channels = 0) {
  SystemDescBuilder builder_(_fbb);
  builder_.add_chip_channels(chip_channels);
  builder_.add_chip_coords(chip_coords);
  builder_.add_chip_capabilities(chip_capabilities);
  builder_.add_chip_desc_indices(chip_desc_indices);
  builder_.add_chip_descs(chip_descs);
  return builder_.Finish();
}
 
struct SystemDesc::Traits {
  using type = SystemDesc;
  static auto constexpr Create = CreateSystemDesc;
};
 
inline ::flatbuffers::Offset<SystemDesc> CreateSystemDescDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<::flatbuffers::Offset<tt::target::ChipDesc>> *chip_descs = nullptr,
    const std::vector<uint32_t> *chip_desc_indices = nullptr,
    const std::vector<tt::target::ChipCapability> *chip_capabilities = nullptr,
    const std::vector<tt::target::ChipCoord> *chip_coords = nullptr,
    const std::vector<tt::target::ChipChannel> *chip_channels = nullptr) {
  auto chip_descs__ = chip_descs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::ChipDesc>>(*chip_descs) : 0;
  auto chip_desc_indices__ = chip_desc_indices ? _fbb.CreateVector<uint32_t>(*chip_desc_indices) : 0;
  auto chip_capabilities__ = chip_capabilities ? _fbb.CreateVector<tt::target::ChipCapability>(*chip_capabilities) : 0;
  auto chip_coords__ = chip_coords ? _fbb.CreateVectorOfStructs<tt::target::ChipCoord>(*chip_coords) : 0;
  auto chip_channels__ = chip_channels ? _fbb.CreateVectorOfStructs<tt::target::ChipChannel>(*chip_channels) : 0;
  return tt::target::CreateSystemDesc(
      _fbb,
      chip_descs__,
      chip_desc_indices__,
      chip_capabilities__,
      chip_coords__,
      chip_channels__);
}
 
struct DeviceRef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DeviceRefBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_GLOBAL_ID = 4
  };
  uint32_t global_id() const {
    return GetField<uint32_t>(VT_GLOBAL_ID, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_GLOBAL_ID, 4) &&
           verifier.EndTable();
  }
};
 
struct DeviceRefBuilder {
  typedef DeviceRef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_global_id(uint32_t global_id) {
    fbb_.AddElement<uint32_t>(DeviceRef::VT_GLOBAL_ID, global_id, 0);
  }
  explicit DeviceRefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DeviceRef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DeviceRef>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<DeviceRef> CreateDeviceRef(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t global_id = 0) {
  DeviceRefBuilder builder_(_fbb);
  builder_.add_global_id(global_id);
  return builder_.Finish();
}
 
struct DeviceRef::Traits {
  using type = DeviceRef;
  static auto constexpr Create = CreateDeviceRef;
};
 
struct EventRef FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EventRefBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_GLOBAL_ID = 4
  };
  uint32_t global_id() const {
    return GetField<uint32_t>(VT_GLOBAL_ID, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_GLOBAL_ID, 4) &&
           verifier.EndTable();
  }
};
 
struct EventRefBuilder {
  typedef EventRef Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_global_id(uint32_t global_id) {
    fbb_.AddElement<uint32_t>(EventRef::VT_GLOBAL_ID, global_id, 0);
  }
  explicit EventRefBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EventRef> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EventRef>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EventRef> CreateEventRef(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t global_id = 0) {
  EventRefBuilder builder_(_fbb);
  builder_.add_global_id(global_id);
  return builder_.Finish();
}
 
struct EventRef::Traits {
  using type = EventRef;
  static auto constexpr Create = CreateEventRef;
};
 
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_TYPES_TT_TARGET_H_