pool_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_POOL_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_POOL_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 MaxPool2dOp;
struct MaxPool2dOpBuilder;
 
struct UniformScale2D;
struct UniformScale2DBuilder;
 
struct NonUniformScale2D;
struct NonUniformScale2DBuilder;
 
struct UpsampleOp;
struct UpsampleOpBuilder;
 
enum class Scale2D : uint8_t {
  NONE = 0,
  UniformScale2D = 1,
  NonUniformScale2D = 2,
  MIN = NONE,
  MAX = NonUniformScale2D
};
 
inline const Scale2D (&EnumValuesScale2D())[3] {
  static const Scale2D values[] = {
    Scale2D::NONE,
    Scale2D::UniformScale2D,
    Scale2D::NonUniformScale2D
  };
  return values;
}
 
inline const char * const *EnumNamesScale2D() {
  static const char * const names[4] = {
    "NONE",
    "UniformScale2D",
    "NonUniformScale2D",
    nullptr
  };
  return names;
}
 
inline const char *EnumNameScale2D(Scale2D e) {
  if (::flatbuffers::IsOutRange(e, Scale2D::NONE, Scale2D::NonUniformScale2D)) return "";
  const size_t index = static_cast<size_t>(e);
  return EnumNamesScale2D()[index];
}
 
template<typename T> struct Scale2DTraits {
  static const Scale2D enum_value = Scale2D::NONE;
};
 
template<> struct Scale2DTraits<tt::target::ttnn::UniformScale2D> {
  static const Scale2D enum_value = Scale2D::UniformScale2D;
};
 
template<> struct Scale2DTraits<tt::target::ttnn::NonUniformScale2D> {
  static const Scale2D enum_value = Scale2D::NonUniformScale2D;
};
 
bool VerifyScale2D(::flatbuffers::Verifier &verifier, const void *obj, Scale2D type);
bool VerifyScale2DVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Scale2D> *types);
 
struct MaxPool2dOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef MaxPool2dOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_OUT = 6,
    VT_BATCH_SIZE = 8,
    VT_INPUT_HEIGHT = 10,
    VT_INPUT_WIDTH = 12,
    VT_CHANNELS = 14,
    VT_KERNEL_SIZE = 16,
    VT_STRIDE = 18,
    VT_PADDING = 20,
    VT_DILATION = 22,
    VT_CEIL_MODE = 24
  };
  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);
  }
  uint32_t batch_size() const {
    return GetField<uint32_t>(VT_BATCH_SIZE, 0);
  }
  uint32_t input_height() const {
    return GetField<uint32_t>(VT_INPUT_HEIGHT, 0);
  }
  uint32_t input_width() const {
    return GetField<uint32_t>(VT_INPUT_WIDTH, 0);
  }
  uint32_t channels() const {
    return GetField<uint32_t>(VT_CHANNELS, 0);
  }
  const ::flatbuffers::Vector<int32_t> *kernel_size() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_KERNEL_SIZE);
  }
  const ::flatbuffers::Vector<int32_t> *stride() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_STRIDE);
  }
  const ::flatbuffers::Vector<int32_t> *padding() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_PADDING);
  }
  const ::flatbuffers::Vector<int32_t> *dilation() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_DILATION);
  }
  bool ceil_mode() const {
    return GetField<uint8_t>(VT_CEIL_MODE, 0) != 0;
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_IN) &&
           verifier.VerifyTable(in()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           VerifyField<uint32_t>(verifier, VT_BATCH_SIZE, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_HEIGHT, 4) &&
           VerifyField<uint32_t>(verifier, VT_INPUT_WIDTH, 4) &&
           VerifyField<uint32_t>(verifier, VT_CHANNELS, 4) &&
           VerifyOffset(verifier, VT_KERNEL_SIZE) &&
           verifier.VerifyVector(kernel_size()) &&
           VerifyOffset(verifier, VT_STRIDE) &&
           verifier.VerifyVector(stride()) &&
           VerifyOffset(verifier, VT_PADDING) &&
           verifier.VerifyVector(padding()) &&
           VerifyOffset(verifier, VT_DILATION) &&
           verifier.VerifyVector(dilation()) &&
           VerifyField<uint8_t>(verifier, VT_CEIL_MODE, 1) &&
           verifier.EndTable();
  }
};
 
