// automatically generated by the FlatBuffers compiler, do not modify #ifndef FLATBUFFERS_GENERATED_MPSSCHEMA_MPSGRAPH_H_ #define FLATBUFFERS_GENERATED_MPSSCHEMA_MPSGRAPH_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"); namespace mpsgraph { struct _MPSNode1x1; struct _MPSNode1x1Builder; struct _MPSNode2x1; struct _MPSNode2x1Builder; struct _MPSDivNode2x1; struct _MPSDivNode2x1Builder; struct _MPSNodeWithAlpha2x1; struct _MPSNodeWithAlpha2x1Builder; struct _MPSNode3x1; struct _MPSNode3x1Builder; struct MPSMinMax; struct MPSMinMaxBuilder; struct MPSPooling2D; struct MPSPooling2DBuilder; struct MPSHardTanh; struct MPSHardTanhBuilder; struct MPSGELU; struct MPSGELUBuilder; struct MPSLeakyReLU; struct MPSLeakyReLUBuilder; struct MPSSoftmax; struct MPSSoftmaxBuilder; struct MPSClamp; struct MPSClampBuilder; struct MPSMean; struct MPSMeanBuilder; struct MPSIndexSelect; struct MPSIndexSelectBuilder; struct MPSEmbedding; struct MPSEmbeddingBuilder; struct MPSIndexTensor; struct MPSIndexTensorBuilder; struct MPSIndexPut; struct MPSIndexPutBuilder; struct MPSScatter; struct MPSScatterBuilder; struct MPSPermute; struct MPSPermuteBuilder; struct MPSView; struct MPSViewBuilder; struct MPSCat; struct MPSCatBuilder; struct MPSSqueeze; struct MPSSqueezeBuilder; struct MPSUnsqueeze; struct MPSUnsqueezeBuilder; struct MPSSelect; struct MPSSelectBuilder; struct MPSSlice; struct MPSSliceBuilder; struct MPSPixelShuffle; struct MPSPixelShuffleBuilder; struct MPSSplitWithSizes; struct MPSSplitWithSizesBuilder; struct MPSCast; struct MPSCastBuilder; struct MPSAddmm; struct MPSAddmmBuilder; struct _MPSFull; struct _MPSFullBuilder; struct MPSConv; struct MPSConvBuilder; struct MPSBatchNorm; struct MPSBatchNormBuilder; struct MPSLayerNorm; struct MPSLayerNormBuilder; struct MPSConstantPadND; struct MPSConstantPadNDBuilder; struct MPSArange; struct MPSArangeBuilder; struct MPSDequantizePerChannelGroup; struct MPSDequantizePerChannelGroupBuilder; struct MPSNode; struct MPSNodeBuilder; struct Buffer; struct BufferBuilder; struct MPSTensor; struct MPSTensorBuilder; struct DataSegment; struct DataSegmentBuilder; struct MPSGraph; struct MPSGraphBuilder; enum MPSDataType : int16_t { MPSDataType_mps_data_type_invalid = 0, MPSDataType_mps_data_type_float16 = 1, MPSDataType_mps_data_type_float32 = 2, MPSDataType_mps_data_type_float64 = 3, MPSDataType_mps_data_type_bfloat16 = 4, MPSDataType_mps_data_type_int4 = 5, MPSDataType_mps_data_type_int8 = 6, MPSDataType_mps_data_type_int16 = 7, MPSDataType_mps_data_type_int32 = 8, MPSDataType_mps_data_type_int64 = 9, MPSDataType_mps_data_type_uint4 = 10, MPSDataType_mps_data_type_uint8 = 11, MPSDataType_mps_data_type_uint16 = 12, MPSDataType_mps_data_type_uint32 = 13, MPSDataType_mps_data_type_uint64 = 14, MPSDataType_mps_data_type_bool = 15, MPSDataType_mps_data_type_complex_float16 = 16, MPSDataType_mps_data_type_complex_float32 = 17, MPSDataType_MIN = MPSDataType_mps_data_type_invalid, MPSDataType_MAX = MPSDataType_mps_data_type_complex_float32 }; inline const MPSDataType (&EnumValuesMPSDataType())[18] { static const MPSDataType values[] = { MPSDataType_mps_data_type_invalid, MPSDataType_mps_data_type_float16, MPSDataType_mps_data_type_float32, MPSDataType_mps_data_type_float64, MPSDataType_mps_data_type_bfloat16, MPSDataType_mps_data_type_int4, MPSDataType_mps_data_type_int8, MPSDataType_mps_data_type_int16, MPSDataType_mps_data_type_int32, MPSDataType_mps_data_type_int64, MPSDataType_mps_data_type_uint4, MPSDataType_mps_data_type_uint8, MPSDataType_mps_data_type_uint16, MPSDataType_mps_data_type_uint32, MPSDataType_mps_data_type_uint64, MPSDataType_mps_data_type_bool, MPSDataType_mps_data_type_complex_float16, MPSDataType_mps_data_type_complex_float32 }; return values; } inline const char * const *EnumNamesMPSDataType() { static const char * const names[19] = { "mps_data_type_invalid", "mps_data_type_float16", "mps_data_type_float32", "mps_data_type_float64", "mps_data_type_bfloat16", "mps_data_type_int4", "mps_data_type_int8", "mps_data_type_int16", "mps_data_type_int32", "mps_data_type_int64", "mps_data_type_uint4", "mps_data_type_uint8", "mps_data_type_uint16", "mps_data_type_uint32", "mps_data_type_uint64", "mps_data_type_bool", "mps_data_type_complex_float16", "mps_data_type_complex_float32", nullptr }; return names; } inline const char *EnumNameMPSDataType(MPSDataType e) { if (::flatbuffers::IsOutRange(e, MPSDataType_mps_data_type_invalid, MPSDataType_mps_data_type_complex_float32)) return ""; const size_t index = static_cast(e); return EnumNamesMPSDataType()[index]; } enum OpType : int16_t { OpType_mps_graph = 0, OpType_metal_kernel = 1, OpType_MIN = OpType_mps_graph, OpType_MAX = OpType_metal_kernel }; inline const OpType (&EnumValuesOpType())[2] { static const OpType values[] = { OpType_mps_graph, OpType_metal_kernel }; return values; } inline const char * const *EnumNamesOpType() { static const char * const names[3] = { "mps_graph", "metal_kernel", nullptr }; return names; } inline const char *EnumNameOpType(OpType e) { if (::flatbuffers::IsOutRange(e, OpType_mps_graph, OpType_metal_kernel)) return ""; const size_t index = static_cast(e); return EnumNamesOpType()[index]; } enum MPSNodeUnion : uint8_t { MPSNodeUnion_NONE = 0, MPSNodeUnion_MPSHardTanh = 1, MPSNodeUnion_MPSReLU = 2, MPSNodeUnion_MPSGELU = 3, MPSNodeUnion_MPSLeakyReLU = 4, MPSNodeUnion_MPSSoftmax = 5, MPSNodeUnion_MPSLogSoftmax = 6, MPSNodeUnion_MPSAdd = 7, MPSNodeUnion_MPSSub = 8, MPSNodeUnion_MPSMul = 9, MPSNodeUnion_MPSDiv = 10, MPSNodeUnion_MPSFmod = 11, MPSNodeUnion_MPSRemainder = 12, MPSNodeUnion_MPSMin = 13, MPSNodeUnion_MPSMax = 14, MPSNodeUnion_MPSPow = 15, MPSNodeUnion_MPSAtan2 = 16, MPSNodeUnion_MPSBitwiseAnd = 17, MPSNodeUnion_MPSBitwiseOr = 18, MPSNodeUnion_MPSBitwiseXor = 19, MPSNodeUnion_MPSMinimum = 20, MPSNodeUnion_MPSExp = 21, MPSNodeUnion_MPSExp2 = 22, MPSNodeUnion_MPSReciprocal = 23, MPSNodeUnion_MPSSqrt = 24, MPSNodeUnion_MPSNeg = 25, MPSNodeUnion_MPSLog = 26, MPSNodeUnion_MPSLog10 = 27, MPSNodeUnion_MPSLog2 = 28, MPSNodeUnion_MPSErf = 29, MPSNodeUnion_MPSFloor = 30, MPSNodeUnion_MPSCeil = 31, MPSNodeUnion_MPSRsqrt = 32, MPSNodeUnion_MPSSigmoid = 33, MPSNodeUnion_MPSSin = 34, MPSNodeUnion_MPSSign = 35, MPSNodeUnion_MPSCos = 36, MPSNodeUnion_MPSTan = 37, MPSNodeUnion_MPSAbs = 38, MPSNodeUnion_MPSAsin = 39, MPSNodeUnion_MPSAcos = 40, MPSNodeUnion_MPSAtan = 41, MPSNodeUnion_MPSSinh = 42, MPSNodeUnion_MPSCosh = 43, MPSNodeUnion_MPSTanh = 44, MPSNodeUnion_MPSAsinh = 45, MPSNodeUnion_MPSAcosh = 46, MPSNodeUnion_MPSAtanh = 47, MPSNodeUnion_MPSBitwiseNot = 48, MPSNodeUnion_MPSIsnan = 49, MPSNodeUnion_MPSIsinf = 50, MPSNodeUnion_MPSRound = 51, MPSNodeUnion_MPSLogicalNot = 52, MPSNodeUnion_MPSMatMul = 53, MPSNodeUnion_MPSAddmm = 54, MPSNodeUnion_MPSFull = 55, MPSNodeUnion_MPSFullLike = 56, MPSNodeUnion_MPSClamp = 57, MPSNodeUnion_MPSWhere = 58, MPSNodeUnion_MPSIndexSelect = 59, MPSNodeUnion_MPSEmbedding = 60, MPSNodeUnion_MPSIndexTensor = 61, MPSNodeUnion_MPSIndexPut = 62, MPSNodeUnion_MPSScatter = 63, MPSNodeUnion_MPSMean = 64, MPSNodeUnion_MPSPermute = 65, MPSNodeUnion_MPSView = 66, MPSNodeUnion_MPSExpand = 67, MPSNodeUnion_MPSCat = 68, MPSNodeUnion_MPSSqueeze = 69, MPSNodeUnion_MPSUnsqueeze = 70, MPSNodeUnion_MPSSelect = 71, MPSNodeUnion_MPSSlice = 72, MPSNodeUnion_MPSPixelShuffle = 73, MPSNodeUnion_MPSSplitWithSizes = 74, MPSNodeUnion_MPSCast = 75, MPSNodeUnion_MPSConv2D = 76, MPSNodeUnion_MPSDepthwiseConv2D = 77, MPSNodeUnion_MPSEq = 78, MPSNodeUnion_MPSNe = 79, MPSNodeUnion_MPSGe = 80, MPSNodeUnion_MPSGt = 81, MPSNodeUnion_MPSLe = 82, MPSNodeUnion_MPSLt = 83, MPSNodeUnion_MPSBatchNorm = 84, MPSNodeUnion_MPSLayerNorm = 85, MPSNodeUnion_MPSMaxPool2DWithIndices = 86, MPSNodeUnion_MPSAvgPool2D = 87, MPSNodeUnion_MPSConstantPadND = 88, MPSNodeUnion_MPSArange = 89, MPSNodeUnion_MPSDequantizePerChannelGroup = 90, MPSNodeUnion_MIN = MPSNodeUnion_NONE, MPSNodeUnion_MAX = MPSNodeUnion_MPSDequantizePerChannelGroup }; inline const MPSNodeUnion (&EnumValuesMPSNodeUnion())[91] { static const MPSNodeUnion values[] = { MPSNodeUnion_NONE, MPSNodeUnion_MPSHardTanh, MPSNodeUnion_MPSReLU, MPSNodeUnion_MPSGELU, MPSNodeUnion_MPSLeakyReLU, MPSNodeUnion_MPSSoftmax, MPSNodeUnion_MPSLogSoftmax, MPSNodeUnion_MPSAdd, MPSNodeUnion_MPSSub, MPSNodeUnion_MPSMul, MPSNodeUnion_MPSDiv, MPSNodeUnion_MPSFmod, MPSNodeUnion_MPSRemainder, MPSNodeUnion_MPSMin, MPSNodeUnion_MPSMax, MPSNodeUnion_MPSPow, MPSNodeUnion_MPSAtan2, MPSNodeUnion_MPSBitwiseAnd, MPSNodeUnion_MPSBitwiseOr, MPSNodeUnion_MPSBitwiseXor, MPSNodeUnion_MPSMinimum, MPSNodeUnion_MPSExp, MPSNodeUnion_MPSExp2, MPSNodeUnion_MPSReciprocal, MPSNodeUnion_MPSSqrt, MPSNodeUnion_MPSNeg, MPSNodeUnion_MPSLog, MPSNodeUnion_MPSLog10, MPSNodeUnion_MPSLog2, MPSNodeUnion_MPSErf, MPSNodeUnion_MPSFloor, MPSNodeUnion_MPSCeil, MPSNodeUnion_MPSRsqrt, MPSNodeUnion_MPSSigmoid, MPSNodeUnion_MPSSin, MPSNodeUnion_MPSSign, MPSNodeUnion_MPSCos, MPSNodeUnion_MPSTan, MPSNodeUnion_MPSAbs, MPSNodeUnion_MPSAsin, MPSNodeUnion_MPSAcos, MPSNodeUnion_MPSAtan, MPSNodeUnion_MPSSinh, MPSNodeUnion_MPSCosh, MPSNodeUnion_MPSTanh, MPSNodeUnion_MPSAsinh, MPSNodeUnion_MPSAcosh, MPSNodeUnion_MPSAtanh, MPSNodeUnion_MPSBitwiseNot, MPSNodeUnion_MPSIsnan, MPSNodeUnion_MPSIsinf, MPSNodeUnion_MPSRound, MPSNodeUnion_MPSLogicalNot, MPSNodeUnion_MPSMatMul, MPSNodeUnion_MPSAddmm, MPSNodeUnion_MPSFull, MPSNodeUnion_MPSFullLike, MPSNodeUnion_MPSClamp, MPSNodeUnion_MPSWhere, MPSNodeUnion_MPSIndexSelect, MPSNodeUnion_MPSEmbedding, MPSNodeUnion_MPSIndexTensor, MPSNodeUnion_MPSIndexPut, MPSNodeUnion_MPSScatter, MPSNodeUnion_MPSMean, MPSNodeUnion_MPSPermute, MPSNodeUnion_MPSView, MPSNodeUnion_MPSExpand, MPSNodeUnion_MPSCat, MPSNodeUnion_MPSSqueeze, MPSNodeUnion_MPSUnsqueeze, MPSNodeUnion_MPSSelect, MPSNodeUnion_MPSSlice, MPSNodeUnion_MPSPixelShuffle, MPSNodeUnion_MPSSplitWithSizes, MPSNodeUnion_MPSCast, MPSNodeUnion_MPSConv2D, MPSNodeUnion_MPSDepthwiseConv2D, MPSNodeUnion_MPSEq, MPSNodeUnion_MPSNe, MPSNodeUnion_MPSGe, MPSNodeUnion_MPSGt, MPSNodeUnion_MPSLe, MPSNodeUnion_MPSLt, MPSNodeUnion_MPSBatchNorm, MPSNodeUnion_MPSLayerNorm, MPSNodeUnion_MPSMaxPool2DWithIndices, MPSNodeUnion_MPSAvgPool2D, MPSNodeUnion_MPSConstantPadND, MPSNodeUnion_MPSArange, MPSNodeUnion_MPSDequantizePerChannelGroup }; return values; } inline const char * const *EnumNamesMPSNodeUnion() { static const char * const names[92] = { "NONE", "MPSHardTanh", "MPSReLU", "MPSGELU", "MPSLeakyReLU", "MPSSoftmax", "MPSLogSoftmax", "MPSAdd", "MPSSub", "MPSMul", "MPSDiv", "MPSFmod", "MPSRemainder", "MPSMin", "MPSMax", "MPSPow", "MPSAtan2", "MPSBitwiseAnd", "MPSBitwiseOr", "MPSBitwiseXor", "MPSMinimum", "MPSExp", "MPSExp2", "MPSReciprocal", "MPSSqrt", "MPSNeg", "MPSLog", "MPSLog10", "MPSLog2", "MPSErf", "MPSFloor", "MPSCeil", "MPSRsqrt", "MPSSigmoid", "MPSSin", "MPSSign", "MPSCos", "MPSTan", "MPSAbs", "MPSAsin", "MPSAcos", "MPSAtan", "MPSSinh", "MPSCosh", "MPSTanh", "MPSAsinh", "MPSAcosh", "MPSAtanh", "MPSBitwiseNot", "MPSIsnan", "MPSIsinf", "MPSRound", "MPSLogicalNot", "MPSMatMul", "MPSAddmm", "MPSFull", "MPSFullLike", "MPSClamp", "MPSWhere", "MPSIndexSelect", "MPSEmbedding", "MPSIndexTensor", "MPSIndexPut", "MPSScatter", "MPSMean", "MPSPermute", "MPSView", "MPSExpand", "MPSCat", "MPSSqueeze", "MPSUnsqueeze", "MPSSelect", "MPSSlice", "MPSPixelShuffle", "MPSSplitWithSizes", "MPSCast", "MPSConv2D", "MPSDepthwiseConv2D", "MPSEq", "MPSNe", "MPSGe", "MPSGt", "MPSLe", "MPSLt", "MPSBatchNorm", "MPSLayerNorm", "MPSMaxPool2DWithIndices", "MPSAvgPool2D", "MPSConstantPadND", "MPSArange", "MPSDequantizePerChannelGroup", nullptr }; return names; } inline const char *EnumNameMPSNodeUnion(MPSNodeUnion e) { if (::flatbuffers::IsOutRange(e, MPSNodeUnion_NONE, MPSNodeUnion_MPSDequantizePerChannelGroup)) return ""; const size_t index = static_cast(e); return EnumNamesMPSNodeUnion()[index]; } bool VerifyMPSNodeUnion(::flatbuffers::Verifier &verifier, const void *obj, MPSNodeUnion type); bool VerifyMPSNodeUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types); struct _MPSNode1x1 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef _MPSNode1x1Builder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && verifier.EndTable(); } }; struct _MPSNode1x1Builder { typedef _MPSNode1x1 Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(_MPSNode1x1::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(_MPSNode1x1::VT_OUTPUT_ID, output_id, 0); } explicit _MPSNode1x1Builder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset<_MPSNode1x1> Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset<_MPSNode1x1>(end); return o; } }; inline ::flatbuffers::Offset<_MPSNode1x1> Create_MPSNode1x1( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0) { _MPSNode1x1Builder builder_(_fbb); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct _MPSNode2x1 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef _MPSNode2x1Builder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_INPUT2_ID = 6, VT_OUTPUT_ID = 8 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t input2_id() const { return GetField(VT_INPUT2_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_INPUT2_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && verifier.EndTable(); } }; struct _MPSNode2x1Builder { typedef _MPSNode2x1 Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(_MPSNode2x1::VT_INPUT1_ID, input1_id, 0); } void add_input2_id(int32_t input2_id) { fbb_.AddElement(_MPSNode2x1::VT_INPUT2_ID, input2_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(_MPSNode2x1::VT_OUTPUT_ID, output_id, 0); } explicit _MPSNode2x1Builder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset<_MPSNode2x1> Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset<_MPSNode2x1>(end); return o; } }; inline ::flatbuffers::Offset<_MPSNode2x1> Create_MPSNode2x1( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t input2_id = 0, int32_t output_id = 0) { _MPSNode2x1Builder builder_(_fbb); builder_.add_output_id(output_id); builder_.add_input2_id(input2_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct _MPSDivNode2x1 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef _MPSDivNode2x1Builder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_INPUT2_ID = 6, VT_OUTPUT_ID = 8, VT_ROUNDING_MODE = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t input2_id() const { return GetField(VT_INPUT2_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } const ::flatbuffers::String *rounding_mode() const { return GetPointer(VT_ROUNDING_MODE); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_INPUT2_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyOffset(verifier, VT_ROUNDING_MODE) && verifier.VerifyString(rounding_mode()) && verifier.EndTable(); } }; struct _MPSDivNode2x1Builder { typedef _MPSDivNode2x1 Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(_MPSDivNode2x1::VT_INPUT1_ID, input1_id, 0); } void add_input2_id(int32_t input2_id) { fbb_.AddElement(_MPSDivNode2x1::VT_INPUT2_ID, input2_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(_MPSDivNode2x1::VT_OUTPUT_ID, output_id, 0); } void add_rounding_mode(::flatbuffers::Offset<::flatbuffers::String> rounding_mode) { fbb_.AddOffset(_MPSDivNode2x1::VT_ROUNDING_MODE, rounding_mode); } explicit _MPSDivNode2x1Builder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset<_MPSDivNode2x1> Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset<_MPSDivNode2x1>(end); return o; } }; inline ::flatbuffers::Offset<_MPSDivNode2x1> Create_MPSDivNode2x1( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t input2_id = 0, int32_t output_id = 0, ::flatbuffers::Offset<::flatbuffers::String> rounding_mode = 0) { _MPSDivNode2x1Builder builder_(_fbb); builder_.add_rounding_mode(rounding_mode); builder_.add_output_id(output_id); builder_.add_input2_id(input2_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset<_MPSDivNode2x1> Create_MPSDivNode2x1Direct( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t input2_id = 0, int32_t output_id = 0, const char *rounding_mode = nullptr) { auto rounding_mode__ = rounding_mode ? _fbb.CreateString(rounding_mode) : 0; return mpsgraph::Create_MPSDivNode2x1( _fbb, input1_id, input2_id, output_id, rounding_mode__); } struct _MPSNodeWithAlpha2x1 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef _MPSNodeWithAlpha2x1Builder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_INPUT2_ID = 6, VT_OUTPUT_ID = 8, VT_ALPHA = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t input2_id() const { return GetField(VT_INPUT2_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } float alpha() const { return GetField(VT_ALPHA, 0.0f); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_INPUT2_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_ALPHA, 4) && verifier.EndTable(); } }; struct _MPSNodeWithAlpha2x1Builder { typedef _MPSNodeWithAlpha2x1 Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(_MPSNodeWithAlpha2x1::VT_INPUT1_ID, input1_id, 0); } void add_input2_id(int32_t input2_id) { fbb_.AddElement(_MPSNodeWithAlpha2x1::VT_INPUT2_ID, input2_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(_MPSNodeWithAlpha2x1::VT_OUTPUT_ID, output_id, 0); } void add_alpha(float alpha) { fbb_.AddElement(_MPSNodeWithAlpha2x1::VT_ALPHA, alpha, 0.0f); } explicit _MPSNodeWithAlpha2x1Builder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset<_MPSNodeWithAlpha2x1> Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset<_MPSNodeWithAlpha2x1>(end); return o; } }; inline ::flatbuffers::Offset<_MPSNodeWithAlpha2x1> Create_MPSNodeWithAlpha2x1( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t input2_id = 0, int32_t output_id = 0, float alpha = 0.0f) { _MPSNodeWithAlpha2x1Builder builder_(_fbb); builder_.add_alpha(alpha); builder_.add_output_id(output_id); builder_.add_input2_id(input2_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct _MPSNode3x1 FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef _MPSNode3x1Builder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_INPUT2_ID = 6, VT_INPUT3_ID = 8, VT_OUTPUT_ID = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t input2_id() const { return GetField(VT_INPUT2_ID, 0); } int32_t input3_id() const { return GetField(VT_INPUT3_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_INPUT2_ID, 4) && VerifyField(verifier, VT_INPUT3_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && verifier.EndTable(); } }; struct _MPSNode3x1Builder { typedef _MPSNode3x1 Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(_MPSNode3x1::VT_INPUT1_ID, input1_id, 0); } void add_input2_id(int32_t input2_id) { fbb_.AddElement(_MPSNode3x1::VT_INPUT2_ID, input2_id, 0); } void add_input3_id(int32_t input3_id) { fbb_.AddElement(_MPSNode3x1::VT_INPUT3_ID, input3_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(_MPSNode3x1::VT_OUTPUT_ID, output_id, 0); } explicit _MPSNode3x1Builder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset<_MPSNode3x1> Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset<_MPSNode3x1>(end); return o; } }; inline ::flatbuffers::Offset<_MPSNode3x1> Create_MPSNode3x1( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t input2_id = 0, int32_t input3_id = 0, int32_t output_id = 0) { _MPSNode3x1Builder builder_(_fbb); builder_.add_output_id(output_id); builder_.add_input3_id(input3_id); builder_.add_input2_id(input2_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSMinMax FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSMinMaxBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_MIN_VALUE = 4, VT_MAX_VALUE = 6 }; float min_value() const { return GetField(VT_MIN_VALUE, 0.0f); } float max_value() const { return GetField(VT_MAX_VALUE, 0.0f); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_MIN_VALUE, 4) && VerifyField(verifier, VT_MAX_VALUE, 4) && verifier.EndTable(); } }; struct MPSMinMaxBuilder { typedef MPSMinMax Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_min_value(float min_value) { fbb_.AddElement(MPSMinMax::VT_MIN_VALUE, min_value, 0.0f); } void add_max_value(float max_value) { fbb_.AddElement(MPSMinMax::VT_MAX_VALUE, max_value, 0.0f); } explicit MPSMinMaxBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSMinMax( ::flatbuffers::FlatBufferBuilder &_fbb, float min_value = 0.0f, float max_value = 0.0f) { MPSMinMaxBuilder builder_(_fbb); builder_.add_max_value(max_value); builder_.add_min_value(min_value); return builder_.Finish(); } struct MPSPooling2D FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSPooling2DBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_KERNEL_HEIGHT = 6, VT_KERNEL_WIDTH = 8, VT_STRIDE_HEIGHT = 10, VT_STRIDE_WIDTH = 12, VT_PADDING_LEFT = 14, VT_PADDING_RIGHT = 16, VT_PADDING_TOP = 18, VT_PADDING_BOTTOM = 20, VT_DILATION_HEIGHT = 22, VT_DILATION_WIDTH = 24, VT_CEIL_MODE = 26, VT_COUNT_INCLUDE_PAD = 28, VT_DIVISOR_OVERRIDE = 30, VT_OUTPUT1_ID = 32, VT_OUTPUT2_ID = 34 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t kernel_height() const { return GetField(VT_KERNEL_HEIGHT, 0); } int32_t kernel_width() const { return GetField(VT_KERNEL_WIDTH, 0); } int32_t stride_height() const { return GetField(VT_STRIDE_HEIGHT, 0); } int32_t stride_width() const { return GetField(VT_STRIDE_WIDTH, 0); } int32_t padding_left() const { return GetField(VT_PADDING_LEFT, 0); } int32_t padding_right() const { return GetField(VT_PADDING_RIGHT, 0); } int32_t padding_top() const { return GetField(VT_PADDING_TOP, 0); } int32_t padding_bottom() const { return GetField(VT_PADDING_BOTTOM, 0); } int32_t dilation_height() const { return GetField(VT_DILATION_HEIGHT, 0); } int32_t dilation_width() const { return GetField(VT_DILATION_WIDTH, 0); } bool ceil_mode() const { return GetField(VT_CEIL_MODE, 0) != 0; } bool count_include_pad() const { return GetField(VT_COUNT_INCLUDE_PAD, 0) != 0; } int32_t divisor_override() const { return GetField(VT_DIVISOR_OVERRIDE, 0); } int32_t output1_id() const { return GetField(VT_OUTPUT1_ID, 0); } int32_t output2_id() const { return GetField(VT_OUTPUT2_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_KERNEL_HEIGHT, 4) && VerifyField(verifier, VT_KERNEL_WIDTH, 4) && VerifyField(verifier, VT_STRIDE_HEIGHT, 4) && VerifyField(verifier, VT_STRIDE_WIDTH, 4) && VerifyField(verifier, VT_PADDING_LEFT, 4) && VerifyField(verifier, VT_PADDING_RIGHT, 4) && VerifyField(verifier, VT_PADDING_TOP, 4) && VerifyField(verifier, VT_PADDING_BOTTOM, 4) && VerifyField(verifier, VT_DILATION_HEIGHT, 4) && VerifyField(verifier, VT_DILATION_WIDTH, 4) && VerifyField(verifier, VT_CEIL_MODE, 1) && VerifyField(verifier, VT_COUNT_INCLUDE_PAD, 1) && VerifyField(verifier, VT_DIVISOR_OVERRIDE, 4) && VerifyField(verifier, VT_OUTPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT2_ID, 4) && verifier.EndTable(); } }; struct MPSPooling2DBuilder { typedef MPSPooling2D Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSPooling2D::VT_INPUT1_ID, input1_id, 0); } void add_kernel_height(int32_t kernel_height) { fbb_.AddElement(MPSPooling2D::VT_KERNEL_HEIGHT, kernel_height, 0); } void add_kernel_width(int32_t kernel_width) { fbb_.AddElement(MPSPooling2D::VT_KERNEL_WIDTH, kernel_width, 0); } void add_stride_height(int32_t stride_height) { fbb_.AddElement(MPSPooling2D::VT_STRIDE_HEIGHT, stride_height, 0); } void add_stride_width(int32_t stride_width) { fbb_.AddElement(MPSPooling2D::VT_STRIDE_WIDTH, stride_width, 0); } void add_padding_left(int32_t padding_left) { fbb_.AddElement(MPSPooling2D::VT_PADDING_LEFT, padding_left, 0); } void add_padding_right(int32_t padding_right) { fbb_.AddElement(MPSPooling2D::VT_PADDING_RIGHT, padding_right, 0); } void add_padding_top(int32_t padding_top) { fbb_.AddElement(MPSPooling2D::VT_PADDING_TOP, padding_top, 0); } void add_padding_bottom(int32_t padding_bottom) { fbb_.AddElement(MPSPooling2D::VT_PADDING_BOTTOM, padding_bottom, 0); } void add_dilation_height(int32_t dilation_height) { fbb_.AddElement(MPSPooling2D::VT_DILATION_HEIGHT, dilation_height, 0); } void add_dilation_width(int32_t dilation_width) { fbb_.AddElement(MPSPooling2D::VT_DILATION_WIDTH, dilation_width, 0); } void add_ceil_mode(bool ceil_mode) { fbb_.AddElement(MPSPooling2D::VT_CEIL_MODE, static_cast(ceil_mode), 0); } void add_count_include_pad(bool count_include_pad) { fbb_.AddElement(MPSPooling2D::VT_COUNT_INCLUDE_PAD, static_cast(count_include_pad), 0); } void add_divisor_override(int32_t divisor_override) { fbb_.AddElement(MPSPooling2D::VT_DIVISOR_OVERRIDE, divisor_override, 0); } void add_output1_id(int32_t output1_id) { fbb_.AddElement(MPSPooling2D::VT_OUTPUT1_ID, output1_id, 0); } void add_output2_id(int32_t output2_id) { fbb_.AddElement(MPSPooling2D::VT_OUTPUT2_ID, output2_id, 0); } explicit MPSPooling2DBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSPooling2D( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t kernel_height = 0, int32_t kernel_width = 0, int32_t stride_height = 0, int32_t stride_width = 0, int32_t padding_left = 0, int32_t padding_right = 0, int32_t padding_top = 0, int32_t padding_bottom = 0, int32_t dilation_height = 0, int32_t dilation_width = 0, bool ceil_mode = false, bool count_include_pad = false, int32_t divisor_override = 0, int32_t output1_id = 0, int32_t output2_id = 0) { MPSPooling2DBuilder builder_(_fbb); builder_.add_output2_id(output2_id); builder_.add_output1_id(output1_id); builder_.add_divisor_override(divisor_override); builder_.add_dilation_width(dilation_width); builder_.add_dilation_height(dilation_height); builder_.add_padding_bottom(padding_bottom); builder_.add_padding_top(padding_top); builder_.add_padding_right(padding_right); builder_.add_padding_left(padding_left); builder_.add_stride_width(stride_width); builder_.add_stride_height(stride_height); builder_.add_kernel_width(kernel_width); builder_.add_kernel_height(kernel_height); builder_.add_input1_id(input1_id); builder_.add_count_include_pad(count_include_pad); builder_.add_ceil_mode(ceil_mode); return builder_.Finish(); } struct MPSHardTanh FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSHardTanhBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_MIN_VALUE = 8, VT_MAX_VALUE = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } float min_value() const { return GetField(VT_MIN_VALUE, 0.0f); } float max_value() const { return GetField(VT_MAX_VALUE, 0.0f); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_MIN_VALUE, 4) && VerifyField(verifier, VT_MAX_VALUE, 4) && verifier.EndTable(); } }; struct MPSHardTanhBuilder { typedef MPSHardTanh Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSHardTanh::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSHardTanh::VT_OUTPUT_ID, output_id, 0); } void add_min_value(float min_value) { fbb_.AddElement(MPSHardTanh::VT_MIN_VALUE, min_value, 0.0f); } void add_max_value(float max_value) { fbb_.AddElement(MPSHardTanh::VT_MAX_VALUE, max_value, 0.0f); } explicit MPSHardTanhBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSHardTanh( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, float min_value = 0.0f, float max_value = 0.0f) { MPSHardTanhBuilder builder_(_fbb); builder_.add_max_value(max_value); builder_.add_min_value(min_value); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSGELU FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSGELUBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_APPROXIMATE = 8 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } const ::flatbuffers::String *approximate() const { return GetPointer(VT_APPROXIMATE); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyOffset(verifier, VT_APPROXIMATE) && verifier.VerifyString(approximate()) && verifier.EndTable(); } }; struct MPSGELUBuilder { typedef MPSGELU Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSGELU::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSGELU::VT_OUTPUT_ID, output_id, 0); } void add_approximate(::flatbuffers::Offset<::flatbuffers::String> approximate) { fbb_.AddOffset(MPSGELU::VT_APPROXIMATE, approximate); } explicit MPSGELUBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSGELU( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, ::flatbuffers::Offset<::flatbuffers::String> approximate = 0) { MPSGELUBuilder builder_(_fbb); builder_.add_approximate(approximate); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSGELUDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, const char *approximate = nullptr) { auto approximate__ = approximate ? _fbb.CreateString(approximate) : 0; return mpsgraph::CreateMPSGELU( _fbb, input1_id, output_id, approximate__); } struct MPSLeakyReLU FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSLeakyReLUBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_NEGATIVE_SLOPE = 8 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } float negative_slope() const { return GetField(VT_NEGATIVE_SLOPE, 0.0f); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_NEGATIVE_SLOPE, 4) && verifier.EndTable(); } }; struct MPSLeakyReLUBuilder { typedef MPSLeakyReLU Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSLeakyReLU::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSLeakyReLU::VT_OUTPUT_ID, output_id, 0); } void add_negative_slope(float negative_slope) { fbb_.AddElement(MPSLeakyReLU::VT_NEGATIVE_SLOPE, negative_slope, 0.0f); } explicit MPSLeakyReLUBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSLeakyReLU( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, float negative_slope = 0.0f) { MPSLeakyReLUBuilder builder_(_fbb); builder_.add_negative_slope(negative_slope); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSSoftmax FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSSoftmaxBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_DIM = 8, VT_HALF_TO_FLOAT = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t dim() const { return GetField(VT_DIM, 0); } bool half_to_float() const { return GetField(VT_HALF_TO_FLOAT, 0) != 0; } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_DIM, 4) && VerifyField(verifier, VT_HALF_TO_FLOAT, 1) && verifier.EndTable(); } }; struct MPSSoftmaxBuilder { typedef MPSSoftmax Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSSoftmax::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSSoftmax::VT_OUTPUT_ID, output_id, 0); } void add_dim(int32_t dim) { fbb_.AddElement(MPSSoftmax::VT_DIM, dim, 0); } void add_half_to_float(bool half_to_float) { fbb_.AddElement(MPSSoftmax::VT_HALF_TO_FLOAT, static_cast(half_to_float), 0); } explicit MPSSoftmaxBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSSoftmax( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t dim = 0, bool half_to_float = false) { MPSSoftmaxBuilder builder_(_fbb); builder_.add_dim(dim); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); builder_.add_half_to_float(half_to_float); return builder_.Finish(); } struct MPSClamp FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSClampBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && verifier.EndTable(); } }; struct MPSClampBuilder { typedef MPSClamp Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSClamp::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSClamp::VT_OUTPUT_ID, output_id, 0); } explicit MPSClampBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSClamp( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0) { MPSClampBuilder builder_(_fbb); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSMean FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSMeanBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_NUM_DIMS = 8, VT_DIMS = 10, VT_KEEP_DIMS = 12 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t num_dims() const { return GetField(VT_NUM_DIMS, 0); } const ::flatbuffers::Vector *dims() const { return GetPointer *>(VT_DIMS); } bool keep_dims() const { return GetField(VT_KEEP_DIMS, 0) != 0; } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_NUM_DIMS, 4) && VerifyOffset(verifier, VT_DIMS) && verifier.VerifyVector(dims()) && VerifyField(verifier, VT_KEEP_DIMS, 1) && verifier.EndTable(); } }; struct MPSMeanBuilder { typedef MPSMean Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSMean::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSMean::VT_OUTPUT_ID, output_id, 0); } void add_num_dims(int32_t num_dims) { fbb_.AddElement(MPSMean::VT_NUM_DIMS, num_dims, 0); } void add_dims(::flatbuffers::Offset<::flatbuffers::Vector> dims) { fbb_.AddOffset(MPSMean::VT_DIMS, dims); } void add_keep_dims(bool keep_dims) { fbb_.AddElement(MPSMean::VT_KEEP_DIMS, static_cast(keep_dims), 0); } explicit MPSMeanBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSMean( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t num_dims = 0, ::flatbuffers::Offset<::flatbuffers::Vector> dims = 0, bool keep_dims = false) { MPSMeanBuilder builder_(_fbb); builder_.add_dims(dims); builder_.add_num_dims(num_dims); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); builder_.add_keep_dims(keep_dims); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSMeanDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t num_dims = 0, const std::vector *dims = nullptr, bool keep_dims = false) { auto dims__ = dims ? _fbb.CreateVector(*dims) : 0; return mpsgraph::CreateMPSMean( _fbb, input1_id, output_id, num_dims, dims__, keep_dims); } struct MPSIndexSelect FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSIndexSelectBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_DIM = 8, VT_INDEX_ID = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t dim() const { return GetField(VT_DIM, 0); } int32_t index_id() const { return GetField(VT_INDEX_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_DIM, 4) && VerifyField(verifier, VT_INDEX_ID, 4) && verifier.EndTable(); } }; struct MPSIndexSelectBuilder { typedef MPSIndexSelect Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSIndexSelect::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSIndexSelect::VT_OUTPUT_ID, output_id, 0); } void add_dim(int32_t dim) { fbb_.AddElement(MPSIndexSelect::VT_DIM, dim, 0); } void add_index_id(int32_t index_id) { fbb_.AddElement(MPSIndexSelect::VT_INDEX_ID, index_id, 0); } explicit MPSIndexSelectBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSIndexSelect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t dim = 0, int32_t index_id = 0) { MPSIndexSelectBuilder builder_(_fbb); builder_.add_index_id(index_id); builder_.add_dim(dim); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSEmbedding FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSEmbeddingBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_INPUT2_ID = 6, VT_OUTPUT_ID = 8, VT_PADDING_IDX = 10, VT_SCALE_GRAD_BY_FREQ = 12, VT_SPARSE = 14 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t input2_id() const { return GetField(VT_INPUT2_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t padding_idx() const { return GetField(VT_PADDING_IDX, 0); } bool scale_grad_by_freq() const { return GetField(VT_SCALE_GRAD_BY_FREQ, 0) != 0; } bool sparse() const { return GetField(VT_SPARSE, 0) != 0; } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_INPUT2_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_PADDING_IDX, 4) && VerifyField(verifier, VT_SCALE_GRAD_BY_FREQ, 1) && VerifyField(verifier, VT_SPARSE, 1) && verifier.EndTable(); } }; struct MPSEmbeddingBuilder { typedef MPSEmbedding Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSEmbedding::VT_INPUT1_ID, input1_id, 0); } void add_input2_id(int32_t input2_id) { fbb_.AddElement(MPSEmbedding::VT_INPUT2_ID, input2_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSEmbedding::VT_OUTPUT_ID, output_id, 0); } void add_padding_idx(int32_t padding_idx) { fbb_.AddElement(MPSEmbedding::VT_PADDING_IDX, padding_idx, 0); } void add_scale_grad_by_freq(bool scale_grad_by_freq) { fbb_.AddElement(MPSEmbedding::VT_SCALE_GRAD_BY_FREQ, static_cast(scale_grad_by_freq), 0); } void add_sparse(bool sparse) { fbb_.AddElement(MPSEmbedding::VT_SPARSE, static_cast(sparse), 0); } explicit MPSEmbeddingBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSEmbedding( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t input2_id = 0, int32_t output_id = 0, int32_t padding_idx = 0, bool scale_grad_by_freq = false, bool sparse = false) { MPSEmbeddingBuilder builder_(_fbb); builder_.add_padding_idx(padding_idx); builder_.add_output_id(output_id); builder_.add_input2_id(input2_id); builder_.add_input1_id(input1_id); builder_.add_sparse(sparse); builder_.add_scale_grad_by_freq(scale_grad_by_freq); return builder_.Finish(); } struct MPSIndexTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSIndexTensorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_INDICES_ID = 6, VT_OUTPUT_ID = 8 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } const ::flatbuffers::Vector *indices_id() const { return GetPointer *>(VT_INDICES_ID); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyOffset(verifier, VT_INDICES_ID) && verifier.VerifyVector(indices_id()) && VerifyField(verifier, VT_OUTPUT_ID, 4) && verifier.EndTable(); } }; struct MPSIndexTensorBuilder { typedef MPSIndexTensor Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSIndexTensor::VT_INPUT1_ID, input1_id, 0); } void add_indices_id(::flatbuffers::Offset<::flatbuffers::Vector> indices_id) { fbb_.AddOffset(MPSIndexTensor::VT_INDICES_ID, indices_id); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSIndexTensor::VT_OUTPUT_ID, output_id, 0); } explicit MPSIndexTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSIndexTensor( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, ::flatbuffers::Offset<::flatbuffers::Vector> indices_id = 0, int32_t output_id = 0) { MPSIndexTensorBuilder builder_(_fbb); builder_.add_output_id(output_id); builder_.add_indices_id(indices_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSIndexTensorDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, const std::vector *indices_id = nullptr, int32_t output_id = 0) { auto indices_id__ = indices_id ? _fbb.CreateVector(*indices_id) : 0; return mpsgraph::CreateMPSIndexTensor( _fbb, input1_id, indices_id__, output_id); } struct MPSIndexPut FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSIndexPutBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_INDICES_ID = 6, VT_VALUES_SHAPE = 8, VT_VALUES_ID = 10, VT_OUTPUT_ID = 12 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } const ::flatbuffers::Vector *indices_id() const { return GetPointer *>(VT_INDICES_ID); } const ::flatbuffers::Vector *values_shape() const { return GetPointer *>(VT_VALUES_SHAPE); } int32_t values_id() const { return GetField(VT_VALUES_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyOffset(verifier, VT_INDICES_ID) && verifier.VerifyVector(indices_id()) && VerifyOffset(verifier, VT_VALUES_SHAPE) && verifier.VerifyVector(values_shape()) && VerifyField(verifier, VT_VALUES_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && verifier.EndTable(); } }; struct MPSIndexPutBuilder { typedef MPSIndexPut Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSIndexPut::VT_INPUT1_ID, input1_id, 0); } void add_indices_id(::flatbuffers::Offset<::flatbuffers::Vector> indices_id) { fbb_.AddOffset(MPSIndexPut::VT_INDICES_ID, indices_id); } void add_values_shape(::flatbuffers::Offset<::flatbuffers::Vector> values_shape) { fbb_.AddOffset(MPSIndexPut::VT_VALUES_SHAPE, values_shape); } void add_values_id(int32_t values_id) { fbb_.AddElement(MPSIndexPut::VT_VALUES_ID, values_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSIndexPut::VT_OUTPUT_ID, output_id, 0); } explicit MPSIndexPutBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSIndexPut( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, ::flatbuffers::Offset<::flatbuffers::Vector> indices_id = 0, ::flatbuffers::Offset<::flatbuffers::Vector> values_shape = 0, int32_t values_id = 0, int32_t output_id = 0) { MPSIndexPutBuilder builder_(_fbb); builder_.add_output_id(output_id); builder_.add_values_id(values_id); builder_.add_values_shape(values_shape); builder_.add_indices_id(indices_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSIndexPutDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, const std::vector *indices_id = nullptr, const std::vector *values_shape = nullptr, int32_t values_id = 0, int32_t output_id = 0) { auto indices_id__ = indices_id ? _fbb.CreateVector(*indices_id) : 0; auto values_shape__ = values_shape ? _fbb.CreateVector(*values_shape) : 0; return mpsgraph::CreateMPSIndexPut( _fbb, input1_id, indices_id__, values_shape__, values_id, output_id); } struct MPSScatter FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSScatterBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_DIM = 8, VT_IDX_ID = 10, VT_SRC_ID = 12 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int64_t dim() const { return GetField(VT_DIM, 0); } int32_t idx_id() const { return GetField(VT_IDX_ID, 0); } int32_t src_id() const { return GetField(VT_SRC_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_DIM, 8) && VerifyField(verifier, VT_IDX_ID, 4) && VerifyField(verifier, VT_SRC_ID, 4) && verifier.EndTable(); } }; struct MPSScatterBuilder { typedef MPSScatter Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSScatter::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSScatter::VT_OUTPUT_ID, output_id, 0); } void add_dim(int64_t dim) { fbb_.AddElement(MPSScatter::VT_DIM, dim, 0); } void add_idx_id(int32_t idx_id) { fbb_.AddElement(MPSScatter::VT_IDX_ID, idx_id, 0); } void add_src_id(int32_t src_id) { fbb_.AddElement(MPSScatter::VT_SRC_ID, src_id, 0); } explicit MPSScatterBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSScatter( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int64_t dim = 0, int32_t idx_id = 0, int32_t src_id = 0) { MPSScatterBuilder builder_(_fbb); builder_.add_dim(dim); builder_.add_src_id(src_id); builder_.add_idx_id(idx_id); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSPermute FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSPermuteBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_NUM_DIMS = 8, VT_PERM = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t num_dims() const { return GetField(VT_NUM_DIMS, 0); } const ::flatbuffers::Vector *perm() const { return GetPointer *>(VT_PERM); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_NUM_DIMS, 4) && VerifyOffset(verifier, VT_PERM) && verifier.VerifyVector(perm()) && verifier.EndTable(); } }; struct MPSPermuteBuilder { typedef MPSPermute Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSPermute::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSPermute::VT_OUTPUT_ID, output_id, 0); } void add_num_dims(int32_t num_dims) { fbb_.AddElement(MPSPermute::VT_NUM_DIMS, num_dims, 0); } void add_perm(::flatbuffers::Offset<::flatbuffers::Vector> perm) { fbb_.AddOffset(MPSPermute::VT_PERM, perm); } explicit MPSPermuteBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSPermute( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t num_dims = 0, ::flatbuffers::Offset<::flatbuffers::Vector> perm = 0) { MPSPermuteBuilder builder_(_fbb); builder_.add_perm(perm); builder_.add_num_dims(num_dims); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSPermuteDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t num_dims = 0, const std::vector *perm = nullptr) { auto perm__ = perm ? _fbb.CreateVector(*perm) : 0; return mpsgraph::CreateMPSPermute( _fbb, input1_id, output_id, num_dims, perm__); } struct MPSView FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSViewBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_NUM_DIMS = 8, VT_SHAPE = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t num_dims() const { return GetField(VT_NUM_DIMS, 0); } const ::flatbuffers::Vector *shape() const { return GetPointer *>(VT_SHAPE); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_NUM_DIMS, 4) && VerifyOffset(verifier, VT_SHAPE) && verifier.VerifyVector(shape()) && verifier.EndTable(); } }; struct MPSViewBuilder { typedef MPSView Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSView::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSView::VT_OUTPUT_ID, output_id, 0); } void add_num_dims(int32_t num_dims) { fbb_.AddElement(MPSView::VT_NUM_DIMS, num_dims, 0); } void add_shape(::flatbuffers::Offset<::flatbuffers::Vector> shape) { fbb_.AddOffset(MPSView::VT_SHAPE, shape); } explicit MPSViewBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSView( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t num_dims = 0, ::flatbuffers::Offset<::flatbuffers::Vector> shape = 0) { MPSViewBuilder builder_(_fbb); builder_.add_shape(shape); builder_.add_num_dims(num_dims); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSViewDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t num_dims = 0, const std::vector *shape = nullptr) { auto shape__ = shape ? _fbb.CreateVector(*shape) : 0; return mpsgraph::CreateMPSView( _fbb, input1_id, output_id, num_dims, shape__); } struct MPSCat FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSCatBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT_IDS = 4, VT_OUTPUT_ID = 6, VT_DIM = 8 }; const ::flatbuffers::Vector *input_ids() const { return GetPointer *>(VT_INPUT_IDS); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t dim() const { return GetField(VT_DIM, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_INPUT_IDS) && verifier.VerifyVector(input_ids()) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_DIM, 4) && verifier.EndTable(); } }; struct MPSCatBuilder { typedef MPSCat Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input_ids(::flatbuffers::Offset<::flatbuffers::Vector> input_ids) { fbb_.AddOffset(MPSCat::VT_INPUT_IDS, input_ids); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSCat::VT_OUTPUT_ID, output_id, 0); } void add_dim(int32_t dim) { fbb_.AddElement(MPSCat::VT_DIM, dim, 0); } explicit MPSCatBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSCat( ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset<::flatbuffers::Vector> input_ids = 0, int32_t output_id = 0, int32_t dim = 0) { MPSCatBuilder builder_(_fbb); builder_.add_dim(dim); builder_.add_output_id(output_id); builder_.add_input_ids(input_ids); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSCatDirect( ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *input_ids = nullptr, int32_t output_id = 0, int32_t dim = 0) { auto input_ids__ = input_ids ? _fbb.CreateVector(*input_ids) : 0; return mpsgraph::CreateMPSCat( _fbb, input_ids__, output_id, dim); } struct MPSSqueeze FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSSqueezeBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_DIMS = 8 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } const ::flatbuffers::Vector *dims() const { return GetPointer *>(VT_DIMS); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyOffset(verifier, VT_DIMS) && verifier.VerifyVector(dims()) && verifier.EndTable(); } }; struct MPSSqueezeBuilder { typedef MPSSqueeze Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSSqueeze::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSSqueeze::VT_OUTPUT_ID, output_id, 0); } void add_dims(::flatbuffers::Offset<::flatbuffers::Vector> dims) { fbb_.AddOffset(MPSSqueeze::VT_DIMS, dims); } explicit MPSSqueezeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSSqueeze( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, ::flatbuffers::Offset<::flatbuffers::Vector> dims = 0) { MPSSqueezeBuilder builder_(_fbb); builder_.add_dims(dims); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSSqueezeDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, const std::vector *dims = nullptr) { auto dims__ = dims ? _fbb.CreateVector(*dims) : 0; return mpsgraph::CreateMPSSqueeze( _fbb, input1_id, output_id, dims__); } struct MPSUnsqueeze FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSUnsqueezeBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_DIM = 8 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t dim() const { return GetField(VT_DIM, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_DIM, 4) && verifier.EndTable(); } }; struct MPSUnsqueezeBuilder { typedef MPSUnsqueeze Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSUnsqueeze::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSUnsqueeze::VT_OUTPUT_ID, output_id, 0); } void add_dim(int32_t dim) { fbb_.AddElement(MPSUnsqueeze::VT_DIM, dim, 0); } explicit MPSUnsqueezeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSUnsqueeze( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t dim = 0) { MPSUnsqueezeBuilder builder_(_fbb); builder_.add_dim(dim); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSSelect FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSSelectBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_DIM = 8, VT_INDEX = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t dim() const { return GetField(VT_DIM, 0); } int32_t index() const { return GetField(VT_INDEX, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_DIM, 4) && VerifyField(verifier, VT_INDEX, 4) && verifier.EndTable(); } }; struct MPSSelectBuilder { typedef MPSSelect Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSSelect::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSSelect::VT_OUTPUT_ID, output_id, 0); } void add_dim(int32_t dim) { fbb_.AddElement(MPSSelect::VT_DIM, dim, 0); } void add_index(int32_t index) { fbb_.AddElement(MPSSelect::VT_INDEX, index, 0); } explicit MPSSelectBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSSelect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t dim = 0, int32_t index = 0) { MPSSelectBuilder builder_(_fbb); builder_.add_index(index); builder_.add_dim(dim); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSSlice FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSSliceBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_DIM = 8, VT_START = 10, VT_END = 12, VT_STEP = 14 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int64_t dim() const { return GetField(VT_DIM, 0); } int64_t start() const { return GetField(VT_START, 0); } int64_t end() const { return GetField(VT_END, 0); } int64_t step() const { return GetField(VT_STEP, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_DIM, 8) && VerifyField(verifier, VT_START, 8) && VerifyField(verifier, VT_END, 8) && VerifyField(verifier, VT_STEP, 8) && verifier.EndTable(); } }; struct MPSSliceBuilder { typedef MPSSlice Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSSlice::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSSlice::VT_OUTPUT_ID, output_id, 0); } void add_dim(int64_t dim) { fbb_.AddElement(MPSSlice::VT_DIM, dim, 0); } void add_start(int64_t start) { fbb_.AddElement(MPSSlice::VT_START, start, 0); } void add_end(int64_t end) { fbb_.AddElement(MPSSlice::VT_END, end, 0); } void add_step(int64_t step) { fbb_.AddElement(MPSSlice::VT_STEP, step, 0); } explicit MPSSliceBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSSlice( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int64_t dim = 0, int64_t start = 0, int64_t end = 0, int64_t step = 0) { MPSSliceBuilder builder_(_fbb); builder_.add_step(step); builder_.add_end(end); builder_.add_start(start); builder_.add_dim(dim); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSPixelShuffle FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSPixelShuffleBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_UPSCALE_FACTOR = 8 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t upscale_factor() const { return GetField(VT_UPSCALE_FACTOR, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_UPSCALE_FACTOR, 4) && verifier.EndTable(); } }; struct MPSPixelShuffleBuilder { typedef MPSPixelShuffle Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSPixelShuffle::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSPixelShuffle::VT_OUTPUT_ID, output_id, 0); } void add_upscale_factor(int32_t upscale_factor) { fbb_.AddElement(MPSPixelShuffle::VT_UPSCALE_FACTOR, upscale_factor, 0); } explicit MPSPixelShuffleBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSPixelShuffle( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t upscale_factor = 0) { MPSPixelShuffleBuilder builder_(_fbb); builder_.add_upscale_factor(upscale_factor); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSSplitWithSizes FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSSplitWithSizesBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_IDS = 6, VT_SPLIT_SIZES = 8, VT_DIM = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } const ::flatbuffers::Vector *output_ids() const { return GetPointer *>(VT_OUTPUT_IDS); } const ::flatbuffers::Vector *split_sizes() const { return GetPointer *>(VT_SPLIT_SIZES); } int32_t dim() const { return GetField(VT_DIM, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyOffset(verifier, VT_OUTPUT_IDS) && verifier.VerifyVector(output_ids()) && VerifyOffset(verifier, VT_SPLIT_SIZES) && verifier.VerifyVector(split_sizes()) && VerifyField(verifier, VT_DIM, 4) && verifier.EndTable(); } }; struct MPSSplitWithSizesBuilder { typedef MPSSplitWithSizes Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSSplitWithSizes::VT_INPUT1_ID, input1_id, 0); } void add_output_ids(::flatbuffers::Offset<::flatbuffers::Vector> output_ids) { fbb_.AddOffset(MPSSplitWithSizes::VT_OUTPUT_IDS, output_ids); } void add_split_sizes(::flatbuffers::Offset<::flatbuffers::Vector> split_sizes) { fbb_.AddOffset(MPSSplitWithSizes::VT_SPLIT_SIZES, split_sizes); } void add_dim(int32_t dim) { fbb_.AddElement(MPSSplitWithSizes::VT_DIM, dim, 0); } explicit MPSSplitWithSizesBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSSplitWithSizes( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, ::flatbuffers::Offset<::flatbuffers::Vector> output_ids = 0, ::flatbuffers::Offset<::flatbuffers::Vector> split_sizes = 0, int32_t dim = 0) { MPSSplitWithSizesBuilder builder_(_fbb); builder_.add_dim(dim); builder_.add_split_sizes(split_sizes); builder_.add_output_ids(output_ids); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSSplitWithSizesDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, const std::vector *output_ids = nullptr, const std::vector *split_sizes = nullptr, int32_t dim = 0) { auto output_ids__ = output_ids ? _fbb.CreateVector(*output_ids) : 0; auto split_sizes__ = split_sizes ? _fbb.CreateVector(*split_sizes) : 0; return mpsgraph::CreateMPSSplitWithSizes( _fbb, input1_id, output_ids__, split_sizes__, dim); } struct MPSCast FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSCastBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_DTYPE = 8 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } mpsgraph::MPSDataType dtype() const { return static_cast(GetField(VT_DTYPE, 0)); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_DTYPE, 2) && verifier.EndTable(); } }; struct MPSCastBuilder { typedef MPSCast Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSCast::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSCast::VT_OUTPUT_ID, output_id, 0); } void add_dtype(mpsgraph::MPSDataType dtype) { fbb_.AddElement(MPSCast::VT_DTYPE, static_cast(dtype), 0); } explicit MPSCastBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSCast( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, mpsgraph::MPSDataType dtype = mpsgraph::MPSDataType_mps_data_type_invalid) { MPSCastBuilder builder_(_fbb); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); builder_.add_dtype(dtype); return builder_.Finish(); } struct MPSAddmm FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSAddmmBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_INPUT2_ID = 6, VT_INPUT3_ID = 8, VT_OUTPUT_ID = 10, VT_BETA = 12, VT_ALPHA = 14 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t input2_id() const { return GetField(VT_INPUT2_ID, 0); } int32_t input3_id() const { return GetField(VT_INPUT3_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } float beta() const { return GetField(VT_BETA, 0.0f); } float alpha() const { return GetField(VT_ALPHA, 0.0f); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_INPUT2_ID, 4) && VerifyField(verifier, VT_INPUT3_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_BETA, 4) && VerifyField(verifier, VT_ALPHA, 4) && verifier.EndTable(); } }; struct MPSAddmmBuilder { typedef MPSAddmm Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSAddmm::VT_INPUT1_ID, input1_id, 0); } void add_input2_id(int32_t input2_id) { fbb_.AddElement(MPSAddmm::VT_INPUT2_ID, input2_id, 0); } void add_input3_id(int32_t input3_id) { fbb_.AddElement(MPSAddmm::VT_INPUT3_ID, input3_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSAddmm::VT_OUTPUT_ID, output_id, 0); } void add_beta(float beta) { fbb_.AddElement(MPSAddmm::VT_BETA, beta, 0.0f); } void add_alpha(float alpha) { fbb_.AddElement(MPSAddmm::VT_ALPHA, alpha, 0.0f); } explicit MPSAddmmBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSAddmm( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t input2_id = 0, int32_t input3_id = 0, int32_t output_id = 0, float beta = 0.0f, float alpha = 0.0f) { MPSAddmmBuilder builder_(_fbb); builder_.add_alpha(alpha); builder_.add_beta(beta); builder_.add_output_id(output_id); builder_.add_input3_id(input3_id); builder_.add_input2_id(input2_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct _MPSFull FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef _MPSFullBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_SHAPE = 8, VT_FILL_VALUE = 10, VT_DTYPE = 12 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } const ::flatbuffers::Vector *shape() const { return GetPointer *>(VT_SHAPE); } float fill_value() const { return GetField(VT_FILL_VALUE, 0.0f); } mpsgraph::MPSDataType dtype() const { return static_cast(GetField(VT_DTYPE, 0)); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyOffset(verifier, VT_SHAPE) && verifier.VerifyVector(shape()) && VerifyField(verifier, VT_FILL_VALUE, 4) && VerifyField(verifier, VT_DTYPE, 2) && verifier.EndTable(); } }; struct _MPSFullBuilder { typedef _MPSFull Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(_MPSFull::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(_MPSFull::VT_OUTPUT_ID, output_id, 0); } void add_shape(::flatbuffers::Offset<::flatbuffers::Vector> shape) { fbb_.AddOffset(_MPSFull::VT_SHAPE, shape); } void add_fill_value(float fill_value) { fbb_.AddElement(_MPSFull::VT_FILL_VALUE, fill_value, 0.0f); } void add_dtype(mpsgraph::MPSDataType dtype) { fbb_.AddElement(_MPSFull::VT_DTYPE, static_cast(dtype), 0); } explicit _MPSFullBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset<_MPSFull> Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset<_MPSFull>(end); return o; } }; inline ::flatbuffers::Offset<_MPSFull> Create_MPSFull( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, ::flatbuffers::Offset<::flatbuffers::Vector> shape = 0, float fill_value = 0.0f, mpsgraph::MPSDataType dtype = mpsgraph::MPSDataType_mps_data_type_invalid) { _MPSFullBuilder builder_(_fbb); builder_.add_fill_value(fill_value); builder_.add_shape(shape); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); builder_.add_dtype(dtype); return builder_.Finish(); } inline ::flatbuffers::Offset<_MPSFull> Create_MPSFullDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, const std::vector *shape = nullptr, float fill_value = 0.0f, mpsgraph::MPSDataType dtype = mpsgraph::MPSDataType_mps_data_type_invalid) { auto shape__ = shape ? _fbb.CreateVector(*shape) : 0; return mpsgraph::Create_MPSFull( _fbb, input1_id, output_id, shape__, fill_value, dtype); } struct MPSConv FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSConvBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_INPUT2_ID = 6, VT_INPUT3_ID = 8, VT_OUTPUT_ID = 10, VT_STRIDE_X = 12, VT_STRIDE_Y = 14, VT_DILATION_X = 16, VT_DILATION_Y = 18, VT_GROUPS = 20, VT_PADDING_LEFT = 22, VT_PADDING_RIGHT = 24, VT_PADDING_TOP = 26, VT_PADDING_BOTTOM = 28 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t input2_id() const { return GetField(VT_INPUT2_ID, 0); } int32_t input3_id() const { return GetField(VT_INPUT3_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t stride_x() const { return GetField(VT_STRIDE_X, 0); } int32_t stride_y() const { return GetField(VT_STRIDE_Y, 0); } int32_t dilation_x() const { return GetField(VT_DILATION_X, 0); } int32_t dilation_y() const { return GetField(VT_DILATION_Y, 0); } int32_t groups() const { return GetField(VT_GROUPS, 0); } int32_t padding_left() const { return GetField(VT_PADDING_LEFT, 0); } int32_t padding_right() const { return GetField(VT_PADDING_RIGHT, 0); } int32_t padding_top() const { return GetField(VT_PADDING_TOP, 0); } int32_t padding_bottom() const { return GetField(VT_PADDING_BOTTOM, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_INPUT2_ID, 4) && VerifyField(verifier, VT_INPUT3_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_STRIDE_X, 4) && VerifyField(verifier, VT_STRIDE_Y, 4) && VerifyField(verifier, VT_DILATION_X, 4) && VerifyField(verifier, VT_DILATION_Y, 4) && VerifyField(verifier, VT_GROUPS, 4) && VerifyField(verifier, VT_PADDING_LEFT, 4) && VerifyField(verifier, VT_PADDING_RIGHT, 4) && VerifyField(verifier, VT_PADDING_TOP, 4) && VerifyField(verifier, VT_PADDING_BOTTOM, 4) && verifier.EndTable(); } }; struct MPSConvBuilder { typedef MPSConv Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSConv::VT_INPUT1_ID, input1_id, 0); } void add_input2_id(int32_t input2_id) { fbb_.AddElement(MPSConv::VT_INPUT2_ID, input2_id, 0); } void add_input3_id(int32_t input3_id) { fbb_.AddElement(MPSConv::VT_INPUT3_ID, input3_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSConv::VT_OUTPUT_ID, output_id, 0); } void add_stride_x(int32_t stride_x) { fbb_.AddElement(MPSConv::VT_STRIDE_X, stride_x, 0); } void add_stride_y(int32_t stride_y) { fbb_.AddElement(MPSConv::VT_STRIDE_Y, stride_y, 0); } void add_dilation_x(int32_t dilation_x) { fbb_.AddElement(MPSConv::VT_DILATION_X, dilation_x, 0); } void add_dilation_y(int32_t dilation_y) { fbb_.AddElement(MPSConv::VT_DILATION_Y, dilation_y, 0); } void add_groups(int32_t groups) { fbb_.AddElement(MPSConv::VT_GROUPS, groups, 0); } void add_padding_left(int32_t padding_left) { fbb_.AddElement(MPSConv::VT_PADDING_LEFT, padding_left, 0); } void add_padding_right(int32_t padding_right) { fbb_.AddElement(MPSConv::VT_PADDING_RIGHT, padding_right, 0); } void add_padding_top(int32_t padding_top) { fbb_.AddElement(MPSConv::VT_PADDING_TOP, padding_top, 0); } void add_padding_bottom(int32_t padding_bottom) { fbb_.AddElement(MPSConv::VT_PADDING_BOTTOM, padding_bottom, 0); } explicit MPSConvBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSConv( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t input2_id = 0, int32_t input3_id = 0, int32_t output_id = 0, int32_t stride_x = 0, int32_t stride_y = 0, int32_t dilation_x = 0, int32_t dilation_y = 0, int32_t groups = 0, int32_t padding_left = 0, int32_t padding_right = 0, int32_t padding_top = 0, int32_t padding_bottom = 0) { MPSConvBuilder builder_(_fbb); builder_.add_padding_bottom(padding_bottom); builder_.add_padding_top(padding_top); builder_.add_padding_right(padding_right); builder_.add_padding_left(padding_left); builder_.add_groups(groups); builder_.add_dilation_y(dilation_y); builder_.add_dilation_x(dilation_x); builder_.add_stride_y(stride_y); builder_.add_stride_x(stride_x); builder_.add_output_id(output_id); builder_.add_input3_id(input3_id); builder_.add_input2_id(input2_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } struct MPSBatchNorm FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSBatchNormBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT_ID = 4, VT_MEAN_ID = 6, VT_VAR_ID = 8, VT_WEIGHT_ID = 10, VT_BIAS_ID = 12, VT_MOMENTUM = 14, VT_EPSILON = 16, VT_OUTPUT2_ID = 18, VT_OUTPUT1_ID = 20, VT_OUTPUT3_ID = 22 }; int32_t input_id() const { return GetField(VT_INPUT_ID, 0); } int32_t mean_id() const { return GetField(VT_MEAN_ID, 0); } int32_t var_id() const { return GetField(VT_VAR_ID, 0); } int32_t weight_id() const { return GetField(VT_WEIGHT_ID, 0); } int32_t bias_id() const { return GetField(VT_BIAS_ID, 0); } float momentum() const { return GetField(VT_MOMENTUM, 0.0f); } float epsilon() const { return GetField(VT_EPSILON, 0.0f); } int32_t output2_id() const { return GetField(VT_OUTPUT2_ID, 0); } int32_t output1_id() const { return GetField(VT_OUTPUT1_ID, 0); } int32_t output3_id() const { return GetField(VT_OUTPUT3_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT_ID, 4) && VerifyField(verifier, VT_MEAN_ID, 4) && VerifyField(verifier, VT_VAR_ID, 4) && VerifyField(verifier, VT_WEIGHT_ID, 4) && VerifyField(verifier, VT_BIAS_ID, 4) && VerifyField(verifier, VT_MOMENTUM, 4) && VerifyField(verifier, VT_EPSILON, 4) && VerifyField(verifier, VT_OUTPUT2_ID, 4) && VerifyField(verifier, VT_OUTPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT3_ID, 4) && verifier.EndTable(); } }; struct MPSBatchNormBuilder { typedef MPSBatchNorm Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input_id(int32_t input_id) { fbb_.AddElement(MPSBatchNorm::VT_INPUT_ID, input_id, 0); } void add_mean_id(int32_t mean_id) { fbb_.AddElement(MPSBatchNorm::VT_MEAN_ID, mean_id, 0); } void add_var_id(int32_t var_id) { fbb_.AddElement(MPSBatchNorm::VT_VAR_ID, var_id, 0); } void add_weight_id(int32_t weight_id) { fbb_.AddElement(MPSBatchNorm::VT_WEIGHT_ID, weight_id, 0); } void add_bias_id(int32_t bias_id) { fbb_.AddElement(MPSBatchNorm::VT_BIAS_ID, bias_id, 0); } void add_momentum(float momentum) { fbb_.AddElement(MPSBatchNorm::VT_MOMENTUM, momentum, 0.0f); } void add_epsilon(float epsilon) { fbb_.AddElement(MPSBatchNorm::VT_EPSILON, epsilon, 0.0f); } void add_output2_id(int32_t output2_id) { fbb_.AddElement(MPSBatchNorm::VT_OUTPUT2_ID, output2_id, 0); } void add_output1_id(int32_t output1_id) { fbb_.AddElement(MPSBatchNorm::VT_OUTPUT1_ID, output1_id, 0); } void add_output3_id(int32_t output3_id) { fbb_.AddElement(MPSBatchNorm::VT_OUTPUT3_ID, output3_id, 0); } explicit MPSBatchNormBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSBatchNorm( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input_id = 0, int32_t mean_id = 0, int32_t var_id = 0, int32_t weight_id = 0, int32_t bias_id = 0, float momentum = 0.0f, float epsilon = 0.0f, int32_t output2_id = 0, int32_t output1_id = 0, int32_t output3_id = 0) { MPSBatchNormBuilder builder_(_fbb); builder_.add_output3_id(output3_id); builder_.add_output1_id(output1_id); builder_.add_output2_id(output2_id); builder_.add_epsilon(epsilon); builder_.add_momentum(momentum); builder_.add_bias_id(bias_id); builder_.add_weight_id(weight_id); builder_.add_var_id(var_id); builder_.add_mean_id(mean_id); builder_.add_input_id(input_id); return builder_.Finish(); } struct MPSLayerNorm FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSLayerNormBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_NORMALIZED_SHAPE = 6, VT_WEIGHT_ID = 8, VT_BIAS_ID = 10, VT_EPS = 12, VT_OUTPUT2_ID = 14, VT_OUTPUT1_ID = 16, VT_OUTPUT3_ID = 18 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } const ::flatbuffers::Vector *normalized_shape() const { return GetPointer *>(VT_NORMALIZED_SHAPE); } int32_t weight_id() const { return GetField(VT_WEIGHT_ID, 0); } int32_t bias_id() const { return GetField(VT_BIAS_ID, 0); } float eps() const { return GetField(VT_EPS, 0.0f); } int32_t output2_id() const { return GetField(VT_OUTPUT2_ID, 0); } int32_t output1_id() const { return GetField(VT_OUTPUT1_ID, 0); } int32_t output3_id() const { return GetField(VT_OUTPUT3_ID, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyOffset(verifier, VT_NORMALIZED_SHAPE) && verifier.VerifyVector(normalized_shape()) && VerifyField(verifier, VT_WEIGHT_ID, 4) && VerifyField(verifier, VT_BIAS_ID, 4) && VerifyField(verifier, VT_EPS, 4) && VerifyField(verifier, VT_OUTPUT2_ID, 4) && VerifyField(verifier, VT_OUTPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT3_ID, 4) && verifier.EndTable(); } }; struct MPSLayerNormBuilder { typedef MPSLayerNorm Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSLayerNorm::VT_INPUT1_ID, input1_id, 0); } void add_normalized_shape(::flatbuffers::Offset<::flatbuffers::Vector> normalized_shape) { fbb_.AddOffset(MPSLayerNorm::VT_NORMALIZED_SHAPE, normalized_shape); } void add_weight_id(int32_t weight_id) { fbb_.AddElement(MPSLayerNorm::VT_WEIGHT_ID, weight_id, 0); } void add_bias_id(int32_t bias_id) { fbb_.AddElement(MPSLayerNorm::VT_BIAS_ID, bias_id, 0); } void add_eps(float eps) { fbb_.AddElement(MPSLayerNorm::VT_EPS, eps, 0.0f); } void add_output2_id(int32_t output2_id) { fbb_.AddElement(MPSLayerNorm::VT_OUTPUT2_ID, output2_id, 0); } void add_output1_id(int32_t output1_id) { fbb_.AddElement(MPSLayerNorm::VT_OUTPUT1_ID, output1_id, 0); } void add_output3_id(int32_t output3_id) { fbb_.AddElement(MPSLayerNorm::VT_OUTPUT3_ID, output3_id, 0); } explicit MPSLayerNormBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSLayerNorm( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, ::flatbuffers::Offset<::flatbuffers::Vector> normalized_shape = 0, int32_t weight_id = 0, int32_t bias_id = 0, float eps = 0.0f, int32_t output2_id = 0, int32_t output1_id = 0, int32_t output3_id = 0) { MPSLayerNormBuilder builder_(_fbb); builder_.add_output3_id(output3_id); builder_.add_output1_id(output1_id); builder_.add_output2_id(output2_id); builder_.add_eps(eps); builder_.add_bias_id(bias_id); builder_.add_weight_id(weight_id); builder_.add_normalized_shape(normalized_shape); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSLayerNormDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, const std::vector *normalized_shape = nullptr, int32_t weight_id = 0, int32_t bias_id = 0, float eps = 0.0f, int32_t output2_id = 0, int32_t output1_id = 0, int32_t output3_id = 0) { auto normalized_shape__ = normalized_shape ? _fbb.CreateVector(*normalized_shape) : 0; return mpsgraph::CreateMPSLayerNorm( _fbb, input1_id, normalized_shape__, weight_id, bias_id, eps, output2_id, output1_id, output3_id); } struct MPSConstantPadND FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSConstantPadNDBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_PAD = 8, VT_VALUE = 10 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } const ::flatbuffers::Vector *pad() const { return GetPointer *>(VT_PAD); } float value() const { return GetField(VT_VALUE, 0.0f); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyOffset(verifier, VT_PAD) && verifier.VerifyVector(pad()) && VerifyField(verifier, VT_VALUE, 4) && verifier.EndTable(); } }; struct MPSConstantPadNDBuilder { typedef MPSConstantPadND Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSConstantPadND::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSConstantPadND::VT_OUTPUT_ID, output_id, 0); } void add_pad(::flatbuffers::Offset<::flatbuffers::Vector> pad) { fbb_.AddOffset(MPSConstantPadND::VT_PAD, pad); } void add_value(float value) { fbb_.AddElement(MPSConstantPadND::VT_VALUE, value, 0.0f); } explicit MPSConstantPadNDBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSConstantPadND( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, ::flatbuffers::Offset<::flatbuffers::Vector> pad = 0, float value = 0.0f) { MPSConstantPadNDBuilder builder_(_fbb); builder_.add_value(value); builder_.add_pad(pad); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSConstantPadNDDirect( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, const std::vector *pad = nullptr, float value = 0.0f) { auto pad__ = pad ? _fbb.CreateVector(*pad) : 0; return mpsgraph::CreateMPSConstantPadND( _fbb, input1_id, output_id, pad__, value); } struct MPSArange FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSArangeBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_OUTPUT_ID = 4, VT_START = 6, VT_END = 8, VT_STEP = 10, VT_DTYPE = 12 }; int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } float start() const { return GetField(VT_START, 0.0f); } float end() const { return GetField(VT_END, 0.0f); } float step() const { return GetField(VT_STEP, 0.0f); } mpsgraph::MPSDataType dtype() const { return static_cast(GetField(VT_DTYPE, 0)); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_START, 4) && VerifyField(verifier, VT_END, 4) && VerifyField(verifier, VT_STEP, 4) && VerifyField(verifier, VT_DTYPE, 2) && verifier.EndTable(); } }; struct MPSArangeBuilder { typedef MPSArange Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_output_id(int32_t output_id) { fbb_.AddElement(MPSArange::VT_OUTPUT_ID, output_id, 0); } void add_start(float start) { fbb_.AddElement(MPSArange::VT_START, start, 0.0f); } void add_end(float end) { fbb_.AddElement(MPSArange::VT_END, end, 0.0f); } void add_step(float step) { fbb_.AddElement(MPSArange::VT_STEP, step, 0.0f); } void add_dtype(mpsgraph::MPSDataType dtype) { fbb_.AddElement(MPSArange::VT_DTYPE, static_cast(dtype), 0); } explicit MPSArangeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSArange( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t output_id = 0, float start = 0.0f, float end = 0.0f, float step = 0.0f, mpsgraph::MPSDataType dtype = mpsgraph::MPSDataType_mps_data_type_invalid) { MPSArangeBuilder builder_(_fbb); builder_.add_step(step); builder_.add_end(end); builder_.add_start(start); builder_.add_output_id(output_id); builder_.add_dtype(dtype); return builder_.Finish(); } struct MPSDequantizePerChannelGroup FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSDequantizePerChannelGroupBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_INPUT1_ID = 4, VT_OUTPUT_ID = 6, VT_SCALES_ID = 8, VT_ZERO_POINTS_ID = 10, VT_QUANT_MIN = 12, VT_QUANT_MAX = 14, VT_DTYPE = 16, VT_GROUP_SIZE = 18, VT_OUTPUT_DTYPE = 20 }; int32_t input1_id() const { return GetField(VT_INPUT1_ID, 0); } int32_t output_id() const { return GetField(VT_OUTPUT_ID, 0); } int32_t scales_id() const { return GetField(VT_SCALES_ID, 0); } int32_t zero_points_id() const { return GetField(VT_ZERO_POINTS_ID, 0); } int32_t quant_min() const { return GetField(VT_QUANT_MIN, 0); } int32_t quant_max() const { return GetField(VT_QUANT_MAX, 0); } mpsgraph::MPSDataType dtype() const { return static_cast(GetField(VT_DTYPE, 0)); } int32_t group_size() const { return GetField(VT_GROUP_SIZE, 0); } mpsgraph::MPSDataType output_dtype() const { return static_cast(GetField(VT_OUTPUT_DTYPE, 0)); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_INPUT1_ID, 4) && VerifyField(verifier, VT_OUTPUT_ID, 4) && VerifyField(verifier, VT_SCALES_ID, 4) && VerifyField(verifier, VT_ZERO_POINTS_ID, 4) && VerifyField(verifier, VT_QUANT_MIN, 4) && VerifyField(verifier, VT_QUANT_MAX, 4) && VerifyField(verifier, VT_DTYPE, 2) && VerifyField(verifier, VT_GROUP_SIZE, 4) && VerifyField(verifier, VT_OUTPUT_DTYPE, 2) && verifier.EndTable(); } }; struct MPSDequantizePerChannelGroupBuilder { typedef MPSDequantizePerChannelGroup Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_input1_id(int32_t input1_id) { fbb_.AddElement(MPSDequantizePerChannelGroup::VT_INPUT1_ID, input1_id, 0); } void add_output_id(int32_t output_id) { fbb_.AddElement(MPSDequantizePerChannelGroup::VT_OUTPUT_ID, output_id, 0); } void add_scales_id(int32_t scales_id) { fbb_.AddElement(MPSDequantizePerChannelGroup::VT_SCALES_ID, scales_id, 0); } void add_zero_points_id(int32_t zero_points_id) { fbb_.AddElement(MPSDequantizePerChannelGroup::VT_ZERO_POINTS_ID, zero_points_id, 0); } void add_quant_min(int32_t quant_min) { fbb_.AddElement(MPSDequantizePerChannelGroup::VT_QUANT_MIN, quant_min, 0); } void add_quant_max(int32_t quant_max) { fbb_.AddElement(MPSDequantizePerChannelGroup::VT_QUANT_MAX, quant_max, 0); } void add_dtype(mpsgraph::MPSDataType dtype) { fbb_.AddElement(MPSDequantizePerChannelGroup::VT_DTYPE, static_cast(dtype), 0); } void add_group_size(int32_t group_size) { fbb_.AddElement(MPSDequantizePerChannelGroup::VT_GROUP_SIZE, group_size, 0); } void add_output_dtype(mpsgraph::MPSDataType output_dtype) { fbb_.AddElement(MPSDequantizePerChannelGroup::VT_OUTPUT_DTYPE, static_cast(output_dtype), 0); } explicit MPSDequantizePerChannelGroupBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSDequantizePerChannelGroup( ::flatbuffers::FlatBufferBuilder &_fbb, int32_t input1_id = 0, int32_t output_id = 0, int32_t scales_id = 0, int32_t zero_points_id = 0, int32_t quant_min = 0, int32_t quant_max = 0, mpsgraph::MPSDataType dtype = mpsgraph::MPSDataType_mps_data_type_invalid, int32_t group_size = 0, mpsgraph::MPSDataType output_dtype = mpsgraph::MPSDataType_mps_data_type_invalid) { MPSDequantizePerChannelGroupBuilder builder_(_fbb); builder_.add_group_size(group_size); builder_.add_quant_max(quant_max); builder_.add_quant_min(quant_min); builder_.add_zero_points_id(zero_points_id); builder_.add_scales_id(scales_id); builder_.add_output_id(output_id); builder_.add_input1_id(input1_id); builder_.add_output_dtype(output_dtype); builder_.add_dtype(dtype); return builder_.Finish(); } struct MPSNode FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSNodeBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_MPSNODE_UNION_TYPE = 4, VT_MPSNODE_UNION = 6, VT_MIN_MAX = 8 }; mpsgraph::MPSNodeUnion mpsnode_union_type() const { return static_cast(GetField(VT_MPSNODE_UNION_TYPE, 0)); } const void *mpsnode_union() const { return GetPointer(VT_MPSNODE_UNION); } const mpsgraph::MPSHardTanh *mpsnode_union_as_MPSHardTanh() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSHardTanh ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSReLU() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSReLU ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSGELU *mpsnode_union_as_MPSGELU() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSGELU ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSLeakyReLU *mpsnode_union_as_MPSLeakyReLU() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSLeakyReLU ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSSoftmax *mpsnode_union_as_MPSSoftmax() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSoftmax ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSSoftmax *mpsnode_union_as_MPSLogSoftmax() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSLogSoftmax ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNodeWithAlpha2x1 *mpsnode_union_as_MPSAdd() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAdd ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNodeWithAlpha2x1 *mpsnode_union_as_MPSSub() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSub ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSMul() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSMul ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSDivNode2x1 *mpsnode_union_as_MPSDiv() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSDiv ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSDivNode2x1 *mpsnode_union_as_MPSFmod() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSFmod ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSDivNode2x1 *mpsnode_union_as_MPSRemainder() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSRemainder ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSMin() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSMin ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSMax() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSMax ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSPow() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSPow ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSAtan2() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAtan2 ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSBitwiseAnd() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSBitwiseAnd ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSBitwiseOr() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSBitwiseOr ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSBitwiseXor() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSBitwiseXor ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSMinimum() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSMinimum ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSExp() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSExp ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSExp2() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSExp2 ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSReciprocal() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSReciprocal ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSSqrt() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSqrt ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSNeg() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSNeg ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSLog() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSLog ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSLog10() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSLog10 ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSLog2() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSLog2 ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSErf() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSErf ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSFloor() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSFloor ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSCeil() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSCeil ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSRsqrt() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSRsqrt ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSSigmoid() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSigmoid ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSSin() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSin ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSSign() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSign ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSCos() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSCos ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSTan() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSTan ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSAbs() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAbs ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSAsin() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAsin ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSAcos() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAcos ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSAtan() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAtan ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSSinh() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSinh ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSCosh() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSCosh ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSTanh() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSTanh ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSAsinh() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAsinh ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSAcosh() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAcosh ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSAtanh() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAtanh ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSBitwiseNot() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSBitwiseNot ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSIsnan() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSIsnan ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSIsinf() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSIsinf ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSRound() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSRound ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode1x1 *mpsnode_union_as_MPSLogicalNot() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSLogicalNot ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSMatMul() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSMatMul ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSAddmm *mpsnode_union_as_MPSAddmm() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAddmm ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSFull *mpsnode_union_as_MPSFull() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSFull ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSFull *mpsnode_union_as_MPSFullLike() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSFullLike ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSClamp *mpsnode_union_as_MPSClamp() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSClamp ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode3x1 *mpsnode_union_as_MPSWhere() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSWhere ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSIndexSelect *mpsnode_union_as_MPSIndexSelect() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSIndexSelect ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSEmbedding *mpsnode_union_as_MPSEmbedding() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSEmbedding ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSIndexTensor *mpsnode_union_as_MPSIndexTensor() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSIndexTensor ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSIndexPut *mpsnode_union_as_MPSIndexPut() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSIndexPut ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSScatter *mpsnode_union_as_MPSScatter() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSScatter ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSMean *mpsnode_union_as_MPSMean() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSMean ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSPermute *mpsnode_union_as_MPSPermute() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSPermute ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSView *mpsnode_union_as_MPSView() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSView ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSView *mpsnode_union_as_MPSExpand() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSExpand ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSCat *mpsnode_union_as_MPSCat() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSCat ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSSqueeze *mpsnode_union_as_MPSSqueeze() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSqueeze ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSUnsqueeze *mpsnode_union_as_MPSUnsqueeze() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSUnsqueeze ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSSelect *mpsnode_union_as_MPSSelect() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSelect ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSSlice *mpsnode_union_as_MPSSlice() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSlice ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSPixelShuffle *mpsnode_union_as_MPSPixelShuffle() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSPixelShuffle ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSSplitWithSizes *mpsnode_union_as_MPSSplitWithSizes() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSSplitWithSizes ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSCast *mpsnode_union_as_MPSCast() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSCast ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSConv *mpsnode_union_as_MPSConv2D() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSConv2D ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSConv *mpsnode_union_as_MPSDepthwiseConv2D() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSDepthwiseConv2D ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSEq() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSEq ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSNe() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSNe ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSGe() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSGe ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSGt() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSGt ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSLe() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSLe ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::_MPSNode2x1 *mpsnode_union_as_MPSLt() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSLt ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSBatchNorm *mpsnode_union_as_MPSBatchNorm() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSBatchNorm ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSLayerNorm *mpsnode_union_as_MPSLayerNorm() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSLayerNorm ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSPooling2D *mpsnode_union_as_MPSMaxPool2DWithIndices() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSMaxPool2DWithIndices ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSPooling2D *mpsnode_union_as_MPSAvgPool2D() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSAvgPool2D ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSConstantPadND *mpsnode_union_as_MPSConstantPadND() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSConstantPadND ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSArange *mpsnode_union_as_MPSArange() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSArange ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSDequantizePerChannelGroup *mpsnode_union_as_MPSDequantizePerChannelGroup() const { return mpsnode_union_type() == mpsgraph::MPSNodeUnion_MPSDequantizePerChannelGroup ? static_cast(mpsnode_union()) : nullptr; } const mpsgraph::MPSMinMax *min_max() const { return GetPointer(VT_MIN_MAX); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_MPSNODE_UNION_TYPE, 1) && VerifyOffset(verifier, VT_MPSNODE_UNION) && VerifyMPSNodeUnion(verifier, mpsnode_union(), mpsnode_union_type()) && VerifyOffset(verifier, VT_MIN_MAX) && verifier.VerifyTable(min_max()) && verifier.EndTable(); } }; struct MPSNodeBuilder { typedef MPSNode Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_mpsnode_union_type(mpsgraph::MPSNodeUnion mpsnode_union_type) { fbb_.AddElement(MPSNode::VT_MPSNODE_UNION_TYPE, static_cast(mpsnode_union_type), 0); } void add_mpsnode_union(::flatbuffers::Offset mpsnode_union) { fbb_.AddOffset(MPSNode::VT_MPSNODE_UNION, mpsnode_union); } void add_min_max(::flatbuffers::Offset min_max) { fbb_.AddOffset(MPSNode::VT_MIN_MAX, min_max); } explicit MPSNodeBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSNode( ::flatbuffers::FlatBufferBuilder &_fbb, mpsgraph::MPSNodeUnion mpsnode_union_type = mpsgraph::MPSNodeUnion_NONE, ::flatbuffers::Offset mpsnode_union = 0, ::flatbuffers::Offset min_max = 0) { MPSNodeBuilder builder_(_fbb); builder_.add_min_max(min_max); builder_.add_mpsnode_union(mpsnode_union); builder_.add_mpsnode_union_type(mpsnode_union_type); return builder_.Finish(); } struct Buffer FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef BufferBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_STORAGE = 4 }; const ::flatbuffers::Vector *storage() const { return GetPointer *>(VT_STORAGE); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_STORAGE) && verifier.VerifyVector(storage()) && verifier.EndTable(); } }; struct BufferBuilder { typedef Buffer Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_storage(::flatbuffers::Offset<::flatbuffers::Vector> storage) { fbb_.AddOffset(Buffer::VT_STORAGE, storage); } explicit BufferBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateBuffer( ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset<::flatbuffers::Vector> storage = 0) { BufferBuilder builder_(_fbb); builder_.add_storage(storage); return builder_.Finish(); } inline ::flatbuffers::Offset CreateBufferDirect( ::flatbuffers::FlatBufferBuilder &_fbb, const std::vector *storage = nullptr) { if (storage) { _fbb.ForceVectorAlignment(storage->size(), sizeof(uint8_t), 16); } auto storage__ = storage ? _fbb.CreateVector(*storage) : 0; return mpsgraph::CreateBuffer( _fbb, storage__); } struct MPSTensor FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSTensorBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_DATATYPE = 4, VT_NUM_DIMS = 6, VT_DIMS = 8, VT_CONSTANT_BUFFER_SIZE = 10, VT_CONSTANT_BUFFER = 12, VT_SEGMENT_OFFSET = 14 }; mpsgraph::MPSDataType datatype() const { return static_cast(GetField(VT_DATATYPE, 0)); } int32_t num_dims() const { return GetField(VT_NUM_DIMS, 0); } const ::flatbuffers::Vector *dims() const { return GetPointer *>(VT_DIMS); } uint64_t constant_buffer_size() const { return GetField(VT_CONSTANT_BUFFER_SIZE, 0); } const mpsgraph::Buffer *constant_buffer() const { return GetPointer(VT_CONSTANT_BUFFER); } uint64_t segment_offset() const { return GetField(VT_SEGMENT_OFFSET, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_DATATYPE, 2) && VerifyField(verifier, VT_NUM_DIMS, 4) && VerifyOffset(verifier, VT_DIMS) && verifier.VerifyVector(dims()) && VerifyField(verifier, VT_CONSTANT_BUFFER_SIZE, 8) && VerifyOffset(verifier, VT_CONSTANT_BUFFER) && verifier.VerifyTable(constant_buffer()) && VerifyField(verifier, VT_SEGMENT_OFFSET, 8) && verifier.EndTable(); } }; struct MPSTensorBuilder { typedef MPSTensor Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_datatype(mpsgraph::MPSDataType datatype) { fbb_.AddElement(MPSTensor::VT_DATATYPE, static_cast(datatype), 0); } void add_num_dims(int32_t num_dims) { fbb_.AddElement(MPSTensor::VT_NUM_DIMS, num_dims, 0); } void add_dims(::flatbuffers::Offset<::flatbuffers::Vector> dims) { fbb_.AddOffset(MPSTensor::VT_DIMS, dims); } void add_constant_buffer_size(uint64_t constant_buffer_size) { fbb_.AddElement(MPSTensor::VT_CONSTANT_BUFFER_SIZE, constant_buffer_size, 0); } void add_constant_buffer(::flatbuffers::Offset constant_buffer) { fbb_.AddOffset(MPSTensor::VT_CONSTANT_BUFFER, constant_buffer); } void add_segment_offset(uint64_t segment_offset) { fbb_.AddElement(MPSTensor::VT_SEGMENT_OFFSET, segment_offset, 0); } explicit MPSTensorBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSTensor( ::flatbuffers::FlatBufferBuilder &_fbb, mpsgraph::MPSDataType datatype = mpsgraph::MPSDataType_mps_data_type_invalid, int32_t num_dims = 0, ::flatbuffers::Offset<::flatbuffers::Vector> dims = 0, uint64_t constant_buffer_size = 0, ::flatbuffers::Offset constant_buffer = 0, uint64_t segment_offset = 0) { MPSTensorBuilder builder_(_fbb); builder_.add_segment_offset(segment_offset); builder_.add_constant_buffer_size(constant_buffer_size); builder_.add_constant_buffer(constant_buffer); builder_.add_dims(dims); builder_.add_num_dims(num_dims); builder_.add_datatype(datatype); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSTensorDirect( ::flatbuffers::FlatBufferBuilder &_fbb, mpsgraph::MPSDataType datatype = mpsgraph::MPSDataType_mps_data_type_invalid, int32_t num_dims = 0, const std::vector *dims = nullptr, uint64_t constant_buffer_size = 0, ::flatbuffers::Offset constant_buffer = 0, uint64_t segment_offset = 0) { auto dims__ = dims ? _fbb.CreateVector(*dims) : 0; return mpsgraph::CreateMPSTensor( _fbb, datatype, num_dims, dims__, constant_buffer_size, constant_buffer, segment_offset); } struct DataSegment FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef DataSegmentBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_OFFSET = 4, VT_SIZE = 6 }; uint64_t offset() const { return GetField(VT_OFFSET, 0); } uint64_t size() const { return GetField(VT_SIZE, 0); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyField(verifier, VT_OFFSET, 8) && VerifyField(verifier, VT_SIZE, 8) && verifier.EndTable(); } }; struct DataSegmentBuilder { typedef DataSegment Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_offset(uint64_t offset) { fbb_.AddElement(DataSegment::VT_OFFSET, offset, 0); } void add_size(uint64_t size) { fbb_.AddElement(DataSegment::VT_SIZE, size, 0); } explicit DataSegmentBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateDataSegment( ::flatbuffers::FlatBufferBuilder &_fbb, uint64_t offset = 0, uint64_t size = 0) { DataSegmentBuilder builder_(_fbb); builder_.add_size(size); builder_.add_offset(offset); return builder_.Finish(); } struct MPSGraph FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { typedef MPSGraphBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_VERSION = 4, VT_MPS_NODES = 6, VT_MPS_VALUES = 8, VT_INPUT_IDS = 10, VT_OUTPUT_IDS = 12, VT_CONSTANT_IDS = 14, VT_GRAPH_TYPE = 16, VT_CONSTANT_SEGMENT = 18 }; const ::flatbuffers::String *version() const { return GetPointer(VT_VERSION); } const ::flatbuffers::Vector<::flatbuffers::Offset> *mps_nodes() const { return GetPointer> *>(VT_MPS_NODES); } const ::flatbuffers::Vector<::flatbuffers::Offset> *mps_values() const { return GetPointer> *>(VT_MPS_VALUES); } const ::flatbuffers::Vector *input_ids() const { return GetPointer *>(VT_INPUT_IDS); } const ::flatbuffers::Vector *output_ids() const { return GetPointer *>(VT_OUTPUT_IDS); } const ::flatbuffers::Vector *constant_ids() const { return GetPointer *>(VT_CONSTANT_IDS); } mpsgraph::OpType graph_type() const { return static_cast(GetField(VT_GRAPH_TYPE, 0)); } const mpsgraph::DataSegment *constant_segment() const { return GetPointer(VT_CONSTANT_SEGMENT); } bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_VERSION) && verifier.VerifyString(version()) && VerifyOffset(verifier, VT_MPS_NODES) && verifier.VerifyVector(mps_nodes()) && verifier.VerifyVectorOfTables(mps_nodes()) && VerifyOffset(verifier, VT_MPS_VALUES) && verifier.VerifyVector(mps_values()) && verifier.VerifyVectorOfTables(mps_values()) && VerifyOffset(verifier, VT_INPUT_IDS) && verifier.VerifyVector(input_ids()) && VerifyOffset(verifier, VT_OUTPUT_IDS) && verifier.VerifyVector(output_ids()) && VerifyOffset(verifier, VT_CONSTANT_IDS) && verifier.VerifyVector(constant_ids()) && VerifyField(verifier, VT_GRAPH_TYPE, 2) && VerifyOffset(verifier, VT_CONSTANT_SEGMENT) && verifier.VerifyTable(constant_segment()) && verifier.EndTable(); } }; struct MPSGraphBuilder { typedef MPSGraph Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_version(::flatbuffers::Offset<::flatbuffers::String> version) { fbb_.AddOffset(MPSGraph::VT_VERSION, version); } void add_mps_nodes(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> mps_nodes) { fbb_.AddOffset(MPSGraph::VT_MPS_NODES, mps_nodes); } void add_mps_values(::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> mps_values) { fbb_.AddOffset(MPSGraph::VT_MPS_VALUES, mps_values); } void add_input_ids(::flatbuffers::Offset<::flatbuffers::Vector> input_ids) { fbb_.AddOffset(MPSGraph::VT_INPUT_IDS, input_ids); } void add_output_ids(::flatbuffers::Offset<::flatbuffers::Vector> output_ids) { fbb_.AddOffset(MPSGraph::VT_OUTPUT_IDS, output_ids); } void add_constant_ids(::flatbuffers::Offset<::flatbuffers::Vector> constant_ids) { fbb_.AddOffset(MPSGraph::VT_CONSTANT_IDS, constant_ids); } void add_graph_type(mpsgraph::OpType graph_type) { fbb_.AddElement(MPSGraph::VT_GRAPH_TYPE, static_cast(graph_type), 0); } void add_constant_segment(::flatbuffers::Offset constant_segment) { fbb_.AddOffset(MPSGraph::VT_CONSTANT_SEGMENT, constant_segment); } explicit MPSGraphBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); auto o = ::flatbuffers::Offset(end); return o; } }; inline ::flatbuffers::Offset CreateMPSGraph( ::flatbuffers::FlatBufferBuilder &_fbb, ::flatbuffers::Offset<::flatbuffers::String> version = 0, ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> mps_nodes = 0, ::flatbuffers::Offset<::flatbuffers::Vector<::flatbuffers::Offset>> mps_values = 0, ::flatbuffers::Offset<::flatbuffers::Vector> input_ids = 0, ::flatbuffers::Offset<::flatbuffers::Vector> output_ids = 0, ::flatbuffers::Offset<::flatbuffers::Vector> constant_ids = 0, mpsgraph::OpType graph_type = mpsgraph::OpType_mps_graph, ::flatbuffers::Offset constant_segment = 0) { MPSGraphBuilder builder_(_fbb); builder_.add_constant_segment(constant_segment); builder_.add_constant_ids(constant_ids); builder_.add_output_ids(output_ids); builder_.add_input_ids(input_ids); builder_.add_mps_values(mps_values); builder_.add_mps_nodes(mps_nodes); builder_.add_version(version); builder_.add_graph_type(graph_type); return builder_.Finish(); } inline ::flatbuffers::Offset CreateMPSGraphDirect( ::flatbuffers::FlatBufferBuilder &_fbb, const char *version = nullptr, const std::vector<::flatbuffers::Offset> *mps_nodes = nullptr, const std::vector<::flatbuffers::Offset> *mps_values = nullptr, const std::vector *input_ids = nullptr, const std::vector *output_ids = nullptr, const std::vector *constant_ids = nullptr, mpsgraph::OpType graph_type = mpsgraph::OpType_mps_graph, ::flatbuffers::Offset constant_segment = 0) { auto version__ = version ? _fbb.CreateString(version) : 0; auto mps_nodes__ = mps_nodes ? _fbb.CreateVector<::flatbuffers::Offset>(*mps_nodes) : 0; auto mps_values__ = mps_values ? _fbb.CreateVector<::flatbuffers::Offset>(*mps_values) : 0; auto input_ids__ = input_ids ? _fbb.CreateVector(*input_ids) : 0; auto output_ids__ = output_ids ? _fbb.CreateVector(*output_ids) : 0; auto constant_ids__ = constant_ids ? _fbb.CreateVector(*constant_ids) : 0; return mpsgraph::CreateMPSGraph( _fbb, version__, mps_nodes__, mps_values__, input_ids__, output_ids__, constant_ids__, graph_type, constant_segment); } inline bool VerifyMPSNodeUnion(::flatbuffers::Verifier &verifier, const void *obj, MPSNodeUnion type) { switch (type) { case MPSNodeUnion_NONE: { return true; } case MPSNodeUnion_MPSHardTanh: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSReLU: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSGELU: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSLeakyReLU: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSoftmax: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSLogSoftmax: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAdd: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSub: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSMul: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSDiv: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSFmod: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSRemainder: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSMin: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSMax: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSPow: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAtan2: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSBitwiseAnd: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSBitwiseOr: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSBitwiseXor: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSMinimum: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSExp: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSExp2: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSReciprocal: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSqrt: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSNeg: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSLog: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSLog10: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSLog2: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSErf: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSFloor: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSCeil: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSRsqrt: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSigmoid: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSin: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSign: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSCos: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSTan: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAbs: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAsin: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAcos: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAtan: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSinh: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSCosh: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSTanh: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAsinh: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAcosh: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAtanh: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSBitwiseNot: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSIsnan: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSIsinf: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSRound: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSLogicalNot: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSMatMul: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAddmm: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSFull: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSFullLike: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSClamp: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSWhere: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSIndexSelect: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSEmbedding: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSIndexTensor: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSIndexPut: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSScatter: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSMean: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSPermute: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSView: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSExpand: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSCat: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSqueeze: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSUnsqueeze: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSelect: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSlice: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSPixelShuffle: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSSplitWithSizes: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSCast: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSConv2D: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSDepthwiseConv2D: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSEq: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSNe: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSGe: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSGt: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSLe: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSLt: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSBatchNorm: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSLayerNorm: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSMaxPool2DWithIndices: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSAvgPool2D: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSConstantPadND: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSArange: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } case MPSNodeUnion_MPSDequantizePerChannelGroup: { auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } default: return true; } } inline bool VerifyMPSNodeUnionVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *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 (!VerifyMPSNodeUnion( verifier, values->Get(i), types->GetEnum(i))) { return false; } } return true; } inline const mpsgraph::MPSGraph *GetMPSGraph(const void *buf) { return ::flatbuffers::GetRoot(buf); } inline const mpsgraph::MPSGraph *GetSizePrefixedMPSGraph(const void *buf) { return ::flatbuffers::GetSizePrefixedRoot(buf); } inline const char *MPSGraphIdentifier() { return "MP00"; } inline bool MPSGraphBufferHasIdentifier(const void *buf) { return ::flatbuffers::BufferHasIdentifier( buf, MPSGraphIdentifier()); } inline bool SizePrefixedMPSGraphBufferHasIdentifier(const void *buf) { return ::flatbuffers::BufferHasIdentifier( buf, MPSGraphIdentifier(), true); } inline bool VerifyMPSGraphBuffer( ::flatbuffers::Verifier &verifier) { return verifier.VerifyBuffer(MPSGraphIdentifier()); } inline bool VerifySizePrefixedMPSGraphBuffer( ::flatbuffers::Verifier &verifier) { return verifier.VerifySizePrefixedBuffer(MPSGraphIdentifier()); } inline void FinishMPSGraphBuffer( ::flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::Offset root) { fbb.Finish(root, MPSGraphIdentifier()); } inline void FinishSizePrefixedMPSGraphBuffer( ::flatbuffers::FlatBufferBuilder &fbb, ::flatbuffers::Offset root) { fbb.FinishSizePrefixed(root, MPSGraphIdentifier()); } } // namespace mpsgraph #endif // FLATBUFFERS_GENERATED_MPSSCHEMA_MPSGRAPH_H_