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 ShardSpec;
struct ShardSpecBuilder;
 
struct MemoryConfigDesc;
struct MemoryConfigDescBuilder;
 
struct ReplicateTensor;
struct ReplicateTensorBuilder;
 
struct ShardTensor;
struct ShardTensorBuilder;
 
struct ShardTensor2D;
struct ShardTensor2DBuilder;
 
struct AllGatherTensor;
struct AllGatherTensorBuilder;
 
struct DistributionStrategy;
struct DistributionStrategyBuilder;
 
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 CPUDesc;
struct CPUDescBuilder;
 
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 DistributedTensorConfig : uint8_t {
  NONE = 0,
  ReplicateTensor = 1,
  ShardTensor = 2,
  ShardTensor2D = 3,
  AllGatherTensor = 4,
  MIN = NONE,
  MAX = AllGatherTensor
};
 
inline const DistributedTensorConfig (&EnumValuesDistributedTensorConfig())[5] {
  static const DistributedTensorConfig values[] = {
    DistributedTensorConfig::NONE,
    DistributedTensorConfig::ReplicateTensor,
    DistributedTensorConfig::ShardTensor,
    DistributedTensorConfig::ShardTensor2D,
    DistributedTensorConfig::AllGatherTensor
  };
  return values;
}
 
inline const char * const *EnumNamesDistributedTensorConfig() {
  static const char * const names[6] = {
    "NONE",
    "ReplicateTensor",
    "ShardTensor",
    "ShardTensor2D",
    "AllGatherTensor",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameDistributedTensorConfig(DistributedTensorConfig e) {
  if (::flatbuffers::IsOutRange(e, DistributedTensorConfig::NONE, DistributedTensorConfig::AllGatherTensor)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesDistributedTensorConfig()[index];
}
 
template<typename T> struct DistributedTensorConfigTraits {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::NONE;
};
 
template<> struct DistributedTensorConfigTraits<tt::target::ReplicateTensor> {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::ReplicateTensor;
};
 
template<> struct DistributedTensorConfigTraits<tt::target::ShardTensor> {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::ShardTensor;
};
 
template<> struct DistributedTensorConfigTraits<tt::target::ShardTensor2D> {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::ShardTensor2D;
};
 
template<> struct DistributedTensorConfigTraits<tt::target::AllGatherTensor> {
  static const DistributedTensorConfig enum_value = DistributedTensorConfig::AllGatherTensor;
};
 
bool VerifyDistributedTensorConfig(::flatbuffers::Verifier &verifier, const void *obj, DistributedTensorConfig type);
bool VerifyDistributedTensorConfigVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<DistributedTensorConfig> *types);
 
enum class CPURole : uint8_t {
  Host = 0,
  Device = 1,
  MIN = Host,
  MAX = Device
};
 
inline const CPURole (&EnumValuesCPURole())[2] {
  static const CPURole values[] = {
    CPURole::Host,
    CPURole::Device
  };
  return values;
}
 
inline const char * const *EnumNamesCPURole() {
  static const char * const names[3] = {
    "Host",
    "Device",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameCPURole(CPURole e) {
  if (::flatbuffers::IsOutRange(e, CPURole::Host, CPURole::Device)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesCPURole()[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 ShardSpec FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShardSpecBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHARD_SHAPE = 4
  };
  const ::flatbuffers::Vector<int64_t> *shard_shape() const {
    return GetPointer<const ::flatbuffers::Vector<int64_t> *>(VT_SHARD_SHAPE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHARD_SHAPE) &&
           verifier.VerifyVector(shard_shape()) &&
           verifier.EndTable();
  }
};
 
struct ShardSpecBuilder {
  typedef ShardSpec Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shard_shape(::flatbuffers::Offset<::flatbuffers::Vector<int64_t>> shard_shape) {
    fbb_.AddOffset(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<int64_t>> shard_shape = 0) {
  ShardSpecBuilder builder_(_fbb);
  builder_.add_shard_shape(shard_shape);
  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<int64_t> *shard_shape = nullptr) {
  auto shard_shape__ = shard_shape ? _fbb.CreateVector<int64_t>(*shard_shape) : 0;
  return tt::target::CreateShardSpec(
      _fbb,
      shard_shape__);
}
 
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,
    VT_SHARD_SPEC = 8
  };
  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));
  }
  const tt::target::ShardSpec *shard_spec() const {
    return GetPointer<const tt::target::ShardSpec *>(VT_SHARD_SPEC);
  }
  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) &&
           VerifyOffset(verifier, VT_SHARD_SPEC) &&
           verifier.VerifyTable(shard_spec()) &&
           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);
  }
  void add_shard_spec(::flatbuffers::Offset<tt::target::ShardSpec> shard_spec) {
    fbb_.AddOffset(MemoryConfigDesc::VT_SHARD_SPEC, shard_spec);
  }
  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,
    ::flatbuffers::Offset<tt::target::ShardSpec> shard_spec = 0) {
  MemoryConfigDescBuilder builder_(_fbb);
  builder_.add_shard_spec(shard_spec);
  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 ReplicateTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReplicateTensorBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_REPLICATION_FACTOR = 4
  };
  uint32_t replication_factor() const {
    return GetField<uint32_t>(VT_REPLICATION_FACTOR, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_REPLICATION_FACTOR, 4) &&
           verifier.EndTable();
  }
};
 