struct MaxPool2dOpBuilder {
  typedef MaxPool2dOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(MaxPool2dOp::VT_IN, in);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(MaxPool2dOp::VT_OUT, out);
  }
  void add_batch_size(uint32_t batch_size) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_BATCH_SIZE, batch_size, 0);
  }
  void add_input_height(uint32_t input_height) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_INPUT_HEIGHT, input_height, 0);
  }
  void add_input_width(uint32_t input_width) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_INPUT_WIDTH, input_width, 0);
  }
  void add_channels(uint32_t channels) {
    fbb_.AddElement<uint32_t>(MaxPool2dOp::VT_CHANNELS, channels, 0);
  }
  void add_kernel_size(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size) {
    fbb_.AddOffset(MaxPool2dOp::VT_KERNEL_SIZE, kernel_size);
  }
  void add_stride(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride) {
    fbb_.AddOffset(MaxPool2dOp::VT_STRIDE, stride);
  }
  void add_padding(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding) {
    fbb_.AddOffset(MaxPool2dOp::VT_PADDING, padding);
  }
  void add_dilation(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation) {
    fbb_.AddOffset(MaxPool2dOp::VT_DILATION, dilation);
  }
  void add_ceil_mode(bool ceil_mode) {
    fbb_.AddElement<uint8_t>(MaxPool2dOp::VT_CEIL_MODE, static_cast<uint8_t>(ceil_mode), 0);
  }
  explicit MaxPool2dOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<MaxPool2dOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<MaxPool2dOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<MaxPool2dOp> CreateMaxPool2dOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    uint32_t channels = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> kernel_size = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> stride = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> padding = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> dilation = 0,
    bool ceil_mode = false) {
  MaxPool2dOpBuilder builder_(_fbb);
  builder_.add_dilation(dilation);
  builder_.add_padding(padding);
  builder_.add_stride(stride);
  builder_.add_kernel_size(kernel_size);
  builder_.add_channels(channels);
  builder_.add_input_width(input_width);
  builder_.add_input_height(input_height);
  builder_.add_batch_size(batch_size);
  builder_.add_out(out);
  builder_.add_in(in);
  builder_.add_ceil_mode(ceil_mode);
  return builder_.Finish();
}
 
struct MaxPool2dOp::Traits {
  using type = MaxPool2dOp;
  static auto constexpr Create = CreateMaxPool2dOp;
};
 
inline ::flatbuffers::Offset<MaxPool2dOp> CreateMaxPool2dOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0,
    uint32_t batch_size = 0,
    uint32_t input_height = 0,
    uint32_t input_width = 0,
    uint32_t channels = 0,
    const std::vector<int32_t> *kernel_size = nullptr,
    const std::vector<int32_t> *stride = nullptr,
    const std::vector<int32_t> *padding = nullptr,
    const std::vector<int32_t> *dilation = nullptr,
    bool ceil_mode = false) {
  auto kernel_size__ = kernel_size ? _fbb.CreateVector<int32_t>(*kernel_size) : 0;
  auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
  auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
  auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0;
  return tt::target::ttnn::CreateMaxPool2dOp(
      _fbb,
      in,
      out,
      batch_size,
      input_height,
      input_width,
      channels,
      kernel_size__,
      stride__,
      padding__,
      dilation__,
      ceil_mode);
}
 
struct UniformScale2D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UniformScale2DBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCALE = 4
  };
  int32_t scale() const {
    return GetField<int32_t>(VT_SCALE, 0);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyField<int32_t>(verifier, VT_SCALE, 4) &&
           verifier.EndTable();
  }
};
 
