reduction_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_REDUCTION_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_REDUCTION_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/TTNN/types_generated.h"
 
namespace tt {
namespace target {
namespace ttnn {
 
struct ReductionOp;
struct ReductionOpBuilder;
 
struct ReductionArgMaxOp;
struct ReductionArgMaxOpBuilder;
 
struct ReductionProdOp;
struct ReductionProdOpBuilder;
 
enum class ReductionOpType : uint32_t {
  Sum = 0,
  Mean = 1,
  Max = 2,
  Min = 3,
  MIN = Sum,
  MAX = Min
};
 
inline const ReductionOpType (&EnumValuesReductionOpType())[4] {
  static const ReductionOpType values[] = {
    ReductionOpType::Sum,
    ReductionOpType::Mean,
    ReductionOpType::Max,
    ReductionOpType::Min
  };
  return values;
}
 
inline const char * const *EnumNamesReductionOpType() {
  static const char * const names[5] = {
    "Sum",
    "Mean",
    "Max",
    "Min",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameReductionOpType(ReductionOpType e) {
  if (::flatbuffers::IsOutRange(e, ReductionOpType::Sum, ReductionOpType::Min)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesReductionOpType()[index];
}
 
struct ReductionOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReductionOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ReductionOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_TYPE = 4,
    VT_IN = 6,
    VT_OUT = 8,
    VT_DIM_ARG = 10,
    VT_KEEP_DIM = 12
  };
  tt::target::ttnn::ReductionOpType type() const {
    return static_cast<tt::target::ttnn::ReductionOpType>(GetField<uint32_t>(VT_TYPE, 0));
  }
  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);
  }
  const ::flatbuffers::Vector<int32_t> *dim_arg() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_DIM_ARG);
  }
  bool keep_dim() const {
    return GetField<uint8_t>(VT_KEEP_DIM, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<uint32_t>(verifier, VT_TYPE, 4) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyOffset(verifier, VT_DIM_ARG) &&
           verifier.VerifyVector(dim_arg()) &&
           VerifyField<uint8_t>(verifier, VT_KEEP_DIM, 1) &&
           verifier.EndTable();
  }
};
 
struct ReductionOpBuilder {
  typedef ReductionOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_type(tt::target::ttnn::ReductionOpType type) {
    fbb_.AddElement<uint32_t>(ReductionOp::VT_TYPE, static_cast<uint32_t>(type), 0);
  }
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(ReductionOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ReductionOp::VT_OUT, out);
  }
  void add_dim_arg(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dim_arg) {
    fbb_.AddOffset(ReductionOp::VT_DIM_ARG, dim_arg);
  }
  void add_keep_dim(bool keep_dim) {
    fbb_.AddElement<uint8_t>(ReductionOp::VT_KEEP_DIM, static_cast<uint8_t>(keep_dim), 0);
  }
  explicit ReductionOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReductionOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReductionOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReductionOp> CreateReductionOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::ReductionOpType type = tt::target::ttnn::ReductionOpType::Sum,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dim_arg = 0,
    bool keep_dim = false) {
  ReductionOpBuilder builder_(_fbb);
  builder_.add_dim_arg(dim_arg);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_type(type);
  builder_.add_keep_dim(keep_dim);
  return builder_.Finish();
}
 
struct ReductionOp::Traits {
  using type = ReductionOp;
  static auto constexpr Create = CreateReductionOp;
};
 
inline ::flatbuffers::Offset<ReductionOp> CreateReductionOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    tt::target::ttnn::ReductionOpType type = tt::target::ttnn::ReductionOpType::Sum,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    const std::vector<int32_t> *dim_arg = nullptr,
    bool keep_dim = false) {
  auto dim_arg__ = dim_arg ? _fbb.CreateVector<int32_t>(*dim_arg) : 0;
  return tt::target::ttnn::CreateReductionOp(
      _fbb,
      type,
      in,
      out,
      dim_arg__,
      keep_dim);
}
 
struct ReductionArgMaxOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReductionArgMaxOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ReductionArgMaxOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_DIM = 8,
    VT_KEEP_DIM = 10,
    VT_USE_MULTICORE = 12,
    VT_MEMCFG = 14
  };
  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);
  }
  ::flatbuffers::Optional<int32_t> dim() const {
    return GetOptional<int32_t, int32_t>(VT_DIM);
  }
  bool keep_dim() const {
    return GetField<uint8_t>(VT_KEEP_DIM, 0) != 0;
  }
  bool use_multicore() const {
    return GetField<uint8_t>(VT_USE_MULTICORE, 0) != 0;
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<int32_t>(verifier, VT_DIM, 4) &&
           VerifyField<uint8_t>(verifier, VT_KEEP_DIM, 1) &&
           VerifyField<uint8_t>(verifier, VT_USE_MULTICORE, 1) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           verifier.EndTable();
  }
};
 