struct ReplicateTensorBuilder {
  typedef ReplicateTensor Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_replication_factor(uint32_t replication_factor) {
    fbb_.AddElement<uint32_t>(ReplicateTensor::VT_REPLICATION_FACTOR, replication_factor, 0);
  }
  explicit ReplicateTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReplicateTensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReplicateTensor>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReplicateTensor> CreateReplicateTensor(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t replication_factor = 0) {
  ReplicateTensorBuilder builder_(_fbb);
  builder_.add_replication_factor(replication_factor);
  return builder_.Finish();
}
 
struct ReplicateTensor::Traits {
  using type = ReplicateTensor;
  static auto constexpr Create = CreateReplicateTensor;
};
 
struct ShardTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShardTensorBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHARD_DIM = 4
  };
  uint32_t shard_dim() const {
    return GetField<uint32_t>(VT_SHARD_DIM, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_SHARD_DIM, 4) &&
           verifier.EndTable();
  }
};
 
struct ShardTensorBuilder {
  typedef ShardTensor Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shard_dim(uint32_t shard_dim) {
    fbb_.AddElement<uint32_t>(ShardTensor::VT_SHARD_DIM, shard_dim, 0);
  }
  explicit ShardTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ShardTensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ShardTensor>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ShardTensor> CreateShardTensor(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    uint32_t shard_dim = 0) {
  ShardTensorBuilder builder_(_fbb);
  builder_.add_shard_dim(shard_dim);
  return builder_.Finish();
}
 
struct ShardTensor::Traits {
  using type = ShardTensor;
  static auto constexpr Create = CreateShardTensor;
};
 
struct ShardTensor2D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ShardTensor2DBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SHARD_MESH = 4
  };
  const tt::target::Dim2d *shard_mesh() const {
    return GetStruct<const tt::target::Dim2d *>(VT_SHARD_MESH);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<tt::target::Dim2d>(verifier, VT_SHARD_MESH, 4) &&
           verifier.EndTable();
  }
};
 
struct ShardTensor2DBuilder {
  typedef ShardTensor2D Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_shard_mesh(const tt::target::Dim2d *shard_mesh) {
    fbb_.AddStruct(ShardTensor2D::VT_SHARD_MESH, shard_mesh);
  }
  explicit ShardTensor2DBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ShardTensor2D> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ShardTensor2D>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ShardTensor2D> CreateShardTensor2D(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const tt::target::Dim2d *shard_mesh = nullptr) {
  ShardTensor2DBuilder builder_(_fbb);
  builder_.add_shard_mesh(shard_mesh);
  return builder_.Finish();
}
 
struct ShardTensor2D::Traits {
  using type = ShardTensor2D;
  static auto constexpr Create = CreateShardTensor2D;
};
 
struct AllGatherTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef AllGatherTensorBuilder Builder;
  struct Traits;
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           verifier.EndTable();
  }
};
 