struct UniformScale2DBuilder {
  typedef UniformScale2D Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_scale(int32_t scale) {
    fbb_.AddElement<int32_t>(UniformScale2D::VT_SCALE, scale, 0);
  }
  explicit UniformScale2DBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UniformScale2D> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UniformScale2D>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<UniformScale2D> CreateUniformScale2D(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    int32_t scale = 0) {
  UniformScale2DBuilder builder_(_fbb);
  builder_.add_scale(scale);
  return builder_.Finish();
}
 
struct UniformScale2D::Traits {
  using type = UniformScale2D;
  static auto constexpr Create = CreateUniformScale2D;
};
 
struct NonUniformScale2D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef NonUniformScale2DBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_SCALE = 4
  };
  const ::flatbuffers::Vector<int32_t> *scale() const {
    return GetPointer<const ::flatbuffers::Vector<int32_t> *>(VT_SCALE);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_SCALE) &&
           verifier.VerifyVector(scale()) &&
           verifier.EndTable();
  }
};
 
struct NonUniformScale2DBuilder {
  typedef NonUniformScale2D Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_scale(::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> scale) {
    fbb_.AddOffset(NonUniformScale2D::VT_SCALE, scale);
  }
  explicit NonUniformScale2DBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<NonUniformScale2D> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<NonUniformScale2D>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<NonUniformScale2D> CreateNonUniformScale2D(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<::flatbuffers::Vector<int32_t>> scale = 0) {
  NonUniformScale2DBuilder builder_(_fbb);
  builder_.add_scale(scale);
  return builder_.Finish();
}
 
struct NonUniformScale2D::Traits {
  using type = NonUniformScale2D;
  static auto constexpr Create = CreateNonUniformScale2D;
};
 
inline ::flatbuffers::Offset<NonUniformScale2D> CreateNonUniformScale2DDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    const std::vector<int32_t> *scale = nullptr) {
  auto scale__ = scale ? _fbb.CreateVector<int32_t>(*scale) : 0;
  return tt::target::ttnn::CreateNonUniformScale2D(
      _fbb,
      scale__);
}
 
struct UpsampleOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef UpsampleOpBuilder Builder;
  struct Traits;
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_IN = 4,
    VT_SCALE_FACTOR_TYPE = 6,
    VT_SCALE_FACTOR = 8,
    VT_MODE = 10,
    VT_MEMORY_CONFIG = 12,
    VT_OUT = 14
  };
  const tt::target::ttnn::TensorRef *in() const {
    return GetPointer<const tt::target::ttnn::TensorRef *>(VT_IN);
  }
  tt::target::ttnn::Scale2D scale_factor_type() const {
    return static_cast<tt::target::ttnn::Scale2D>(GetField<uint8_t>(VT_SCALE_FACTOR_TYPE, 0));
  }
  const void *scale_factor() const {
    return GetPointer<const void *>(VT_SCALE_FACTOR);
  }
  template<typename T> const T *scale_factor_as() const;
  const tt::target::ttnn::UniformScale2D *scale_factor_as_UniformScale2D() const {
    return scale_factor_type() == tt::target::ttnn::Scale2D::UniformScale2D ? static_cast<const tt::target::ttnn::UniformScale2D *>(scale_factor()) : nullptr;
  }
  const tt::target::ttnn::NonUniformScale2D *scale_factor_as_NonUniformScale2D() const {
    return scale_factor_type() == tt::target::ttnn::Scale2D::NonUniformScale2D ? static_cast<const tt::target::ttnn::NonUniformScale2D *>(scale_factor()) : nullptr;
  }
  const ::flatbuffers::String *mode() const {
    return GetPointer<const ::flatbuffers::String *>(VT_MODE);
  }
  const tt::target::ttnn::MemoryConfig *memory_config() const {
    return GetPointer<const tt::target::ttnn::MemoryConfig *>(VT_MEMORY_CONFIG);
  }
  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<uint8_t>(verifier, VT_SCALE_FACTOR_TYPE, 1) &&
           VerifyOffset(verifier, VT_SCALE_FACTOR) &&
           VerifyScale2D(verifier, scale_factor(), scale_factor_type()) &&
           VerifyOffset(verifier, VT_MODE) &&
           verifier.VerifyString(mode()) &&
           VerifyOffset(verifier, VT_MEMORY_CONFIG) &&
           verifier.VerifyTable(memory_config()) &&
           VerifyOffset(verifier, VT_OUT) &&
           verifier.VerifyTable(out()) &&
           verifier.EndTable();
  }
};
 
