trace_generated.h

Go to the documentation of this file.

// automatically generated by the FlatBuffers compiler, do not modify
 
 
#ifndef FLATBUFFERS_GENERATED_TRACE_TT_TARGET_TTNN_H_
#define FLATBUFFERS_GENERATED_TRACE_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 TraceOp;
struct TraceOpBuilder;
 
struct TraceOp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
  typedef TraceOpBuilder Builder;
  struct Traits;
  static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
    return "tt.target.ttnn.TraceOp";
  }
  enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
    VT_DEVICE = 4,
    VT_CQ_ID = 6,
    VT_BLOCKING = 8,
    VT_CALLEE_NAME = 10,
    VT_CALLEE_PROGRAM_IDX = 12,
    VT_INPUTS = 14,
    VT_OUTPUTS = 16
  };
  const tt::target::DeviceRef *device() const {
    return GetPointer<const tt::target::DeviceRef *>(VT_DEVICE);
  }
  uint32_t cq_id() const {
    return GetField<uint32_t>(VT_CQ_ID, 0);
  }
  bool blocking() const {
    return GetField<uint8_t>(VT_BLOCKING, 0) != 0;
  }
  const ::flatbuffers::String *callee_name() const {
    return GetPointer<const ::flatbuffers::String *>(VT_CALLEE_NAME);
  }
  uint32_t callee_program_idx() const {
    return GetField<uint32_t>(VT_CALLEE_PROGRAM_IDX, 0);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *inputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *>(VT_INPUTS);
  }
  const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *outputs() const {
    return GetPointer<const ::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *>(VT_OUTPUTS);
  }
  bool Verify(::flatbuffers::Verifier &verifier) const {
    return VerifyTableStart(verifier) &&
           VerifyOffset(verifier, VT_DEVICE) &&
           verifier.VerifyTable(device()) &&
           VerifyField<uint32_t>(verifier, VT_CQ_ID, 4) &&
           VerifyField<uint8_t>(verifier, VT_BLOCKING, 1) &&
           VerifyOffset(verifier, VT_CALLEE_NAME) &&
           verifier.VerifyString(callee_name()) &&
           VerifyField<uint32_t>(verifier, VT_CALLEE_PROGRAM_IDX, 4) &&
           VerifyOffset(verifier, VT_INPUTS) &&
           verifier.VerifyVector(inputs()) &&
           verifier.VerifyVectorOfTables(inputs()) &&
           VerifyOffset(verifier, VT_OUTPUTS) &&
           verifier.VerifyVector(outputs()) &&
           verifier.VerifyVectorOfTables(outputs()) &&
           verifier.EndTable();
  }
};
 
struct TraceOpBuilder {
  typedef TraceOp Table;
  ::flatbuffers::FlatBufferBuilder &fbb_;
  ::flatbuffers::uoffset_t start_;
  void add_device(::flatbuffers::Offset<tt::target::DeviceRef> device) {
    fbb_.AddOffset(TraceOp::VT_DEVICE, device);
  }
  void add_cq_id(uint32_t cq_id) {
    fbb_.AddElement<uint32_t>(TraceOp::VT_CQ_ID, cq_id, 0);
  }
  void add_blocking(bool blocking) {
    fbb_.AddElement<uint8_t>(TraceOp::VT_BLOCKING, static_cast<uint8_t>(blocking), 0);
  }
  void add_callee_name(::flatbuffers::Offset<::flatbuffers::String> callee_name) {
    fbb_.AddOffset(TraceOp::VT_CALLEE_NAME, callee_name);
  }
  void add_callee_program_idx(uint32_t callee_program_idx) {
    fbb_.AddElement<uint32_t>(TraceOp::VT_CALLEE_PROGRAM_IDX, callee_program_idx, 0);
  }
  void add_inputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> inputs) {
    fbb_.AddOffset(TraceOp::VT_INPUTS, inputs);
  }
  void add_outputs(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> outputs) {
    fbb_.AddOffset(TraceOp::VT_OUTPUTS, outputs);
  }
  explicit TraceOpBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
        : fbb_(_fbb) {
    start_ = fbb_.StartTable();
  }
  ::flatbuffers::Offset<TraceOp> Finish() {
    const auto end = fbb_.EndTable(start_);
    auto o = ::flatbuffers::Offset<TraceOp>(end);
    return o;
  }
};
 
inline ::flatbuffers::Offset<TraceOp> CreateTraceOp(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    uint32_t cq_id = 0,
    bool blocking = false,
    ::flatbuffers::Offset<::flatbuffers::String> callee_name = 0,
    uint32_t callee_program_idx = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> inputs = 0,
    ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>> outputs = 0) {
  TraceOpBuilder builder_(_fbb);
  builder_.add_outputs(outputs);
  builder_.add_inputs(inputs);
  builder_.add_callee_program_idx(callee_program_idx);
  builder_.add_callee_name(callee_name);
  builder_.add_cq_id(cq_id);
  builder_.add_device(device);
  builder_.add_blocking(blocking);
  return builder_.Finish();
}
 
struct TraceOp::Traits {
  using type = TraceOp;
  static auto constexpr Create = CreateTraceOp;
};
 
inline ::flatbuffers::Offset<TraceOp> CreateTraceOpDirect(
    ::flatbuffers::FlatBufferBuilder &_fbb,
    ::flatbuffers::Offset<tt::target::DeviceRef> device = 0,
    uint32_t cq_id = 0,
    bool blocking = false,
    const char *callee_name = nullptr,
    uint32_t callee_program_idx = 0,
    const std::vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *inputs = nullptr,
    const std::vector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>> *outputs = nullptr) {
  auto callee_name__ = callee_name ? _fbb.CreateString(callee_name) : 0;
  auto inputs__ = inputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>(*inputs) : 0;
  auto outputs__ = outputs ? _fbb.CreateVector<::flatbuffers::Offset<tt::target::ttnn::TensorRef>>(*outputs) : 0;
  return tt::target::ttnn::CreateTraceOp(
      _fbb,
      device,
      cq_id,
      blocking,
      callee_name__,
      callee_program_idx,
      inputs__,
      outputs__);
}
 
}  // namespace ttnn
}  // namespace target
}  // namespace tt
 
#endif  // FLATBUFFERS_GENERATED_TRACE_TT_TARGET_TTNN_H_