struct ReductionArgMaxOpBuilder {
  typedef ReductionArgMaxOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(ReductionArgMaxOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ReductionArgMaxOp::VT_OUT, out);
  }
  void add_dim(int32_t dim) {
    fbb_.AddElement<int32_t>(ReductionArgMaxOp::VT_DIM, dim);
  }
  void add_keep_dim(bool keep_dim) {
    fbb_.AddElement<uint8_t>(ReductionArgMaxOp::VT_KEEP_DIM, static_cast<uint8_t>(keep_dim), 0);
  }
  void add_use_multicore(bool use_multicore) {
    fbb_.AddElement<uint8_t>(ReductionArgMaxOp::VT_USE_MULTICORE, static_cast<uint8_t>(use_multicore), 0);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(ReductionArgMaxOp::VT_MEMCFG, memcfg);
  }
  explicit ReductionArgMaxOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReductionArgMaxOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReductionArgMaxOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReductionArgMaxOp> CreateReductionArgMaxOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    ::flatbuffers::Optional<int32_t> dim = ::flatbuffers::nullopt,
    bool keep_dim = false,
    bool use_multicore = false,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0) {
  ReductionArgMaxOpBuilder builder_(_fbb);
  builder_.add_memcfg(memcfg);
  if(dim) { builder_.add_dim(*dim); }
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_use_multicore(use_multicore);
  builder_.add_keep_dim(keep_dim);
  return builder_.Finish();
}
 
struct ReductionArgMaxOp::Traits {
  using type = ReductionArgMaxOp;
  static auto constexpr Create = CreateReductionArgMaxOp;
};
 
struct ReductionProdOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef ReductionProdOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.ReductionProdOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_ALL_DIMENSIONS = 8,
    VT_DIM_ARG = 10,
    VT_KEEP_DIM = 12,
    VT_MEMCFG = 14
  };
  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 all_dimensions() const {
    return GetField<uint8_t>(VT_ALL_DIMENSIONS, 0) != 0;
  }
  int64_t dim_arg() const {
    return GetField<int64_t>(VT_DIM_ARG, 0);
  }
  bool keep_dim() const {
    return GetField<uint8_t>(VT_KEEP_DIM, 0) != 0;
  }
  const tt::target::ttnn::MemoryConfig *memcfg() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMCFG);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<uint8_t>(verifier, VT_ALL_DIMENSIONS, 1) &&
           VerifyField<int64_t>(verifier, VT_DIM_ARG, 8) &&
           VerifyField<uint8_t>(verifier, VT_KEEP_DIM, 1) &&
           VerifyOffset(verifier, VT_MEMCFG) &&
           verifier.VerifyTable(memcfg()) &&
           verifier.EndTable();
  }
};
 
struct ReductionProdOpBuilder {
  typedef ReductionProdOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(ReductionProdOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(ReductionProdOp::VT_OUT, out);
  }
  void add_all_dimensions(bool all_dimensions) {
    fbb_.AddElement<uint8_t>(ReductionProdOp::VT_ALL_DIMENSIONS, static_cast<uint8_t>(all_dimensions), 0);
  }
  void add_dim_arg(int64_t dim_arg) {
    fbb_.AddElement<int64_t>(ReductionProdOp::VT_DIM_ARG, dim_arg, 0);
  }
  void add_keep_dim(bool keep_dim) {
    fbb_.AddElement<uint8_t>(ReductionProdOp::VT_KEEP_DIM, static_cast<uint8_t>(keep_dim), 0);
  }
  void add_memcfg(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg) {
    fbb_.AddOffset(ReductionProdOp::VT_MEMCFG, memcfg);
  }
  explicit ReductionProdOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<ReductionProdOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<ReductionProdOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<ReductionProdOp> CreateReductionProdOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    bool all_dimensions = false,
    int64_t dim_arg = 0,
    bool keep_dim = false,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memcfg = 0) {
  ReductionProdOpBuilder builder_(_fbb);
  builder_.add_dim_arg(dim_arg);
  builder_.add_memcfg(memcfg);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_keep_dim(keep_dim);
  builder_.add_all_dimensions(all_dimensions);
  return builder_.Finish();
}
 
struct ReductionProdOp::Traits {
  using type = ReductionProdOp;
  static auto constexpr Create = CreateReductionProdOp;
};
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_REDUCTION_TT_TARGET_TTNN_H_