struct AllGatherTensorBuilder {
  typedef AllGatherTensor Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  explicit AllGatherTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<AllGatherTensor> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<AllGatherTensor>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<AllGatherTensor> CreateAllGatherTensor(
    ::flatbuffers::FlatBufferBuilder &_fbb) {
  AllGatherTensorBuilder builder_(_fbb);
  return builder_.Finish();
}
 
struct AllGatherTensor::Traits {
  using type = AllGatherTensor;
  static auto constexpr Create = CreateAllGatherTensor;
};
 
struct DistributionStrategy FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef DistributionStrategyBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_STRATEGY_TYPE = 4,
    VT_STRATEGY = 6
  };
  tt::target::DistributedTensorConfig strategy_type() const {
    return static_cast<tt::target::DistributedTensorConfig>(GetField<uint8_t>(VT_STRATEGY_TYPE, 0));
  }
  const void *strategy() const {
    return GetPointer<const void *>(VT_STRATEGY);
  }
  template<typename T> const T *strategy_as() const;
  const tt::target::ReplicateTensor *strategy_as_ReplicateTensor() const {
    return strategy_type() == tt::target::DistributedTensorConfig::ReplicateTensor ? static_cast<const tt::target::ReplicateTensor *>(strategy()) : nullptr;
  }
  const tt::target::ShardTensor *strategy_as_ShardTensor() const {
    return strategy_type() == tt::target::DistributedTensorConfig::ShardTensor ? static_cast<const tt::target::ShardTensor *>(strategy()) : nullptr;
  }
  const tt::target::ShardTensor2D *strategy_as_ShardTensor2D() const {
    return strategy_type() == tt::target::DistributedTensorConfig::ShardTensor2D ? static_cast<const tt::target::ShardTensor2D *>(strategy()) : nullptr;
  }
  const tt::target::AllGatherTensor *strategy_as_AllGatherTensor() const {
    return strategy_type() == tt::target::DistributedTensorConfig::AllGatherTensor ? static_cast<const tt::target::AllGatherTensor *>(strategy()) : nullptr;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_STRATEGY_TYPE, 1) &&
           VerifyOffset(verifier, VT_STRATEGY) &&
           VerifyDistributedTensorConfig(verifier, strategy(), strategy_type()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ReplicateTensor *DistributionStrategy::strategy_as<tt::target::ReplicateTensor>() const {
  return strategy_as_ReplicateTensor();
}
 
template<> inline const tt::target::ShardTensor *DistributionStrategy::strategy_as<tt::target::ShardTensor>() const {
  return strategy_as_ShardTensor();
}
 
template<> inline const tt::target::ShardTensor2D *DistributionStrategy::strategy_as<tt::target::ShardTensor2D>() const {
  return strategy_as_ShardTensor2D();
}
 
template<> inline const tt::target::AllGatherTensor *DistributionStrategy::strategy_as<tt::target::AllGatherTensor>() const {
  return strategy_as_AllGatherTensor();
}
 
struct DistributionStrategyBuilder {
  typedef DistributionStrategy Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_strategy_type(tt::target::DistributedTensorConfig strategy_type) {
    fbb_.AddElement<uint8_t>(DistributionStrategy::VT_STRATEGY_TYPE, static_cast<uint8_t>(strategy_type), 0);
  }
  void add_strategy(::flatbuffers::Offset<void> strategy) {
    fbb_.AddOffset(DistributionStrategy::VT_STRATEGY, strategy);
  }
  explicit DistributionStrategyBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<DistributionStrategy> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<DistributionStrategy>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<DistributionStrategy> CreateDistributionStrategy(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::DistributedTensorConfig strategy_type = tt::target::DistributedTensorConfig::NONE,
    ::flatbuffers::Offset<void> strategy = 0) {
  DistributionStrategyBuilder builder_(_fbb);
  builder_.add_strategy(strategy);
  builder_.add_strategy_type(strategy_type);
  return builder_.Finish();
}
 
struct DistributionStrategy::Traits {
  using type = DistributionStrategy;
  static auto constexpr Create = CreateDistributionStrategy;
};
 
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,
    VT_STRATEGY = 12
  };
  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);
  }
  const tt::target::DistributionStrategy *strategy() const {
    return GetPointer<const tt::target::DistributionStrategy *>(VT_STRATEGY);
  }
  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()) &&
           VerifyOffset(verifier, VT_STRATEGY) &&
           verifier.VerifyTable(strategy()) &&
           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);
  }
  void add_strategy(::flatbuffers::Offset<tt::target::DistributionStrategy> strategy) {
    fbb_.AddOffset(LayoutDesc::VT_STRATEGY, strategy);
  }
  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,
    ::flatbuffers::Offset<tt::target::DistributionStrategy> strategy = 0) {
  LayoutDescBuilder builder_(_fbb);
  builder_.add_strategy(strategy);
  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,
    ::flatbuffers::Offset<tt::target::DistributionStrategy> strategy = 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,
      strategy);
}
 
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
  };
  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);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SHAPE) &&
           verifier.VerifyVector(shape()) &&
           VerifyOffset(verifier, VT_LAYOUT) &&
           verifier.VerifyTable(layout()) &&
           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);
  }
  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) {
  TensorDescBuilder builder_(_fbb);
  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) {
  auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
  return tt::target::CreateTensorDesc(
      _fbb,
      shape__,
      layout);
}
 
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,
    VT_NUM_CBS = 34
  };
  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);
  }
  uint32_t num_cbs() const {
    return GetField<uint32_t>(VT_NUM_CBS, 0);
  }
  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()) &&
           VerifyField<uint32_t>(verifier, VT_NUM_CBS, 4) &&
           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);
  }
  void add_num_cbs(uint32_t num_cbs) {
    fbb_.AddElement<uint32_t>(ChipDesc::VT_NUM_CBS, num_cbs, 0);
  }
  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,
    uint32_t num_cbs = 0) {
  ChipDescBuilder builder_(_fbb);
  builder_.add_dram_channel_size(dram_channel_size);
  builder_.add_l1_size(l1_size);
  builder_.add_num_cbs(num_cbs);
  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,
    uint32_t num_cbs = 0) {
  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__,
      num_cbs);
}
 
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 CPUDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef CPUDescBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_ROLE = 4,
    VT_TARGET_TRIPLE = 6
  };
  tt::target::CPURole role() const {
    return static_cast<tt::target::CPURole>(GetField<uint8_t>(VT_ROLE, 0));
  }
  const ::flatbuffers::String *target_triple() const {
    return GetPointer<const ::flatbuffers::String *>(VT_TARGET_TRIPLE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint8_t>(verifier, VT_ROLE, 1) &&
           VerifyOffset(verifier, VT_TARGET_TRIPLE) &&
           verifier.VerifyString(target_triple()) &&
           verifier.EndTable();
  }
};
 
