embedding_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_EMBEDDING_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_EMBEDDING_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 EmbeddingOp;
struct EmbeddingOpBuilder;
 
struct EmbeddingBackwardOp;
struct EmbeddingBackwardOpBuilder;
 
struct EmbeddingOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EmbeddingOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EmbeddingOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUT = 4,
    VT_WEIGHT = 6,
    VT_OUT = 8
  };
  const tt::target::ttnn::TensorRef *input() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_INPUT);
  }
  const tt::target::ttnn::TensorRef *weight() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_WEIGHT);
  }
  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_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyOffset(verifier, VT_WEIGHT) &&
           verifier.VerifyTable(weight()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct EmbeddingOpBuilder {
  typedef EmbeddingOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_input(::flatbuffers::Offset<tt::target::ttnn::TensorRef> input) {
    fbb_.AddOffset(EmbeddingOp::VT_INPUT, input);
  }
  void add_weight(::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight) {
    fbb_.AddOffset(EmbeddingOp::VT_WEIGHT, weight);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(EmbeddingOp::VT_OUT, out);
  }
  explicit EmbeddingOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EmbeddingOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EmbeddingOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EmbeddingOp> CreateEmbeddingOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  EmbeddingOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_weight(weight);
  builder_.add_input(input);
  return builder_.Finish();
}
 
struct EmbeddingOp::Traits {
  using type = EmbeddingOp;
  static auto constexpr Create = CreateEmbeddingOp;
};
 
struct EmbeddingBackwardOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef EmbeddingBackwardOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.EmbeddingBackwardOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_INPUT = 4,
    VT_WEIGHT = 6,
    VT_IN_GRAD = 8,
    VT_DTYPE = 10,
    VT_MEMCFG = 12,
    VT_OUT = 14
  };
  const tt::target::ttnn::TensorRef *input() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_INPUT);
  }
  const tt::target::ttnn::TensorRef *weight() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_WEIGHT);
  }
  const tt::target::ttnn::TensorRef *in_grad() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN_GRAD);
  }
  ::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::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_INPUT) &&
           verifier.VerifyTable(input()) &&
           VerifyOffset(verifier, VT_WEIGHT) &&
           verifier.VerifyTable(weight()) &&
           VerifyOffset(verifier, VT_IN_GRAD) &&
           verifier.VerifyTable(in_grad()) &&
           VerifyField<uint16_t>(verifier, VT_DTYPE, 2) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
struct EmbeddingBackwardOpBuilder {
  typedef EmbeddingBackwardOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_input(::flatbuffers::Offset<tt::target::ttnn::TensorRef> input) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_INPUT, input);
  }
  void add_weight(::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_WEIGHT, weight);
  }
  void add_in_grad(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in_grad) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_IN_GRAD, in_grad);
  }
  void add_dtype(tt::target::DataType dtype) {
    fbb_.AddElement<uint16_t>(EmbeddingBackwardOp::VT_DTYPE, static_cast<uint16_t>(dtype));
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_MEMCFG, memcfg);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(EmbeddingBackwardOp::VT_OUT, out);
  }
  explicit EmbeddingBackwardOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<EmbeddingBackwardOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<EmbeddingBackwardOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<EmbeddingBackwardOp> CreateEmbeddingBackwardOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> input = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> weight = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in_grad = 0,
    ::flatbuffers::Optional<tt::target::DataType> dtype = ::flatbuffers::nullopt,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  EmbeddingBackwardOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memcfg(memcfg);
  builder_.add_in_grad(in_grad);
  builder_.add_weight(weight);
  builder_.add_input(input);
  if(dtype) { builder_.add_dtype(*dtype); }
  return builder_.Finish();
}
 
struct EmbeddingBackwardOp::Traits {
  using type = EmbeddingBackwardOp;
  static auto constexpr Create = CreateEmbeddingBackwardOp;
};
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_EMBEDDING_TT_TARGET_TTNN_H_