layout_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_LAYOUT_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_LAYOUT_TT_TARGET_TTNN_H_
 
#include "flatbuffers/flatbuffers.h"
 
// Ensure the included flatbuffers.h is the same version as when this file was
// generated, otherwise it may not be compatible.
static_assert(FLATBUFFERS_VERSION_MAJOR == 24 &&
              FLATBUFFERS_VERSION_MINOR == 3 &&
              FLATBUFFERS_VERSION_REVISION == 25,
             "Non-compatible flatbuffers version included");
 
#include "ttmlir/Target/Common/types_generated.h"
#include "ttmlir/Target/TTNN/types_generated.h"
 
namespace tt {
namespace target {
namespace ttnn {
 
struct FromDeviceOp;
struct FromDeviceOpBuilder;
 
struct ToDeviceOp;
struct ToDeviceOpBuilder;
 
struct ToDTypeOp;
struct ToDTypeOpBuilder;
 
struct ToLayoutOp;
struct ToLayoutOpBuilder;
 
struct ToMemoryConfigOp;
struct ToMemoryConfigOpBuilder;
 
struct TypecastOp;
struct TypecastOpBuilder;
 
struct FromDeviceOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef FromDeviceOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.FromDeviceOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct FromDeviceOpBuilder {
  typedef FromDeviceOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(FromDeviceOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(FromDeviceOp::VT_OUT, out);
  }
  explicit FromDeviceOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<FromDeviceOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<FromDeviceOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<FromDeviceOp> CreateFromDeviceOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  FromDeviceOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct FromDeviceOp::Traits {
  using type = FromDeviceOp;
  static auto constexpr Create = CreateFromDeviceOp;
};
 
struct ToDeviceOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ToDeviceOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ToDeviceOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_DEVICE = 6,
    VT_MEMCFG = 8,
    VT_OUT = 10
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct ToDeviceOpBuilder {
  typedef ToDeviceOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(ToDeviceOp::VT_IN, in);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ToDeviceOp::VT_DEVICE, device);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(ToDeviceOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ToDeviceOp::VT_OUT, out);
  }
  explicit ToDeviceOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ToDeviceOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ToDeviceOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ToDeviceOp> CreateToDeviceOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  ToDeviceOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_device(device);
  builder_.add_in(in);
  return builder_.Finish();
}
 
struct ToDeviceOp::Traits {
  using type = ToDeviceOp;
  static auto constexpr Create = CreateToDeviceOp;
};
 
struct ToDTypeOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ToDTypeOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ToDTypeOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_DTYPE = 6,
    VT_OUT = 8
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  tt::target::DataType dtype() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DTYPE, 0));
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct ToDTypeOpBuilder {
  typedef ToDTypeOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(ToDTypeOp::VT_IN, in);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(ToDTypeOp::VT_DTYPE, static_cast<uint16_t>(dtype), 0);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ToDTypeOp::VT_OUT, out);
  }
  explicit ToDTypeOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ToDTypeOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ToDTypeOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ToDTypeOp> CreateToDTypeOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  ToDTypeOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_dtype(dtype);
  return builder_.Finish();
}
 
struct ToDTypeOp::Traits {
  using type = ToDTypeOp;
  static auto constexpr Create = CreateToDTypeOp;
};
 
struct ToLayoutOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ToLayoutOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ToLayoutOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_LAYOUT = 6,
    VT_DTYPE = 8,
    VT_MEMCFG = 10,
    VT_DEVICE = 12,
    VT_OUT = 14
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  tt::target::TensorLayout layout() const {
    return static_cast<tt::target::TensorLayout>(GetField<uint16_t>(VT_LAYOUT, 0));
  }
  ::flatbuffers::Optional<tt::target::DataType> dtype() const {
    return GetOptional<uint16_t, tt::target::DataType>(VT_DTYPE);
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyField<uint16_t>(verifier, VT_LAYOUT, 2) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct ToLayoutOpBuilder {
  typedef ToLayoutOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(ToLayoutOp::VT_IN, in);
  }
  void add_layout(tt::target::TensorLayout layout) {
    fbb_.AddElement<uint16_t>(ToLayoutOp::VT_LAYOUT, static_cast<uint16_t>(layout), 0);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(ToLayoutOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(ToLayoutOp::VT_MEMCFG, memcfg);
  }
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(ToLayoutOp::VT_DEVICE, device);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ToLayoutOp::VT_OUT, out);
  }
  explicit ToLayoutOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ToLayoutOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ToLayoutOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ToLayoutOp> CreateToLayoutOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    tt::target::TensorLayout layout = tt::target::TensorLayout::RowMajor,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  ToLayoutOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_device(device);
  builder_.add_memcfg(memcfg);
  builder_.add_in(in);
  if(dtype) { builder_.add_dtype(*dtype); }
  builder_.add_layout(layout);
  return builder_.Finish();
}
 
struct ToLayoutOp::Traits {
  using type = ToLayoutOp;
  static auto constexpr Create = CreateToLayoutOp;
};
 
struct ToMemoryConfigOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ToMemoryConfigOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ToMemoryConfigOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN0 = 4,
    VT_MEMCFG = 6,
    VT_OUT = 8
  };
  const tt::target::ttnn::TensorRef *in0() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN0);
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN0) &&
           verifier.VerifyTable(in0()) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct ToMemoryConfigOpBuilder {
  typedef ToMemoryConfigOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in0(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in0) {
    fbb_.AddOffset(ToMemoryConfigOp::VT_IN0, in0);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(ToMemoryConfigOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ToMemoryConfigOp::VT_OUT, out);
  }
  explicit ToMemoryConfigOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ToMemoryConfigOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ToMemoryConfigOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ToMemoryConfigOp> CreateToMemoryConfigOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in0 = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  ToMemoryConfigOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_in0(in0);
  return builder_.Finish();
}
 
struct ToMemoryConfigOp::Traits {
  using type = ToMemoryConfigOp;
  static auto constexpr Create = CreateToMemoryConfigOp;
};
 
struct TypecastOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TypecastOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.TypecastOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_DTYPE = 6,
    VT_OUT = 8
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  tt::target::DataType dtype() const {
    return static_cast<tt::target::DataType>(GetField<uint16_t>(VT_DTYPE, 0));
  }
  const tt::target::ttnn::TensorRef *out() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_OUT);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct TypecastOpBuilder {
  typedef TypecastOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(TypecastOp::VT_IN, in);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(TypecastOp::VT_DTYPE, static_cast<uint16_t>(dtype), 0);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(TypecastOp::VT_OUT, out);
  }
  explicit TypecastOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TypecastOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TypecastOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TypecastOp> CreateTypecastOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    tt::target::DataType dtype = tt::target::DataType::Float32,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  TypecastOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_dtype(dtype);
  return builder_.Finish();
}
 
struct TypecastOp::Traits {
  using type = TypecastOp;
  static auto constexpr Create = CreateTypecastOp;
};
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_LAYOUT_TT_TARGET_TTNN_H_