template<> inline const tt::target::ttnn::UniformScale2D *UpsampleOp::scale_factor_as<tt::target::ttnn::UniformScale2D>() const {
  return scale_factor_as_UniformScale2D();
}
 
template<> inline const tt::target::ttnn::NonUniformScale2D *UpsampleOp::scale_factor_as<tt::target::ttnn::NonUniformScale2D>() const {
  return scale_factor_as_NonUniformScale2D();
}
 
struct UpsampleOpBuilder {
  typedef UpsampleOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_in(::flatbuffers::Offset<tt::target::ttnn::TensorRef> in) {
    fbb_.AddOffset(UpsampleOp::VT_IN, in);
  }
  void add_scale_factor_type(tt::target::ttnn::Scale2D scale_factor_type) {
    fbb_.AddElement<uint8_t>(UpsampleOp::VT_SCALE_FACTOR_TYPE, static_cast<uint8_t>(scale_factor_type), 0);
  }
  void add_scale_factor(::flatbuffers::Offset<void> scale_factor) {
    fbb_.AddOffset(UpsampleOp::VT_SCALE_FACTOR, scale_factor);
  }
  void add_mode(::flatbuffers::Offset<::flatbuffers::String> mode) {
    fbb_.AddOffset(UpsampleOp::VT_MODE, mode);
  }
  void add_memory_config(::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config) {
    fbb_.AddOffset(UpsampleOp::VT_MEMORY_CONFIG, memory_config);
  }
  void add_out(::flatbuffers::Offset<tt::target::ttnn::TensorRef> out) {
    fbb_.AddOffset(UpsampleOp::VT_OUT, out);
  }
  explicit UpsampleOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<UpsampleOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<UpsampleOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<UpsampleOp> CreateUpsampleOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    tt::target::ttnn::Scale2D scale_factor_type = tt::target::ttnn::Scale2D::NONE,
    ::flatbuffers::Offset<void> scale_factor = 0,
    ::flatbuffers::Offset<::flatbuffers::String> mode = 0,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  UpsampleOpBuilder builder_(_fbb);
  builder_.add_out(out);
  builder_.add_memory_config(memory_config);
  builder_.add_mode(mode);
  builder_.add_scale_factor(scale_factor);
  builder_.add_in(in);
  builder_.add_scale_factor_type(scale_factor_type);
  return builder_.Finish();
}
 
struct UpsampleOp::Traits {
  using type = UpsampleOp;
  static auto constexpr Create = CreateUpsampleOp;
};
 
inline ::flatbuffers::Offset<UpsampleOp> CreateUpsampleOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> in = 0,
    tt::target::ttnn::Scale2D scale_factor_type = tt::target::ttnn::Scale2D::NONE,
    ::flatbuffers::Offset<void> scale_factor = 0,
    const char *mode = nullptr,
    ::flatbuffers::Offset<tt::target::ttnn::MemoryConfig> memory_config = 0,
    ::flatbuffers::Offset<tt::target::ttnn::TensorRef> out = 0) {
  auto mode__ = mode ? _fbb.CreateString(mode) : 0;
  return tt::target::ttnn::CreateUpsampleOp(
      _fbb,
      in,
      scale_factor_type,
      scale_factor,
      mode__,
      memory_config,
      out);
}
 
inline bool VerifyScale2D(::flatbuffers::Verifier &verifier, const void *obj, Scale2D type) {
  switch (type) {
    case Scale2D::NONE: {
      return true;
    }
    case Scale2D::UniformScale2D: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::UniformScale2D *>(obj);
      return verifier.VerifyTable(ptr);
    }
    case Scale2D::NonUniformScale2D: {
      auto ptr = reinterpret_cast<const tt::target::ttnn::NonUniformScale2D *>(obj);
      return verifier.VerifyTable(ptr);
    }
    default: return true;
  }
}
 
inline bool VerifyScale2DVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset<void>> *values, const ::flatbuffers::Vector<Scale2D> *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 (!VerifyScale2D(
        verifier,  values->Get(i), types->GetEnum<Scale2D>(i))) {
      return false;
    }
  }
  return true;
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_POOL_TT_TARGET_TTNN_H_