struct CPUDescBuilder {
  typedef CPUDesc Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_role(tt::target::CPURole role) {
    fbb_.AddElement<uint8_t>(CPUDesc::VT_ROLE, static_cast<uint8_t>(role), 0);
  }
  void add_target_triple(::flatbuffers::Offset<::flatbuffers::String> target_triple) {
    fbb_.AddOffset(CPUDesc::VT_TARGET_TRIPLE, target_triple);
  }
  explicit CPUDescBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<CPUDesc> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<CPUDesc>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<CPUDesc> CreateCPUDesc(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::CPURole role = tt::target::CPURole::Host,
    ::flatbuffers::Offset<::flatbuffers::String> target_triple = 0) {
  CPUDescBuilder builder_(_fbb);
  builder_.add_target_triple(target_triple);
  builder_.add_role(role);
  return builder_.Finish();
}
 
struct CPUDesc::Traits {
  using type = CPUDesc;
  static auto constexpr Create = CreateCPUDesc;
};
 
inline ::flatbuffers::Offset<CPUDesc> CreateCPUDescDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::CPURole role = tt::target::CPURole::Host,
    const char *target_triple = nullptr) {
  auto target_triple__ = target_triple ? _fbb.CreateString(target_triple) : 0;
  return tt::target::CreateCPUDesc(
      _fbb,
      role,
      target_triple__);
}
 
struct SystemDesc FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef SystemDescBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_CPU_DESCS = 4,
    VT_CHIP_DESCS = 6,
    VT_CHIP_DESC_INDICES = 8,
    VT_CHIP_CAPABILITIES = 10,
    VT_CHIP_COORDS = 12,
    VT_CHIP_CHANNELS = 14
  };
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::CPUDesc>> *cpu_descs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::CPUDesc>> *>(VT_CPU_DESCS);
  }
  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_CPU_DESCS) &&
           verifier.VerifyVector(cpu_descs()) &&
           verifier.VerifyVectorOfTables(cpu_descs()) &&
           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_cpu_descs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::CPUDesc>>> cpu_descs) {
    fbb_.AddOffset(SystemDesc::VT_CPU_DESCS, cpu_descs);
  }
  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::CPUDesc>>> cpu_descs = 0,
    ::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);
  builder_.add_cpu_descs(cpu_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::CPUDesc>> *cpu_descs = nullptr,
    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 cpu_descs__ = cpu_descs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::CPUDesc>>(*cpu_descs) : 0;
  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,
      cpu_descs__,
      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;
};
 
inline bool VerifyDistributedTensorConfig(::flatbuffers::Verifier &verifier, const void *obj, DistributedTensorConfig type) {
  switch (type) {
    case DistributedTensorConfig::NONE: {
      return true;
    }
    case DistributedTensorConfig::ReplicateTensor: {
      auto ptr = reinterpret_cast<const tt::target::ReplicateTensor *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DistributedTensorConfig::ShardTensor: {
      auto ptr = reinterpret_cast<const tt::target::ShardTensor *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DistributedTensorConfig::ShardTensor2D: {
      auto ptr = reinterpret_cast<const tt::target::ShardTensor2D *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case DistributedTensorConfig::AllGatherTensor: {
      auto ptr = reinterpret_cast<const tt::target::AllGatherTensor *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyDistributedTensorConfigVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<DistributedTensorConfig> *types) {
  if (!values || !types) return !values && !types;
  if (values->size() != types->size()) return false;
  for (::flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
    if (!VerifyDistributedTensorConfig(
        verifier,  values->Get(i), types->GetEnum<DistributedTensorConfig>(i))) {
      return false;
    }
  }
  return true;
}
 
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_TYPES_TT_TARGET_H_