Gitiles
Code Review Sign In
review.mlplatform.org / tosa / reference_model / e5e2676409a936431f87d31fb74d825257b20804 / . / serialization / tosa_generated.h
blob: 5bb21f319129c12b4702ab1a9f659326b8035d6d [file] [log] [blame]
Eric Kunzee5e26762020-10-13 16:11:07 -0700[diff] [blame^]1
2// Copyright (c) 2020, ARM Limited.
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
16// automatically generated by the FlatBuffers compiler, do not modify
17
18
19#ifndef FLATBUFFERS_GENERATED_TOSA_TOSA_H_
20#define FLATBUFFERS_GENERATED_TOSA_TOSA_H_
21
22#include "flatbuffers/flatbuffers.h"
23
24namespace tosa {
25
26struct Pool2dAttribute;
27
28struct Conv2dAttribute;
29
30struct TransposeConv2dAttribute;
31
32struct ReluNAttribute;
33
34struct AxisAttribute;
35
36struct ReshapeAttribute;
37
38struct SliceAttribute;
39
40struct TileAttribute;
41
42struct ResizeAttribute;
43
44struct ClampAttribute;
45
46struct RescaleAttribute;
47
48struct CustomAttribute;
49
50struct CondIfAttribute;
51
52struct WhileLoopAttribute;
53
54struct UnaryQuantInfo;
55
56struct ConvQuantInfo;
57
58struct MatMulQuantInfo;
59
60struct PadQuantInfo;
61
62struct Version;
63
64struct TosaTensor;
65
66struct TosaOperator;
67
68struct TosaBasicBlock;
69
70struct TosaGraph;
71
72enum DType {
73 DType_UNKNOWN = 0,
74 DType_BOOL = 1,
75 DType_AINT8 = 2,
76 DType_UINT8 = 3,
77 DType_INT4 = 4,
78 DType_INT8 = 5,
79 DType_INT16 = 6,
80 DType_INT32 = 7,
81 DType_INT48 = 8,
82 DType_FLOAT = 9,
83 DType_MIN = DType_UNKNOWN,
84 DType_MAX = DType_FLOAT
85};
86
87inline const DType (&EnumValuesDType())[10] {
88 static const DType values[] = {
89 DType_UNKNOWN,
90 DType_BOOL,
91 DType_AINT8,
92 DType_UINT8,
93 DType_INT4,
94 DType_INT8,
95 DType_INT16,
96 DType_INT32,
97 DType_INT48,
98 DType_FLOAT
99 };
100 return values;
101}
102
103inline const char * const *EnumNamesDType() {
104 static const char * const names[] = {
105 "UNKNOWN",
106 "BOOL",
107 "AINT8",
108 "UINT8",
109 "INT4",
110 "INT8",
111 "INT16",
112 "INT32",
113 "INT48",
114 "FLOAT",
115 nullptr
116 };
117 return names;
118}
119
120inline const char *EnumNameDType(DType e) {
121 if (e < DType_UNKNOWN || e > DType_FLOAT) return "";
122 const size_t index = static_cast<size_t>(e);
123 return EnumNamesDType()[index];
124}
125
126enum Format {
127 Format_UNKNOWN = 0,
128 Format_NHWC = 1,
129 Format_NDHWC = 2,
130 Format_OHWI = 3,
131 Format_HWIM = 4,
132 Format_DOHWI = 5,
133 Format_MIN = Format_UNKNOWN,
134 Format_MAX = Format_DOHWI
135};
136
137inline const Format (&EnumValuesFormat())[6] {
138 static const Format values[] = {
139 Format_UNKNOWN,
140 Format_NHWC,
141 Format_NDHWC,
142 Format_OHWI,
143 Format_HWIM,
144 Format_DOHWI
145 };
146 return values;
147}
148
149inline const char * const *EnumNamesFormat() {
150 static const char * const names[] = {
151 "UNKNOWN",
152 "NHWC",
153 "NDHWC",
154 "OHWI",
155 "HWIM",
156 "DOHWI",
157 nullptr
158 };
159 return names;
160}
161
162inline const char *EnumNameFormat(Format e) {
163 if (e < Format_UNKNOWN || e > Format_DOHWI) return "";
164 const size_t index = static_cast<size_t>(e);
165 return EnumNamesFormat()[index];
166}
167
168enum Usage {
169 Usage_UNKNOWN = 0,
170 Usage_ACTIVATION = 1,
171 Usage_WEIGHT = 2,
172 Usage_INDEX = 3,
173 Usage_MIN = Usage_UNKNOWN,
174 Usage_MAX = Usage_INDEX
175};
176
177inline const Usage (&EnumValuesUsage())[4] {
178 static const Usage values[] = {
179 Usage_UNKNOWN,
180 Usage_ACTIVATION,
181 Usage_WEIGHT,
182 Usage_INDEX
183 };
184 return values;
185}
186
187inline const char * const *EnumNamesUsage() {
188 static const char * const names[] = {
189 "UNKNOWN",
190 "ACTIVATION",
191 "WEIGHT",
192 "INDEX",
193 nullptr
194 };
195 return names;
196}
197
198inline const char *EnumNameUsage(Usage e) {
199 if (e < Usage_UNKNOWN || e > Usage_INDEX) return "";
200 const size_t index = static_cast<size_t>(e);
201 return EnumNamesUsage()[index];
202}
203
204enum ResizeMode {
205 ResizeMode_UNKNOWN = 0,
206 ResizeMode_NEAREST = 1,
207 ResizeMode_BILINEAR = 2,
208 ResizeMode_MIN = ResizeMode_UNKNOWN,
209 ResizeMode_MAX = ResizeMode_BILINEAR
210};
211
212inline const ResizeMode (&EnumValuesResizeMode())[3] {
213 static const ResizeMode values[] = {
214 ResizeMode_UNKNOWN,
215 ResizeMode_NEAREST,
216 ResizeMode_BILINEAR
217 };
218 return values;
219}
220
221inline const char * const *EnumNamesResizeMode() {
222 static const char * const names[] = {
223 "UNKNOWN",
224 "NEAREST",
225 "BILINEAR",
226 nullptr
227 };
228 return names;
229}
230
231inline const char *EnumNameResizeMode(ResizeMode e) {
232 if (e < ResizeMode_UNKNOWN || e > ResizeMode_BILINEAR) return "";
233 const size_t index = static_cast<size_t>(e);
234 return EnumNamesResizeMode()[index];
235}
236
237enum Op {
238 Op_UNKNOWN = 0,
239 Op_ARGMAX = 1,
240 Op_AVG_POOL2D = 2,
241 Op_CONV2D = 3,
242 Op_CONV3D = 4,
243 Op_DEPTHWISE_CONV2D = 5,
244 Op_FULLY_CONNECTED = 6,
245 Op_MATMUL = 7,
246 Op_MAX_POOL2D = 8,
247 Op_TRANSPOSE_CONV2D = 9,
248 Op_CLAMP = 10,
249 Op_RELUN = 11,
250 Op_SIGMOID = 12,
251 Op_TANH = 13,
252 Op_ADD = 14,
253 Op_ARITHMETIC_RIGHT_SHIFT = 15,
254 Op_BITWISE_AND = 16,
255 Op_BITWISE_OR = 17,
256 Op_BITWISE_XOR = 18,
257 Op_LOGICAL_AND = 19,
258 Op_LOGICAL_LEFT_SHIFT = 20,
259 Op_LOGICAL_RIGHT_SHIFT = 21,
260 Op_LOGICAL_OR = 22,
261 Op_LOGICAL_XOR = 23,
262 Op_MAXIMUM = 24,
263 Op_MINIMUM = 25,
264 Op_MUL = 26,
265 Op_POW = 27,
266 Op_SUB = 28,
267 Op_TABLE = 29,
268 Op_ABS = 30,
269 Op_BITWISE_NOT = 31,
270 Op_CEIL = 32,
271 Op_CLZ = 33,
272 Op_EXP = 34,
273 Op_FLOOR = 35,
274 Op_LOG = 36,
275 Op_LOGICAL_NOT = 37,
276 Op_NEGATE = 38,
277 Op_RECIPROCAL = 39,
278 Op_RSQRT = 40,
279 Op_SELECT = 41,
280 Op_EQUAL = 42,
281 Op_GREATER = 43,
282 Op_GREATER_EQUAL = 44,
283 Op_REDUCE_ANY = 45,
284 Op_REDUCE_ALL = 46,
285 Op_REDUCE_MAX = 47,
286 Op_REDUCE_MIN = 48,
287 Op_REDUCE_PRODUCT = 49,
288 Op_REDUCE_SUM = 50,
289 Op_CONCAT = 51,
290 Op_PAD = 52,
291 Op_RESHAPE = 53,
292 Op_REVERSE = 54,
293 Op_SLICE = 55,
294 Op_TILE = 56,
295 Op_TRANSPOSE = 57,
296 Op_GATHER = 58,
297 Op_RESIZE = 59,
298 Op_CAST = 60,
299 Op_RESCALE = 61,
300 Op_CONST = 62,
301 Op_PLACEHOLDER = 63,
302 Op_IDENTITY = 64,
303 Op_IDENTITYN = 65,
304 Op_CUSTOM = 66,
305 Op_COND_IF = 67,
306 Op_WHILE_LOOP = 68,
307 Op_MIN = Op_UNKNOWN,
308 Op_MAX = Op_WHILE_LOOP
309};
310
311inline const Op (&EnumValuesOp())[69] {
312 static const Op values[] = {
313 Op_UNKNOWN,
314 Op_ARGMAX,
315 Op_AVG_POOL2D,
316 Op_CONV2D,
317 Op_CONV3D,
318 Op_DEPTHWISE_CONV2D,
319 Op_FULLY_CONNECTED,
320 Op_MATMUL,
321 Op_MAX_POOL2D,
322 Op_TRANSPOSE_CONV2D,
323 Op_CLAMP,
324 Op_RELUN,
325 Op_SIGMOID,
326 Op_TANH,
327 Op_ADD,
328 Op_ARITHMETIC_RIGHT_SHIFT,
329 Op_BITWISE_AND,
330 Op_BITWISE_OR,
331 Op_BITWISE_XOR,
332 Op_LOGICAL_AND,
333 Op_LOGICAL_LEFT_SHIFT,
334 Op_LOGICAL_RIGHT_SHIFT,
335 Op_LOGICAL_OR,
336 Op_LOGICAL_XOR,
337 Op_MAXIMUM,
338 Op_MINIMUM,
339 Op_MUL,
340 Op_POW,
341 Op_SUB,
342 Op_TABLE,
343 Op_ABS,
344 Op_BITWISE_NOT,
345 Op_CEIL,
346 Op_CLZ,
347 Op_EXP,
348 Op_FLOOR,
349 Op_LOG,
350 Op_LOGICAL_NOT,
351 Op_NEGATE,
352 Op_RECIPROCAL,
353 Op_RSQRT,
354 Op_SELECT,
355 Op_EQUAL,
356 Op_GREATER,
357 Op_GREATER_EQUAL,
358 Op_REDUCE_ANY,
359 Op_REDUCE_ALL,
360 Op_REDUCE_MAX,
361 Op_REDUCE_MIN,
362 Op_REDUCE_PRODUCT,
363 Op_REDUCE_SUM,
364 Op_CONCAT,
365 Op_PAD,
366 Op_RESHAPE,
367 Op_REVERSE,
368 Op_SLICE,
369 Op_TILE,
370 Op_TRANSPOSE,
371 Op_GATHER,
372 Op_RESIZE,
373 Op_CAST,
374 Op_RESCALE,
375 Op_CONST,
376 Op_PLACEHOLDER,
377 Op_IDENTITY,
378 Op_IDENTITYN,
379 Op_CUSTOM,
380 Op_COND_IF,
381 Op_WHILE_LOOP
382 };
383 return values;
384}
385
386inline const char * const *EnumNamesOp() {
387 static const char * const names[] = {
388 "UNKNOWN",
389 "ARGMAX",
390 "AVG_POOL2D",
391 "CONV2D",
392 "CONV3D",
393 "DEPTHWISE_CONV2D",
394 "FULLY_CONNECTED",
395 "MATMUL",
396 "MAX_POOL2D",
397 "TRANSPOSE_CONV2D",
398 "CLAMP",
399 "RELUN",
400 "SIGMOID",
401 "TANH",
402 "ADD",
403 "ARITHMETIC_RIGHT_SHIFT",
404 "BITWISE_AND",
405 "BITWISE_OR",
406 "BITWISE_XOR",
407 "LOGICAL_AND",
408 "LOGICAL_LEFT_SHIFT",
409 "LOGICAL_RIGHT_SHIFT",
410 "LOGICAL_OR",
411 "LOGICAL_XOR",
412 "MAXIMUM",
413 "MINIMUM",
414 "MUL",
415 "POW",
416 "SUB",
417 "TABLE",
418 "ABS",
419 "BITWISE_NOT",
420 "CEIL",
421 "CLZ",
422 "EXP",
423 "FLOOR",
424 "LOG",
425 "LOGICAL_NOT",
426 "NEGATE",
427 "RECIPROCAL",
428 "RSQRT",
429 "SELECT",
430 "EQUAL",
431 "GREATER",
432 "GREATER_EQUAL",
433 "REDUCE_ANY",
434 "REDUCE_ALL",
435 "REDUCE_MAX",
436 "REDUCE_MIN",
437 "REDUCE_PRODUCT",
438 "REDUCE_SUM",
439 "CONCAT",
440 "PAD",
441 "RESHAPE",
442 "REVERSE",
443 "SLICE",
444 "TILE",
445 "TRANSPOSE",
446 "GATHER",
447 "RESIZE",
448 "CAST",
449 "RESCALE",
450 "CONST",
451 "PLACEHOLDER",
452 "IDENTITY",
453 "IDENTITYN",
454 "CUSTOM",
455 "COND_IF",
456 "WHILE_LOOP",
457 nullptr
458 };
459 return names;
460}
461
462inline const char *EnumNameOp(Op e) {
463 if (e < Op_UNKNOWN || e > Op_WHILE_LOOP) return "";
464 const size_t index = static_cast<size_t>(e);
465 return EnumNamesOp()[index];
466}
467
468enum Attribute {
469 Attribute_NONE = 0,
470 Attribute_Pool2dAttribute = 1,
471 Attribute_Conv2dAttribute = 2,
472 Attribute_TransposeConv2dAttribute = 3,
473 Attribute_ReluNAttribute = 4,
474 Attribute_AxisAttribute = 5,
475 Attribute_ReshapeAttribute = 6,
476 Attribute_SliceAttribute = 7,
477 Attribute_TileAttribute = 8,
478 Attribute_ResizeAttribute = 9,
479 Attribute_ClampAttribute = 10,
480 Attribute_RescaleAttribute = 11,
481 Attribute_CustomAttribute = 12,
482 Attribute_CondIfAttribute = 13,
483 Attribute_WhileLoopAttribute = 14,
484 Attribute_MIN = Attribute_NONE,
485 Attribute_MAX = Attribute_WhileLoopAttribute
486};
487
488inline const Attribute (&EnumValuesAttribute())[15] {
489 static const Attribute values[] = {
490 Attribute_NONE,
491 Attribute_Pool2dAttribute,
492 Attribute_Conv2dAttribute,
493 Attribute_TransposeConv2dAttribute,
494 Attribute_ReluNAttribute,
495 Attribute_AxisAttribute,
496 Attribute_ReshapeAttribute,
497 Attribute_SliceAttribute,
498 Attribute_TileAttribute,
499 Attribute_ResizeAttribute,
500 Attribute_ClampAttribute,
501 Attribute_RescaleAttribute,
502 Attribute_CustomAttribute,
503 Attribute_CondIfAttribute,
504 Attribute_WhileLoopAttribute
505 };
506 return values;
507}
508
509inline const char * const *EnumNamesAttribute() {
510 static const char * const names[] = {
511 "NONE",
512 "Pool2dAttribute",
513 "Conv2dAttribute",
514 "TransposeConv2dAttribute",
515 "ReluNAttribute",
516 "AxisAttribute",
517 "ReshapeAttribute",
518 "SliceAttribute",
519 "TileAttribute",
520 "ResizeAttribute",
521 "ClampAttribute",
522 "RescaleAttribute",
523 "CustomAttribute",
524 "CondIfAttribute",
525 "WhileLoopAttribute",
526 nullptr
527 };
528 return names;
529}
530
531inline const char *EnumNameAttribute(Attribute e) {
532 if (e < Attribute_NONE || e > Attribute_WhileLoopAttribute) return "";
533 const size_t index = static_cast<size_t>(e);
534 return EnumNamesAttribute()[index];
535}
536
537template<typename T> struct AttributeTraits {
538 static const Attribute enum_value = Attribute_NONE;
539};
540
541template<> struct AttributeTraits<Pool2dAttribute> {
542 static const Attribute enum_value = Attribute_Pool2dAttribute;
543};
544
545template<> struct AttributeTraits<Conv2dAttribute> {
546 static const Attribute enum_value = Attribute_Conv2dAttribute;
547};
548
549template<> struct AttributeTraits<TransposeConv2dAttribute> {
550 static const Attribute enum_value = Attribute_TransposeConv2dAttribute;
551};
552
553template<> struct AttributeTraits<ReluNAttribute> {
554 static const Attribute enum_value = Attribute_ReluNAttribute;
555};
556
557template<> struct AttributeTraits<AxisAttribute> {
558 static const Attribute enum_value = Attribute_AxisAttribute;
559};
560
561template<> struct AttributeTraits<ReshapeAttribute> {
562 static const Attribute enum_value = Attribute_ReshapeAttribute;
563};
564
565template<> struct AttributeTraits<SliceAttribute> {
566 static const Attribute enum_value = Attribute_SliceAttribute;
567};
568
569template<> struct AttributeTraits<TileAttribute> {
570 static const Attribute enum_value = Attribute_TileAttribute;
571};
572
573template<> struct AttributeTraits<ResizeAttribute> {
574 static const Attribute enum_value = Attribute_ResizeAttribute;
575};
576
577template<> struct AttributeTraits<ClampAttribute> {
578 static const Attribute enum_value = Attribute_ClampAttribute;
579};
580
581template<> struct AttributeTraits<RescaleAttribute> {
582 static const Attribute enum_value = Attribute_RescaleAttribute;
583};
584
585template<> struct AttributeTraits<CustomAttribute> {
586 static const Attribute enum_value = Attribute_CustomAttribute;
587};
588
589template<> struct AttributeTraits<CondIfAttribute> {
590 static const Attribute enum_value = Attribute_CondIfAttribute;
591};
592
593template<> struct AttributeTraits<WhileLoopAttribute> {
594 static const Attribute enum_value = Attribute_WhileLoopAttribute;
595};
596
597bool VerifyAttribute(flatbuffers::Verifier &verifier, const void *obj, Attribute type);
598bool VerifyAttributeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
599
600enum QuantInfo {
601 QuantInfo_NONE = 0,
602 QuantInfo_UnaryQuantInfo = 1,
603 QuantInfo_ConvQuantInfo = 2,
604 QuantInfo_MatMulQuantInfo = 3,
605 QuantInfo_PadQuantInfo = 4,
606 QuantInfo_MIN = QuantInfo_NONE,
607 QuantInfo_MAX = QuantInfo_PadQuantInfo
608};
609
610inline const QuantInfo (&EnumValuesQuantInfo())[5] {
611 static const QuantInfo values[] = {
612 QuantInfo_NONE,
613 QuantInfo_UnaryQuantInfo,
614 QuantInfo_ConvQuantInfo,
615 QuantInfo_MatMulQuantInfo,
616 QuantInfo_PadQuantInfo
617 };
618 return values;
619}
620
621inline const char * const *EnumNamesQuantInfo() {
622 static const char * const names[] = {
623 "NONE",
624 "UnaryQuantInfo",
625 "ConvQuantInfo",
626 "MatMulQuantInfo",
627 "PadQuantInfo",
628 nullptr
629 };
630 return names;
631}
632
633inline const char *EnumNameQuantInfo(QuantInfo e) {
634 if (e < QuantInfo_NONE || e > QuantInfo_PadQuantInfo) return "";
635 const size_t index = static_cast<size_t>(e);
636 return EnumNamesQuantInfo()[index];
637}
638
639template<typename T> struct QuantInfoTraits {
640 static const QuantInfo enum_value = QuantInfo_NONE;
641};
642
643template<> struct QuantInfoTraits<UnaryQuantInfo> {
644 static const QuantInfo enum_value = QuantInfo_UnaryQuantInfo;
645};
646
647template<> struct QuantInfoTraits<ConvQuantInfo> {
648 static const QuantInfo enum_value = QuantInfo_ConvQuantInfo;
649};
650
651template<> struct QuantInfoTraits<MatMulQuantInfo> {
652 static const QuantInfo enum_value = QuantInfo_MatMulQuantInfo;
653};
654
655template<> struct QuantInfoTraits<PadQuantInfo> {
656 static const QuantInfo enum_value = QuantInfo_PadQuantInfo;
657};
658
659bool VerifyQuantInfo(flatbuffers::Verifier &verifier, const void *obj, QuantInfo type);
660bool VerifyQuantInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
661
662struct Pool2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
663 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
664 VT_PADDING = 4,
665 VT_KERNEL = 6,
666 VT_STRIDE = 8
667 };
668 const flatbuffers::Vector<int32_t> *padding() const {
669 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_PADDING);
670 }
671 const flatbuffers::Vector<int32_t> *kernel() const {
672 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_KERNEL);
673 }
674 const flatbuffers::Vector<int32_t> *stride() const {
675 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE);
676 }
677 bool Verify(flatbuffers::Verifier &verifier) const {
678 return VerifyTableStart(verifier) &&
679 VerifyOffset(verifier, VT_PADDING) &&
680 verifier.VerifyVector(padding()) &&
681 VerifyOffset(verifier, VT_KERNEL) &&
682 verifier.VerifyVector(kernel()) &&
683 VerifyOffset(verifier, VT_STRIDE) &&
684 verifier.VerifyVector(stride()) &&
685 verifier.EndTable();
686 }
687};
688
689struct Pool2dAttributeBuilder {
690 flatbuffers::FlatBufferBuilder &fbb_;
691 flatbuffers::uoffset_t start_;
692 void add_padding(flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding) {
693 fbb_.AddOffset(Pool2dAttribute::VT_PADDING, padding);
694 }
695 void add_kernel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> kernel) {
696 fbb_.AddOffset(Pool2dAttribute::VT_KERNEL, kernel);
697 }
698 void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) {
699 fbb_.AddOffset(Pool2dAttribute::VT_STRIDE, stride);
700 }
701 explicit Pool2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
702 : fbb_(_fbb) {
703 start_ = fbb_.StartTable();
704 }
705 Pool2dAttributeBuilder &operator=(const Pool2dAttributeBuilder &);
706 flatbuffers::Offset<Pool2dAttribute> Finish() {
707 const auto end = fbb_.EndTable(start_);
708 auto o = flatbuffers::Offset<Pool2dAttribute>(end);
709 return o;
710 }
711};
712
713inline flatbuffers::Offset<Pool2dAttribute> CreatePool2dAttribute(
714 flatbuffers::FlatBufferBuilder &_fbb,
715 flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding = 0,
716 flatbuffers::Offset<flatbuffers::Vector<int32_t>> kernel = 0,
717 flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0) {
718 Pool2dAttributeBuilder builder_(_fbb);
719 builder_.add_stride(stride);
720 builder_.add_kernel(kernel);
721 builder_.add_padding(padding);
722 return builder_.Finish();
723}
724
725inline flatbuffers::Offset<Pool2dAttribute> CreatePool2dAttributeDirect(
726 flatbuffers::FlatBufferBuilder &_fbb,
727 const std::vector<int32_t> *padding = nullptr,
728 const std::vector<int32_t> *kernel = nullptr,
729 const std::vector<int32_t> *stride = nullptr) {
730 auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
731 auto kernel__ = kernel ? _fbb.CreateVector<int32_t>(*kernel) : 0;
732 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
733 return tosa::CreatePool2dAttribute(
734 _fbb,
735 padding__,
736 kernel__,
737 stride__);
738}
739
740struct Conv2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
741 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
742 VT_PADDING = 4,
743 VT_STRIDE = 6,
744 VT_DILATION = 8
745 };
746 const flatbuffers::Vector<int32_t> *padding() const {
747 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_PADDING);
748 }
749 const flatbuffers::Vector<int32_t> *stride() const {
750 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE);
751 }
752 const flatbuffers::Vector<int32_t> *dilation() const {
753 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DILATION);
754 }
755 bool Verify(flatbuffers::Verifier &verifier) const {
756 return VerifyTableStart(verifier) &&
757 VerifyOffset(verifier, VT_PADDING) &&
758 verifier.VerifyVector(padding()) &&
759 VerifyOffset(verifier, VT_STRIDE) &&
760 verifier.VerifyVector(stride()) &&
761 VerifyOffset(verifier, VT_DILATION) &&
762 verifier.VerifyVector(dilation()) &&
763 verifier.EndTable();
764 }
765};
766
767struct Conv2dAttributeBuilder {
768 flatbuffers::FlatBufferBuilder &fbb_;
769 flatbuffers::uoffset_t start_;
770 void add_padding(flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding) {
771 fbb_.AddOffset(Conv2dAttribute::VT_PADDING, padding);
772 }
773 void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) {
774 fbb_.AddOffset(Conv2dAttribute::VT_STRIDE, stride);
775 }
776 void add_dilation(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation) {
777 fbb_.AddOffset(Conv2dAttribute::VT_DILATION, dilation);
778 }
779 explicit Conv2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
780 : fbb_(_fbb) {
781 start_ = fbb_.StartTable();
782 }
783 Conv2dAttributeBuilder &operator=(const Conv2dAttributeBuilder &);
784 flatbuffers::Offset<Conv2dAttribute> Finish() {
785 const auto end = fbb_.EndTable(start_);
786 auto o = flatbuffers::Offset<Conv2dAttribute>(end);
787 return o;
788 }
789};
790
791inline flatbuffers::Offset<Conv2dAttribute> CreateConv2dAttribute(
792 flatbuffers::FlatBufferBuilder &_fbb,
793 flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding = 0,
794 flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0,
795 flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation = 0) {
796 Conv2dAttributeBuilder builder_(_fbb);
797 builder_.add_dilation(dilation);
798 builder_.add_stride(stride);
799 builder_.add_padding(padding);
800 return builder_.Finish();
801}
802
803inline flatbuffers::Offset<Conv2dAttribute> CreateConv2dAttributeDirect(
804 flatbuffers::FlatBufferBuilder &_fbb,
805 const std::vector<int32_t> *padding = nullptr,
806 const std::vector<int32_t> *stride = nullptr,
807 const std::vector<int32_t> *dilation = nullptr) {
808 auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0;
809 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
810 auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0;
811 return tosa::CreateConv2dAttribute(
812 _fbb,
813 padding__,
814 stride__,
815 dilation__);
816}
817
818struct TransposeConv2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
819 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
820 VT_OUTPAD = 4,
821 VT_STRIDE = 6,
822 VT_DILATION = 8,
823 VT_OUTPUT_SHAPE = 10
824 };
825 const flatbuffers::Vector<int32_t> *outpad() const {
826 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPAD);
827 }
828 const flatbuffers::Vector<int32_t> *stride() const {
829 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE);
830 }
831 const flatbuffers::Vector<int32_t> *dilation() const {
832 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DILATION);
833 }
834 const flatbuffers::Vector<int32_t> *output_shape() const {
835 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUT_SHAPE);
836 }
837 bool Verify(flatbuffers::Verifier &verifier) const {
838 return VerifyTableStart(verifier) &&
839 VerifyOffset(verifier, VT_OUTPAD) &&
840 verifier.VerifyVector(outpad()) &&
841 VerifyOffset(verifier, VT_STRIDE) &&
842 verifier.VerifyVector(stride()) &&
843 VerifyOffset(verifier, VT_DILATION) &&
844 verifier.VerifyVector(dilation()) &&
845 VerifyOffset(verifier, VT_OUTPUT_SHAPE) &&
846 verifier.VerifyVector(output_shape()) &&
847 verifier.EndTable();
848 }
849};
850
851struct TransposeConv2dAttributeBuilder {
852 flatbuffers::FlatBufferBuilder &fbb_;
853 flatbuffers::uoffset_t start_;
854 void add_outpad(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outpad) {
855 fbb_.AddOffset(TransposeConv2dAttribute::VT_OUTPAD, outpad);
856 }
857 void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) {
858 fbb_.AddOffset(TransposeConv2dAttribute::VT_STRIDE, stride);
859 }
860 void add_dilation(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation) {
861 fbb_.AddOffset(TransposeConv2dAttribute::VT_DILATION, dilation);
862 }
863 void add_output_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_shape) {
864 fbb_.AddOffset(TransposeConv2dAttribute::VT_OUTPUT_SHAPE, output_shape);
865 }
866 explicit TransposeConv2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
867 : fbb_(_fbb) {
868 start_ = fbb_.StartTable();
869 }
870 TransposeConv2dAttributeBuilder &operator=(const TransposeConv2dAttributeBuilder &);
871 flatbuffers::Offset<TransposeConv2dAttribute> Finish() {
872 const auto end = fbb_.EndTable(start_);
873 auto o = flatbuffers::Offset<TransposeConv2dAttribute>(end);
874 return o;
875 }
876};
877
878inline flatbuffers::Offset<TransposeConv2dAttribute> CreateTransposeConv2dAttribute(
879 flatbuffers::FlatBufferBuilder &_fbb,
880 flatbuffers::Offset<flatbuffers::Vector<int32_t>> outpad = 0,
881 flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0,
882 flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation = 0,
883 flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_shape = 0) {
884 TransposeConv2dAttributeBuilder builder_(_fbb);
885 builder_.add_output_shape(output_shape);
886 builder_.add_dilation(dilation);
887 builder_.add_stride(stride);
888 builder_.add_outpad(outpad);
889 return builder_.Finish();
890}
891
892inline flatbuffers::Offset<TransposeConv2dAttribute> CreateTransposeConv2dAttributeDirect(
893 flatbuffers::FlatBufferBuilder &_fbb,
894 const std::vector<int32_t> *outpad = nullptr,
895 const std::vector<int32_t> *stride = nullptr,
896 const std::vector<int32_t> *dilation = nullptr,
897 const std::vector<int32_t> *output_shape = nullptr) {
898 auto outpad__ = outpad ? _fbb.CreateVector<int32_t>(*outpad) : 0;
899 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
900 auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0;
901 auto output_shape__ = output_shape ? _fbb.CreateVector<int32_t>(*output_shape) : 0;
902 return tosa::CreateTransposeConv2dAttribute(
903 _fbb,
904 outpad__,
905 stride__,
906 dilation__,
907 output_shape__);
908}
909
910struct ReluNAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
911 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
912 VT_MAX_INT = 4,
913 VT_MAX_FP = 6
914 };
915 int32_t max_int() const {
916 return GetField<int32_t>(VT_MAX_INT, 0);
917 }
918 float max_fp() const {
919 return GetField<float>(VT_MAX_FP, 0.0f);
920 }
921 bool Verify(flatbuffers::Verifier &verifier) const {
922 return VerifyTableStart(verifier) &&
923 VerifyField<int32_t>(verifier, VT_MAX_INT) &&
924 VerifyField<float>(verifier, VT_MAX_FP) &&
925 verifier.EndTable();
926 }
927};
928
929struct ReluNAttributeBuilder {
930 flatbuffers::FlatBufferBuilder &fbb_;
931 flatbuffers::uoffset_t start_;
932 void add_max_int(int32_t max_int) {
933 fbb_.AddElement<int32_t>(ReluNAttribute::VT_MAX_INT, max_int, 0);
934 }
935 void add_max_fp(float max_fp) {
936 fbb_.AddElement<float>(ReluNAttribute::VT_MAX_FP, max_fp, 0.0f);
937 }
938 explicit ReluNAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
939 : fbb_(_fbb) {
940 start_ = fbb_.StartTable();
941 }
942 ReluNAttributeBuilder &operator=(const ReluNAttributeBuilder &);
943 flatbuffers::Offset<ReluNAttribute> Finish() {
944 const auto end = fbb_.EndTable(start_);
945 auto o = flatbuffers::Offset<ReluNAttribute>(end);
946 return o;
947 }
948};
949
950inline flatbuffers::Offset<ReluNAttribute> CreateReluNAttribute(
951 flatbuffers::FlatBufferBuilder &_fbb,
952 int32_t max_int = 0,
953 float max_fp = 0.0f) {
954 ReluNAttributeBuilder builder_(_fbb);
955 builder_.add_max_fp(max_fp);
956 builder_.add_max_int(max_int);
957 return builder_.Finish();
958}
959
960struct AxisAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
961 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
962 VT_AXIS = 4
963 };
964 int32_t axis() const {
965 return GetField<int32_t>(VT_AXIS, 0);
966 }
967 bool Verify(flatbuffers::Verifier &verifier) const {
968 return VerifyTableStart(verifier) &&
969 VerifyField<int32_t>(verifier, VT_AXIS) &&
970 verifier.EndTable();
971 }
972};
973
974struct AxisAttributeBuilder {
975 flatbuffers::FlatBufferBuilder &fbb_;
976 flatbuffers::uoffset_t start_;
977 void add_axis(int32_t axis) {
978 fbb_.AddElement<int32_t>(AxisAttribute::VT_AXIS, axis, 0);
979 }
980 explicit AxisAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
981 : fbb_(_fbb) {
982 start_ = fbb_.StartTable();
983 }
984 AxisAttributeBuilder &operator=(const AxisAttributeBuilder &);
985 flatbuffers::Offset<AxisAttribute> Finish() {
986 const auto end = fbb_.EndTable(start_);
987 auto o = flatbuffers::Offset<AxisAttribute>(end);
988 return o;
989 }
990};
991
992inline flatbuffers::Offset<AxisAttribute> CreateAxisAttribute(
993 flatbuffers::FlatBufferBuilder &_fbb,
994 int32_t axis = 0) {
995 AxisAttributeBuilder builder_(_fbb);
996 builder_.add_axis(axis);
997 return builder_.Finish();
998}
999
1000struct ReshapeAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1001 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1002 VT_SHAPE = 4
1003 };
1004 const flatbuffers::Vector<int32_t> *shape() const {
1005 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
1006 }
1007 bool Verify(flatbuffers::Verifier &verifier) const {
1008 return VerifyTableStart(verifier) &&
1009 VerifyOffset(verifier, VT_SHAPE) &&
1010 verifier.VerifyVector(shape()) &&
1011 verifier.EndTable();
1012 }
1013};
1014
1015struct ReshapeAttributeBuilder {
1016 flatbuffers::FlatBufferBuilder &fbb_;
1017 flatbuffers::uoffset_t start_;
1018 void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
1019 fbb_.AddOffset(ReshapeAttribute::VT_SHAPE, shape);
1020 }
1021 explicit ReshapeAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1022 : fbb_(_fbb) {
1023 start_ = fbb_.StartTable();
1024 }
1025 ReshapeAttributeBuilder &operator=(const ReshapeAttributeBuilder &);
1026 flatbuffers::Offset<ReshapeAttribute> Finish() {
1027 const auto end = fbb_.EndTable(start_);
1028 auto o = flatbuffers::Offset<ReshapeAttribute>(end);
1029 return o;
1030 }
1031};
1032
1033inline flatbuffers::Offset<ReshapeAttribute> CreateReshapeAttribute(
1034 flatbuffers::FlatBufferBuilder &_fbb,
1035 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0) {
1036 ReshapeAttributeBuilder builder_(_fbb);
1037 builder_.add_shape(shape);
1038 return builder_.Finish();
1039}
1040
1041inline flatbuffers::Offset<ReshapeAttribute> CreateReshapeAttributeDirect(
1042 flatbuffers::FlatBufferBuilder &_fbb,
1043 const std::vector<int32_t> *shape = nullptr) {
1044 auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
1045 return tosa::CreateReshapeAttribute(
1046 _fbb,
1047 shape__);
1048}
1049
1050struct SliceAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1051 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1052 VT_BEGIN = 4,
1053 VT_SIZE = 6
1054 };
1055 const flatbuffers::Vector<int32_t> *begin() const {
1056 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BEGIN);
1057 }
1058 const flatbuffers::Vector<int32_t> *size() const {
1059 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SIZE);
1060 }
1061 bool Verify(flatbuffers::Verifier &verifier) const {
1062 return VerifyTableStart(verifier) &&
1063 VerifyOffset(verifier, VT_BEGIN) &&
1064 verifier.VerifyVector(begin()) &&
1065 VerifyOffset(verifier, VT_SIZE) &&
1066 verifier.VerifyVector(size()) &&
1067 verifier.EndTable();
1068 }
1069};
1070
1071struct SliceAttributeBuilder {
1072 flatbuffers::FlatBufferBuilder &fbb_;
1073 flatbuffers::uoffset_t start_;
1074 void add_begin(flatbuffers::Offset<flatbuffers::Vector<int32_t>> begin) {
1075 fbb_.AddOffset(SliceAttribute::VT_BEGIN, begin);
1076 }
1077 void add_size(flatbuffers::Offset<flatbuffers::Vector<int32_t>> size) {
1078 fbb_.AddOffset(SliceAttribute::VT_SIZE, size);
1079 }
1080 explicit SliceAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1081 : fbb_(_fbb) {
1082 start_ = fbb_.StartTable();
1083 }
1084 SliceAttributeBuilder &operator=(const SliceAttributeBuilder &);
1085 flatbuffers::Offset<SliceAttribute> Finish() {
1086 const auto end = fbb_.EndTable(start_);
1087 auto o = flatbuffers::Offset<SliceAttribute>(end);
1088 return o;
1089 }
1090};
1091
1092inline flatbuffers::Offset<SliceAttribute> CreateSliceAttribute(
1093 flatbuffers::FlatBufferBuilder &_fbb,
1094 flatbuffers::Offset<flatbuffers::Vector<int32_t>> begin = 0,
1095 flatbuffers::Offset<flatbuffers::Vector<int32_t>> size = 0) {
1096 SliceAttributeBuilder builder_(_fbb);
1097 builder_.add_size(size);
1098 builder_.add_begin(begin);
1099 return builder_.Finish();
1100}
1101
1102inline flatbuffers::Offset<SliceAttribute> CreateSliceAttributeDirect(
1103 flatbuffers::FlatBufferBuilder &_fbb,
1104 const std::vector<int32_t> *begin = nullptr,
1105 const std::vector<int32_t> *size = nullptr) {
1106 auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0;
1107 auto size__ = size ? _fbb.CreateVector<int32_t>(*size) : 0;
1108 return tosa::CreateSliceAttribute(
1109 _fbb,
1110 begin__,
1111 size__);
1112}
1113
1114struct TileAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1115 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1116 VT_MULTIPLES = 4
1117 };
1118 const flatbuffers::Vector<int32_t> *multiples() const {
1119 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_MULTIPLES);
1120 }
1121 bool Verify(flatbuffers::Verifier &verifier) const {
1122 return VerifyTableStart(verifier) &&
1123 VerifyOffset(verifier, VT_MULTIPLES) &&
1124 verifier.VerifyVector(multiples()) &&
1125 verifier.EndTable();
1126 }
1127};
1128
1129struct TileAttributeBuilder {
1130 flatbuffers::FlatBufferBuilder &fbb_;
1131 flatbuffers::uoffset_t start_;
1132 void add_multiples(flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiples) {
1133 fbb_.AddOffset(TileAttribute::VT_MULTIPLES, multiples);
1134 }
1135 explicit TileAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1136 : fbb_(_fbb) {
1137 start_ = fbb_.StartTable();
1138 }
1139 TileAttributeBuilder &operator=(const TileAttributeBuilder &);
1140 flatbuffers::Offset<TileAttribute> Finish() {
1141 const auto end = fbb_.EndTable(start_);
1142 auto o = flatbuffers::Offset<TileAttribute>(end);
1143 return o;
1144 }
1145};
1146
1147inline flatbuffers::Offset<TileAttribute> CreateTileAttribute(
1148 flatbuffers::FlatBufferBuilder &_fbb,
1149 flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiples = 0) {
1150 TileAttributeBuilder builder_(_fbb);
1151 builder_.add_multiples(multiples);
1152 return builder_.Finish();
1153}
1154
1155inline flatbuffers::Offset<TileAttribute> CreateTileAttributeDirect(
1156 flatbuffers::FlatBufferBuilder &_fbb,
1157 const std::vector<int32_t> *multiples = nullptr) {
1158 auto multiples__ = multiples ? _fbb.CreateVector<int32_t>(*multiples) : 0;
1159 return tosa::CreateTileAttribute(
1160 _fbb,
1161 multiples__);
1162}
1163
1164struct ResizeAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1165 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1166 VT_OUTPUT_SIZE = 4,
1167 VT_STRIDE = 6,
1168 VT_OFFSET = 8,
1169 VT_SHIFT = 10,
1170 VT_MODE = 12
1171 };
1172 const flatbuffers::Vector<int32_t> *output_size() const {
1173 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUT_SIZE);
1174 }
1175 const flatbuffers::Vector<int32_t> *stride() const {
1176 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE);
1177 }
1178 const flatbuffers::Vector<int32_t> *offset() const {
1179 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OFFSET);
1180 }
1181 int32_t shift() const {
1182 return GetField<int32_t>(VT_SHIFT, 0);
1183 }
1184 ResizeMode mode() const {
1185 return static_cast<ResizeMode>(GetField<uint32_t>(VT_MODE, 0));
1186 }
1187 bool Verify(flatbuffers::Verifier &verifier) const {
1188 return VerifyTableStart(verifier) &&
1189 VerifyOffset(verifier, VT_OUTPUT_SIZE) &&
1190 verifier.VerifyVector(output_size()) &&
1191 VerifyOffset(verifier, VT_STRIDE) &&
1192 verifier.VerifyVector(stride()) &&
1193 VerifyOffset(verifier, VT_OFFSET) &&
1194 verifier.VerifyVector(offset()) &&
1195 VerifyField<int32_t>(verifier, VT_SHIFT) &&
1196 VerifyField<uint32_t>(verifier, VT_MODE) &&
1197 verifier.EndTable();
1198 }
1199};
1200
1201struct ResizeAttributeBuilder {
1202 flatbuffers::FlatBufferBuilder &fbb_;
1203 flatbuffers::uoffset_t start_;
1204 void add_output_size(flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_size) {
1205 fbb_.AddOffset(ResizeAttribute::VT_OUTPUT_SIZE, output_size);
1206 }
1207 void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) {
1208 fbb_.AddOffset(ResizeAttribute::VT_STRIDE, stride);
1209 }
1210 void add_offset(flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset) {
1211 fbb_.AddOffset(ResizeAttribute::VT_OFFSET, offset);
1212 }
1213 void add_shift(int32_t shift) {
1214 fbb_.AddElement<int32_t>(ResizeAttribute::VT_SHIFT, shift, 0);
1215 }
1216 void add_mode(ResizeMode mode) {
1217 fbb_.AddElement<uint32_t>(ResizeAttribute::VT_MODE, static_cast<uint32_t>(mode), 0);
1218 }
1219 explicit ResizeAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1220 : fbb_(_fbb) {
1221 start_ = fbb_.StartTable();
1222 }
1223 ResizeAttributeBuilder &operator=(const ResizeAttributeBuilder &);
1224 flatbuffers::Offset<ResizeAttribute> Finish() {
1225 const auto end = fbb_.EndTable(start_);
1226 auto o = flatbuffers::Offset<ResizeAttribute>(end);
1227 return o;
1228 }
1229};
1230
1231inline flatbuffers::Offset<ResizeAttribute> CreateResizeAttribute(
1232 flatbuffers::FlatBufferBuilder &_fbb,
1233 flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_size = 0,
1234 flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0,
1235 flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset = 0,
1236 int32_t shift = 0,
1237 ResizeMode mode = ResizeMode_UNKNOWN) {
1238 ResizeAttributeBuilder builder_(_fbb);
1239 builder_.add_mode(mode);
1240 builder_.add_shift(shift);
1241 builder_.add_offset(offset);
1242 builder_.add_stride(stride);
1243 builder_.add_output_size(output_size);
1244 return builder_.Finish();
1245}
1246
1247inline flatbuffers::Offset<ResizeAttribute> CreateResizeAttributeDirect(
1248 flatbuffers::FlatBufferBuilder &_fbb,
1249 const std::vector<int32_t> *output_size = nullptr,
1250 const std::vector<int32_t> *stride = nullptr,
1251 const std::vector<int32_t> *offset = nullptr,
1252 int32_t shift = 0,
1253 ResizeMode mode = ResizeMode_UNKNOWN) {
1254 auto output_size__ = output_size ? _fbb.CreateVector<int32_t>(*output_size) : 0;
1255 auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0;
1256 auto offset__ = offset ? _fbb.CreateVector<int32_t>(*offset) : 0;
1257 return tosa::CreateResizeAttribute(
1258 _fbb,
1259 output_size__,
1260 stride__,
1261 offset__,
1262 shift,
1263 mode);
1264}
1265
1266struct ClampAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1267 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1268 VT_MIN_INT = 4,
1269 VT_MAX_INT = 6,
1270 VT_MIN_FP = 8,
1271 VT_MAX_FP = 10
1272 };
1273 int32_t min_int() const {
1274 return GetField<int32_t>(VT_MIN_INT, 0);
1275 }
1276 int32_t max_int() const {
1277 return GetField<int32_t>(VT_MAX_INT, 0);
1278 }
1279 float min_fp() const {
1280 return GetField<float>(VT_MIN_FP, 0.0f);
1281 }
1282 float max_fp() const {
1283 return GetField<float>(VT_MAX_FP, 0.0f);
1284 }
1285 bool Verify(flatbuffers::Verifier &verifier) const {
1286 return VerifyTableStart(verifier) &&
1287 VerifyField<int32_t>(verifier, VT_MIN_INT) &&
1288 VerifyField<int32_t>(verifier, VT_MAX_INT) &&
1289 VerifyField<float>(verifier, VT_MIN_FP) &&
1290 VerifyField<float>(verifier, VT_MAX_FP) &&
1291 verifier.EndTable();
1292 }
1293};
1294
1295struct ClampAttributeBuilder {
1296 flatbuffers::FlatBufferBuilder &fbb_;
1297 flatbuffers::uoffset_t start_;
1298 void add_min_int(int32_t min_int) {
1299 fbb_.AddElement<int32_t>(ClampAttribute::VT_MIN_INT, min_int, 0);
1300 }
1301 void add_max_int(int32_t max_int) {
1302 fbb_.AddElement<int32_t>(ClampAttribute::VT_MAX_INT, max_int, 0);
1303 }
1304 void add_min_fp(float min_fp) {
1305 fbb_.AddElement<float>(ClampAttribute::VT_MIN_FP, min_fp, 0.0f);
1306 }
1307 void add_max_fp(float max_fp) {
1308 fbb_.AddElement<float>(ClampAttribute::VT_MAX_FP, max_fp, 0.0f);
1309 }
1310 explicit ClampAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1311 : fbb_(_fbb) {
1312 start_ = fbb_.StartTable();
1313 }
1314 ClampAttributeBuilder &operator=(const ClampAttributeBuilder &);
1315 flatbuffers::Offset<ClampAttribute> Finish() {
1316 const auto end = fbb_.EndTable(start_);
1317 auto o = flatbuffers::Offset<ClampAttribute>(end);
1318 return o;
1319 }
1320};
1321
1322inline flatbuffers::Offset<ClampAttribute> CreateClampAttribute(
1323 flatbuffers::FlatBufferBuilder &_fbb,
1324 int32_t min_int = 0,
1325 int32_t max_int = 0,
1326 float min_fp = 0.0f,
1327 float max_fp = 0.0f) {
1328 ClampAttributeBuilder builder_(_fbb);
1329 builder_.add_max_fp(max_fp);
1330 builder_.add_min_fp(min_fp);
1331 builder_.add_max_int(max_int);
1332 builder_.add_min_int(min_int);
1333 return builder_.Finish();
1334}
1335
1336struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1337 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1338 VT_INPUT_ZP = 4,
1339 VT_OUTPUT_ZP = 6,
1340 VT_MULTIPLIER = 8,
1341 VT_SHIFT = 10,
1342 VT_SCALE32 = 12,
1343 VT_DOUBLE_ROUND = 14,
1344 VT_PER_CHANNEL = 16
1345 };
1346 int32_t input_zp() const {
1347 return GetField<int32_t>(VT_INPUT_ZP, 0);
1348 }
1349 int32_t output_zp() const {
1350 return GetField<int32_t>(VT_OUTPUT_ZP, 0);
1351 }
1352 const flatbuffers::Vector<int32_t> *multiplier() const {
1353 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_MULTIPLIER);
1354 }
1355 const flatbuffers::Vector<int32_t> *shift() const {
1356 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHIFT);
1357 }
1358 bool scale32() const {
1359 return GetField<uint8_t>(VT_SCALE32, 0) != 0;
1360 }
1361 bool double_round() const {
1362 return GetField<uint8_t>(VT_DOUBLE_ROUND, 0) != 0;
1363 }
1364 bool per_channel() const {
1365 return GetField<uint8_t>(VT_PER_CHANNEL, 0) != 0;
1366 }
1367 bool Verify(flatbuffers::Verifier &verifier) const {
1368 return VerifyTableStart(verifier) &&
1369 VerifyField<int32_t>(verifier, VT_INPUT_ZP) &&
1370 VerifyField<int32_t>(verifier, VT_OUTPUT_ZP) &&
1371 VerifyOffset(verifier, VT_MULTIPLIER) &&
1372 verifier.VerifyVector(multiplier()) &&
1373 VerifyOffset(verifier, VT_SHIFT) &&
1374 verifier.VerifyVector(shift()) &&
1375 VerifyField<uint8_t>(verifier, VT_SCALE32) &&
1376 VerifyField<uint8_t>(verifier, VT_DOUBLE_ROUND) &&
1377 VerifyField<uint8_t>(verifier, VT_PER_CHANNEL) &&
1378 verifier.EndTable();
1379 }
1380};
1381
1382struct RescaleAttributeBuilder {
1383 flatbuffers::FlatBufferBuilder &fbb_;
1384 flatbuffers::uoffset_t start_;
1385 void add_input_zp(int32_t input_zp) {
1386 fbb_.AddElement<int32_t>(RescaleAttribute::VT_INPUT_ZP, input_zp, 0);
1387 }
1388 void add_output_zp(int32_t output_zp) {
1389 fbb_.AddElement<int32_t>(RescaleAttribute::VT_OUTPUT_ZP, output_zp, 0);
1390 }
1391 void add_multiplier(flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiplier) {
1392 fbb_.AddOffset(RescaleAttribute::VT_MULTIPLIER, multiplier);
1393 }
1394 void add_shift(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shift) {
1395 fbb_.AddOffset(RescaleAttribute::VT_SHIFT, shift);
1396 }
1397 void add_scale32(bool scale32) {
1398 fbb_.AddElement<uint8_t>(RescaleAttribute::VT_SCALE32, static_cast<uint8_t>(scale32), 0);
1399 }
1400 void add_double_round(bool double_round) {
1401 fbb_.AddElement<uint8_t>(RescaleAttribute::VT_DOUBLE_ROUND, static_cast<uint8_t>(double_round), 0);
1402 }
1403 void add_per_channel(bool per_channel) {
1404 fbb_.AddElement<uint8_t>(RescaleAttribute::VT_PER_CHANNEL, static_cast<uint8_t>(per_channel), 0);
1405 }
1406 explicit RescaleAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1407 : fbb_(_fbb) {
1408 start_ = fbb_.StartTable();
1409 }
1410 RescaleAttributeBuilder &operator=(const RescaleAttributeBuilder &);
1411 flatbuffers::Offset<RescaleAttribute> Finish() {
1412 const auto end = fbb_.EndTable(start_);
1413 auto o = flatbuffers::Offset<RescaleAttribute>(end);
1414 return o;
1415 }
1416};
1417
1418inline flatbuffers::Offset<RescaleAttribute> CreateRescaleAttribute(
1419 flatbuffers::FlatBufferBuilder &_fbb,
1420 int32_t input_zp = 0,
1421 int32_t output_zp = 0,
1422 flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiplier = 0,
1423 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shift = 0,
1424 bool scale32 = false,
1425 bool double_round = false,
1426 bool per_channel = false) {
1427 RescaleAttributeBuilder builder_(_fbb);
1428 builder_.add_shift(shift);
1429 builder_.add_multiplier(multiplier);
1430 builder_.add_output_zp(output_zp);
1431 builder_.add_input_zp(input_zp);
1432 builder_.add_per_channel(per_channel);
1433 builder_.add_double_round(double_round);
1434 builder_.add_scale32(scale32);
1435 return builder_.Finish();
1436}
1437
1438inline flatbuffers::Offset<RescaleAttribute> CreateRescaleAttributeDirect(
1439 flatbuffers::FlatBufferBuilder &_fbb,
1440 int32_t input_zp = 0,
1441 int32_t output_zp = 0,
1442 const std::vector<int32_t> *multiplier = nullptr,
1443 const std::vector<int32_t> *shift = nullptr,
1444 bool scale32 = false,
1445 bool double_round = false,
1446 bool per_channel = false) {
1447 auto multiplier__ = multiplier ? _fbb.CreateVector<int32_t>(*multiplier) : 0;
1448 auto shift__ = shift ? _fbb.CreateVector<int32_t>(*shift) : 0;
1449 return tosa::CreateRescaleAttribute(
1450 _fbb,
1451 input_zp,
1452 output_zp,
1453 multiplier__,
1454 shift__,
1455 scale32,
1456 double_round,
1457 per_channel);
1458}
1459
1460struct CustomAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1461 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1462 VT_IDENTIFIER = 4
1463 };
1464 const flatbuffers::String *identifier() const {
1465 return GetPointer<const flatbuffers::String *>(VT_IDENTIFIER);
1466 }
1467 bool Verify(flatbuffers::Verifier &verifier) const {
1468 return VerifyTableStart(verifier) &&
1469 VerifyOffset(verifier, VT_IDENTIFIER) &&
1470 verifier.VerifyString(identifier()) &&
1471 verifier.EndTable();
1472 }
1473};
1474
1475struct CustomAttributeBuilder {
1476 flatbuffers::FlatBufferBuilder &fbb_;
1477 flatbuffers::uoffset_t start_;
1478 void add_identifier(flatbuffers::Offset<flatbuffers::String> identifier) {
1479 fbb_.AddOffset(CustomAttribute::VT_IDENTIFIER, identifier);
1480 }
1481 explicit CustomAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1482 : fbb_(_fbb) {
1483 start_ = fbb_.StartTable();
1484 }
1485 CustomAttributeBuilder &operator=(const CustomAttributeBuilder &);
1486 flatbuffers::Offset<CustomAttribute> Finish() {
1487 const auto end = fbb_.EndTable(start_);
1488 auto o = flatbuffers::Offset<CustomAttribute>(end);
1489 return o;
1490 }
1491};
1492
1493inline flatbuffers::Offset<CustomAttribute> CreateCustomAttribute(
1494 flatbuffers::FlatBufferBuilder &_fbb,
1495 flatbuffers::Offset<flatbuffers::String> identifier = 0) {
1496 CustomAttributeBuilder builder_(_fbb);
1497 builder_.add_identifier(identifier);
1498 return builder_.Finish();
1499}
1500
1501inline flatbuffers::Offset<CustomAttribute> CreateCustomAttributeDirect(
1502 flatbuffers::FlatBufferBuilder &_fbb,
1503 const char *identifier = nullptr) {
1504 auto identifier__ = identifier ? _fbb.CreateString(identifier) : 0;
1505 return tosa::CreateCustomAttribute(
1506 _fbb,
1507 identifier__);
1508}
1509
1510struct CondIfAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1511 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1512 VT_THEN_BRANCH = 4,
1513 VT_ELSE_BRANCH = 6
1514 };
1515 const flatbuffers::String *then_branch() const {
1516 return GetPointer<const flatbuffers::String *>(VT_THEN_BRANCH);
1517 }
1518 const flatbuffers::String *else_branch() const {
1519 return GetPointer<const flatbuffers::String *>(VT_ELSE_BRANCH);
1520 }
1521 bool Verify(flatbuffers::Verifier &verifier) const {
1522 return VerifyTableStart(verifier) &&
1523 VerifyOffset(verifier, VT_THEN_BRANCH) &&
1524 verifier.VerifyString(then_branch()) &&
1525 VerifyOffset(verifier, VT_ELSE_BRANCH) &&
1526 verifier.VerifyString(else_branch()) &&
1527 verifier.EndTable();
1528 }
1529};
1530
1531struct CondIfAttributeBuilder {
1532 flatbuffers::FlatBufferBuilder &fbb_;
1533 flatbuffers::uoffset_t start_;
1534 void add_then_branch(flatbuffers::Offset<flatbuffers::String> then_branch) {
1535 fbb_.AddOffset(CondIfAttribute::VT_THEN_BRANCH, then_branch);
1536 }
1537 void add_else_branch(flatbuffers::Offset<flatbuffers::String> else_branch) {
1538 fbb_.AddOffset(CondIfAttribute::VT_ELSE_BRANCH, else_branch);
1539 }
1540 explicit CondIfAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1541 : fbb_(_fbb) {
1542 start_ = fbb_.StartTable();
1543 }
1544 CondIfAttributeBuilder &operator=(const CondIfAttributeBuilder &);
1545 flatbuffers::Offset<CondIfAttribute> Finish() {
1546 const auto end = fbb_.EndTable(start_);
1547 auto o = flatbuffers::Offset<CondIfAttribute>(end);
1548 return o;
1549 }
1550};
1551
1552inline flatbuffers::Offset<CondIfAttribute> CreateCondIfAttribute(
1553 flatbuffers::FlatBufferBuilder &_fbb,
1554 flatbuffers::Offset<flatbuffers::String> then_branch = 0,
1555 flatbuffers::Offset<flatbuffers::String> else_branch = 0) {
1556 CondIfAttributeBuilder builder_(_fbb);
1557 builder_.add_else_branch(else_branch);
1558 builder_.add_then_branch(then_branch);
1559 return builder_.Finish();
1560}
1561
1562inline flatbuffers::Offset<CondIfAttribute> CreateCondIfAttributeDirect(
1563 flatbuffers::FlatBufferBuilder &_fbb,
1564 const char *then_branch = nullptr,
1565 const char *else_branch = nullptr) {
1566 auto then_branch__ = then_branch ? _fbb.CreateString(then_branch) : 0;
1567 auto else_branch__ = else_branch ? _fbb.CreateString(else_branch) : 0;
1568 return tosa::CreateCondIfAttribute(
1569 _fbb,
1570 then_branch__,
1571 else_branch__);
1572}
1573
1574struct WhileLoopAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1575 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1576 VT_COND_BRANCH = 4,
1577 VT_BODY_BRANCH = 6
1578 };
1579 const flatbuffers::String *cond_branch() const {
1580 return GetPointer<const flatbuffers::String *>(VT_COND_BRANCH);
1581 }
1582 const flatbuffers::String *body_branch() const {
1583 return GetPointer<const flatbuffers::String *>(VT_BODY_BRANCH);
1584 }
1585 bool Verify(flatbuffers::Verifier &verifier) const {
1586 return VerifyTableStart(verifier) &&
1587 VerifyOffset(verifier, VT_COND_BRANCH) &&
1588 verifier.VerifyString(cond_branch()) &&
1589 VerifyOffset(verifier, VT_BODY_BRANCH) &&
1590 verifier.VerifyString(body_branch()) &&
1591 verifier.EndTable();
1592 }
1593};
1594
1595struct WhileLoopAttributeBuilder {
1596 flatbuffers::FlatBufferBuilder &fbb_;
1597 flatbuffers::uoffset_t start_;
1598 void add_cond_branch(flatbuffers::Offset<flatbuffers::String> cond_branch) {
1599 fbb_.AddOffset(WhileLoopAttribute::VT_COND_BRANCH, cond_branch);
1600 }
1601 void add_body_branch(flatbuffers::Offset<flatbuffers::String> body_branch) {
1602 fbb_.AddOffset(WhileLoopAttribute::VT_BODY_BRANCH, body_branch);
1603 }
1604 explicit WhileLoopAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1605 : fbb_(_fbb) {
1606 start_ = fbb_.StartTable();
1607 }
1608 WhileLoopAttributeBuilder &operator=(const WhileLoopAttributeBuilder &);
1609 flatbuffers::Offset<WhileLoopAttribute> Finish() {
1610 const auto end = fbb_.EndTable(start_);
1611 auto o = flatbuffers::Offset<WhileLoopAttribute>(end);
1612 return o;
1613 }
1614};
1615
1616inline flatbuffers::Offset<WhileLoopAttribute> CreateWhileLoopAttribute(
1617 flatbuffers::FlatBufferBuilder &_fbb,
1618 flatbuffers::Offset<flatbuffers::String> cond_branch = 0,
1619 flatbuffers::Offset<flatbuffers::String> body_branch = 0) {
1620 WhileLoopAttributeBuilder builder_(_fbb);
1621 builder_.add_body_branch(body_branch);
1622 builder_.add_cond_branch(cond_branch);
1623 return builder_.Finish();
1624}
1625
1626inline flatbuffers::Offset<WhileLoopAttribute> CreateWhileLoopAttributeDirect(
1627 flatbuffers::FlatBufferBuilder &_fbb,
1628 const char *cond_branch = nullptr,
1629 const char *body_branch = nullptr) {
1630 auto cond_branch__ = cond_branch ? _fbb.CreateString(cond_branch) : 0;
1631 auto body_branch__ = body_branch ? _fbb.CreateString(body_branch) : 0;
1632 return tosa::CreateWhileLoopAttribute(
1633 _fbb,
1634 cond_branch__,
1635 body_branch__);
1636}
1637
1638struct UnaryQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1639 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1640 VT_INPUT_ZP = 4,
1641 VT_OUTPUT_ZP = 6
1642 };
1643 int32_t input_zp() const {
1644 return GetField<int32_t>(VT_INPUT_ZP, 0);
1645 }
1646 int32_t output_zp() const {
1647 return GetField<int32_t>(VT_OUTPUT_ZP, 0);
1648 }
1649 bool Verify(flatbuffers::Verifier &verifier) const {
1650 return VerifyTableStart(verifier) &&
1651 VerifyField<int32_t>(verifier, VT_INPUT_ZP) &&
1652 VerifyField<int32_t>(verifier, VT_OUTPUT_ZP) &&
1653 verifier.EndTable();
1654 }
1655};
1656
1657struct UnaryQuantInfoBuilder {
1658 flatbuffers::FlatBufferBuilder &fbb_;
1659 flatbuffers::uoffset_t start_;
1660 void add_input_zp(int32_t input_zp) {
1661 fbb_.AddElement<int32_t>(UnaryQuantInfo::VT_INPUT_ZP, input_zp, 0);
1662 }
1663 void add_output_zp(int32_t output_zp) {
1664 fbb_.AddElement<int32_t>(UnaryQuantInfo::VT_OUTPUT_ZP, output_zp, 0);
1665 }
1666 explicit UnaryQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1667 : fbb_(_fbb) {
1668 start_ = fbb_.StartTable();
1669 }
1670 UnaryQuantInfoBuilder &operator=(const UnaryQuantInfoBuilder &);
1671 flatbuffers::Offset<UnaryQuantInfo> Finish() {
1672 const auto end = fbb_.EndTable(start_);
1673 auto o = flatbuffers::Offset<UnaryQuantInfo>(end);
1674 return o;
1675 }
1676};
1677
1678inline flatbuffers::Offset<UnaryQuantInfo> CreateUnaryQuantInfo(
1679 flatbuffers::FlatBufferBuilder &_fbb,
1680 int32_t input_zp = 0,
1681 int32_t output_zp = 0) {
1682 UnaryQuantInfoBuilder builder_(_fbb);
1683 builder_.add_output_zp(output_zp);
1684 builder_.add_input_zp(input_zp);
1685 return builder_.Finish();
1686}
1687
1688struct ConvQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1689 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1690 VT_INPUT_ZP = 4,
1691 VT_WEIGHT_ZP = 6
1692 };
1693 int32_t input_zp() const {
1694 return GetField<int32_t>(VT_INPUT_ZP, 0);
1695 }
1696 int32_t weight_zp() const {
1697 return GetField<int32_t>(VT_WEIGHT_ZP, 0);
1698 }
1699 bool Verify(flatbuffers::Verifier &verifier) const {
1700 return VerifyTableStart(verifier) &&
1701 VerifyField<int32_t>(verifier, VT_INPUT_ZP) &&
1702 VerifyField<int32_t>(verifier, VT_WEIGHT_ZP) &&
1703 verifier.EndTable();
1704 }
1705};
1706
1707struct ConvQuantInfoBuilder {
1708 flatbuffers::FlatBufferBuilder &fbb_;
1709 flatbuffers::uoffset_t start_;
1710 void add_input_zp(int32_t input_zp) {
1711 fbb_.AddElement<int32_t>(ConvQuantInfo::VT_INPUT_ZP, input_zp, 0);
1712 }
1713 void add_weight_zp(int32_t weight_zp) {
1714 fbb_.AddElement<int32_t>(ConvQuantInfo::VT_WEIGHT_ZP, weight_zp, 0);
1715 }
1716 explicit ConvQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1717 : fbb_(_fbb) {
1718 start_ = fbb_.StartTable();
1719 }
1720 ConvQuantInfoBuilder &operator=(const ConvQuantInfoBuilder &);
1721 flatbuffers::Offset<ConvQuantInfo> Finish() {
1722 const auto end = fbb_.EndTable(start_);
1723 auto o = flatbuffers::Offset<ConvQuantInfo>(end);
1724 return o;
1725 }
1726};
1727
1728inline flatbuffers::Offset<ConvQuantInfo> CreateConvQuantInfo(
1729 flatbuffers::FlatBufferBuilder &_fbb,
1730 int32_t input_zp = 0,
1731 int32_t weight_zp = 0) {
1732 ConvQuantInfoBuilder builder_(_fbb);
1733 builder_.add_weight_zp(weight_zp);
1734 builder_.add_input_zp(input_zp);
1735 return builder_.Finish();
1736}
1737
1738struct MatMulQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1739 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1740 VT_A_ZP = 4,
1741 VT_B_ZP = 6
1742 };
1743 int32_t a_zp() const {
1744 return GetField<int32_t>(VT_A_ZP, 0);
1745 }
1746 int32_t b_zp() const {
1747 return GetField<int32_t>(VT_B_ZP, 0);
1748 }
1749 bool Verify(flatbuffers::Verifier &verifier) const {
1750 return VerifyTableStart(verifier) &&
1751 VerifyField<int32_t>(verifier, VT_A_ZP) &&
1752 VerifyField<int32_t>(verifier, VT_B_ZP) &&
1753 verifier.EndTable();
1754 }
1755};
1756
1757struct MatMulQuantInfoBuilder {
1758 flatbuffers::FlatBufferBuilder &fbb_;
1759 flatbuffers::uoffset_t start_;
1760 void add_a_zp(int32_t a_zp) {
1761 fbb_.AddElement<int32_t>(MatMulQuantInfo::VT_A_ZP, a_zp, 0);
1762 }
1763 void add_b_zp(int32_t b_zp) {
1764 fbb_.AddElement<int32_t>(MatMulQuantInfo::VT_B_ZP, b_zp, 0);
1765 }
1766 explicit MatMulQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1767 : fbb_(_fbb) {
1768 start_ = fbb_.StartTable();
1769 }
1770 MatMulQuantInfoBuilder &operator=(const MatMulQuantInfoBuilder &);
1771 flatbuffers::Offset<MatMulQuantInfo> Finish() {
1772 const auto end = fbb_.EndTable(start_);
1773 auto o = flatbuffers::Offset<MatMulQuantInfo>(end);
1774 return o;
1775 }
1776};
1777
1778inline flatbuffers::Offset<MatMulQuantInfo> CreateMatMulQuantInfo(
1779 flatbuffers::FlatBufferBuilder &_fbb,
1780 int32_t a_zp = 0,
1781 int32_t b_zp = 0) {
1782 MatMulQuantInfoBuilder builder_(_fbb);
1783 builder_.add_b_zp(b_zp);
1784 builder_.add_a_zp(a_zp);
1785 return builder_.Finish();
1786}
1787
1788struct PadQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1789 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1790 VT_INPUT_ZP = 4
1791 };
1792 int32_t input_zp() const {
1793 return GetField<int32_t>(VT_INPUT_ZP, 0);
1794 }
1795 bool Verify(flatbuffers::Verifier &verifier) const {
1796 return VerifyTableStart(verifier) &&
1797 VerifyField<int32_t>(verifier, VT_INPUT_ZP) &&
1798 verifier.EndTable();
1799 }
1800};
1801
1802struct PadQuantInfoBuilder {
1803 flatbuffers::FlatBufferBuilder &fbb_;
1804 flatbuffers::uoffset_t start_;
1805 void add_input_zp(int32_t input_zp) {
1806 fbb_.AddElement<int32_t>(PadQuantInfo::VT_INPUT_ZP, input_zp, 0);
1807 }
1808 explicit PadQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1809 : fbb_(_fbb) {
1810 start_ = fbb_.StartTable();
1811 }
1812 PadQuantInfoBuilder &operator=(const PadQuantInfoBuilder &);
1813 flatbuffers::Offset<PadQuantInfo> Finish() {
1814 const auto end = fbb_.EndTable(start_);
1815 auto o = flatbuffers::Offset<PadQuantInfo>(end);
1816 return o;
1817 }
1818};
1819
1820inline flatbuffers::Offset<PadQuantInfo> CreatePadQuantInfo(
1821 flatbuffers::FlatBufferBuilder &_fbb,
1822 int32_t input_zp = 0) {
1823 PadQuantInfoBuilder builder_(_fbb);
1824 builder_.add_input_zp(input_zp);
1825 return builder_.Finish();
1826}
1827
1828struct Version FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1829 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1830 VT__MAJOR = 4,
1831 VT__MINOR = 6,
1832 VT__PATCH = 8,
1833 VT__EXPERIMENTAL = 10
1834 };
1835 int32_t _major() const {
1836 return GetField<int32_t>(VT__MAJOR, 0);
1837 }
1838 int32_t _minor() const {
1839 return GetField<int32_t>(VT__MINOR, 20);
1840 }
1841 int32_t _patch() const {
1842 return GetField<int32_t>(VT__PATCH, 0);
1843 }
1844 bool _experimental() const {
1845 return GetField<uint8_t>(VT__EXPERIMENTAL, 0) != 0;
1846 }
1847 bool Verify(flatbuffers::Verifier &verifier) const {
1848 return VerifyTableStart(verifier) &&
1849 VerifyField<int32_t>(verifier, VT__MAJOR) &&
1850 VerifyField<int32_t>(verifier, VT__MINOR) &&
1851 VerifyField<int32_t>(verifier, VT__PATCH) &&
1852 VerifyField<uint8_t>(verifier, VT__EXPERIMENTAL) &&
1853 verifier.EndTable();
1854 }
1855};
1856
1857struct VersionBuilder {
1858 flatbuffers::FlatBufferBuilder &fbb_;
1859 flatbuffers::uoffset_t start_;
1860 void add__major(int32_t _major) {
1861 fbb_.AddElement<int32_t>(Version::VT__MAJOR, _major, 0);
1862 }
1863 void add__minor(int32_t _minor) {
1864 fbb_.AddElement<int32_t>(Version::VT__MINOR, _minor, 20);
1865 }
1866 void add__patch(int32_t _patch) {
1867 fbb_.AddElement<int32_t>(Version::VT__PATCH, _patch, 0);
1868 }
1869 void add__experimental(bool _experimental) {
1870 fbb_.AddElement<uint8_t>(Version::VT__EXPERIMENTAL, static_cast<uint8_t>(_experimental), 0);
1871 }
1872 explicit VersionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1873 : fbb_(_fbb) {
1874 start_ = fbb_.StartTable();
1875 }
1876 VersionBuilder &operator=(const VersionBuilder &);
1877 flatbuffers::Offset<Version> Finish() {
1878 const auto end = fbb_.EndTable(start_);
1879 auto o = flatbuffers::Offset<Version>(end);
1880 return o;
1881 }
1882};
1883
1884inline flatbuffers::Offset<Version> CreateVersion(
1885 flatbuffers::FlatBufferBuilder &_fbb,
1886 int32_t _major = 0,
1887 int32_t _minor = 20,
1888 int32_t _patch = 0,
1889 bool _experimental = false) {
1890 VersionBuilder builder_(_fbb);
1891 builder_.add__patch(_patch);
1892 builder_.add__minor(_minor);
1893 builder_.add__major(_major);
1894 builder_.add__experimental(_experimental);
1895 return builder_.Finish();
1896}
1897
1898struct TosaTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1899 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1900 VT_NAME = 4,
1901 VT_SHAPE = 6,
1902 VT_TYPE = 8,
1903 VT_USAGE = 10,
1904 VT_FORMAT = 12,
1905 VT_NPY_FILENAME = 14
1906 };
1907 const flatbuffers::String *name() const {
1908 return GetPointer<const flatbuffers::String *>(VT_NAME);
1909 }
1910 const flatbuffers::Vector<int32_t> *shape() const {
1911 return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE);
1912 }
1913 DType type() const {
1914 return static_cast<DType>(GetField<uint32_t>(VT_TYPE, 0));
1915 }
1916 const flatbuffers::Vector<uint32_t> *usage() const {
1917 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_USAGE);
1918 }
1919 const flatbuffers::Vector<uint32_t> *format() const {
1920 return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_FORMAT);
1921 }
1922 const flatbuffers::String *npy_filename() const {
1923 return GetPointer<const flatbuffers::String *>(VT_NPY_FILENAME);
1924 }
1925 bool Verify(flatbuffers::Verifier &verifier) const {
1926 return VerifyTableStart(verifier) &&
1927 VerifyOffset(verifier, VT_NAME) &&
1928 verifier.VerifyString(name()) &&
1929 VerifyOffset(verifier, VT_SHAPE) &&
1930 verifier.VerifyVector(shape()) &&
1931 VerifyField<uint32_t>(verifier, VT_TYPE) &&
1932 VerifyOffset(verifier, VT_USAGE) &&
1933 verifier.VerifyVector(usage()) &&
1934 VerifyOffset(verifier, VT_FORMAT) &&
1935 verifier.VerifyVector(format()) &&
1936 VerifyOffset(verifier, VT_NPY_FILENAME) &&
1937 verifier.VerifyString(npy_filename()) &&
1938 verifier.EndTable();
1939 }
1940};
1941
1942struct TosaTensorBuilder {
1943 flatbuffers::FlatBufferBuilder &fbb_;
1944 flatbuffers::uoffset_t start_;
1945 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
1946 fbb_.AddOffset(TosaTensor::VT_NAME, name);
1947 }
1948 void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) {
1949 fbb_.AddOffset(TosaTensor::VT_SHAPE, shape);
1950 }
1951 void add_type(DType type) {
1952 fbb_.AddElement<uint32_t>(TosaTensor::VT_TYPE, static_cast<uint32_t>(type), 0);
1953 }
1954 void add_usage(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> usage) {
1955 fbb_.AddOffset(TosaTensor::VT_USAGE, usage);
1956 }
1957 void add_format(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> format) {
1958 fbb_.AddOffset(TosaTensor::VT_FORMAT, format);
1959 }
1960 void add_npy_filename(flatbuffers::Offset<flatbuffers::String> npy_filename) {
1961 fbb_.AddOffset(TosaTensor::VT_NPY_FILENAME, npy_filename);
1962 }
1963 explicit TosaTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1964 : fbb_(_fbb) {
1965 start_ = fbb_.StartTable();
1966 }
1967 TosaTensorBuilder &operator=(const TosaTensorBuilder &);
1968 flatbuffers::Offset<TosaTensor> Finish() {
1969 const auto end = fbb_.EndTable(start_);
1970 auto o = flatbuffers::Offset<TosaTensor>(end);
1971 return o;
1972 }
1973};
1974
1975inline flatbuffers::Offset<TosaTensor> CreateTosaTensor(
1976 flatbuffers::FlatBufferBuilder &_fbb,
1977 flatbuffers::Offset<flatbuffers::String> name = 0,
1978 flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0,
1979 DType type = DType_UNKNOWN,
1980 flatbuffers::Offset<flatbuffers::Vector<uint32_t>> usage = 0,
1981 flatbuffers::Offset<flatbuffers::Vector<uint32_t>> format = 0,
1982 flatbuffers::Offset<flatbuffers::String> npy_filename = 0) {
1983 TosaTensorBuilder builder_(_fbb);
1984 builder_.add_npy_filename(npy_filename);
1985 builder_.add_format(format);
1986 builder_.add_usage(usage);
1987 builder_.add_type(type);
1988 builder_.add_shape(shape);
1989 builder_.add_name(name);
1990 return builder_.Finish();
1991}
1992
1993inline flatbuffers::Offset<TosaTensor> CreateTosaTensorDirect(
1994 flatbuffers::FlatBufferBuilder &_fbb,
1995 const char *name = nullptr,
1996 const std::vector<int32_t> *shape = nullptr,
1997 DType type = DType_UNKNOWN,
1998 const std::vector<uint32_t> *usage = nullptr,
1999 const std::vector<uint32_t> *format = nullptr,
2000 const char *npy_filename = nullptr) {
2001 auto name__ = name ? _fbb.CreateString(name) : 0;
2002 auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0;
2003 auto usage__ = usage ? _fbb.CreateVector<uint32_t>(*usage) : 0;
2004 auto format__ = format ? _fbb.CreateVector<uint32_t>(*format) : 0;
2005 auto npy_filename__ = npy_filename ? _fbb.CreateString(npy_filename) : 0;
2006 return tosa::CreateTosaTensor(
2007 _fbb,
2008 name__,
2009 shape__,
2010 type,
2011 usage__,
2012 format__,
2013 npy_filename__);
2014}
2015
2016struct TosaOperator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2017 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2018 VT_OP = 4,
2019 VT_ATTRIBUTE_TYPE = 6,
2020 VT_ATTRIBUTE = 8,
2021 VT_INPUTS = 10,
2022 VT_OUTPUTS = 12,
2023 VT_QUANT_INFO_TYPE = 14,
2024 VT_QUANT_INFO = 16
2025 };
2026 Op op() const {
2027 return static_cast<Op>(GetField<uint32_t>(VT_OP, 0));
2028 }
2029 Attribute attribute_type() const {
2030 return static_cast<Attribute>(GetField<uint8_t>(VT_ATTRIBUTE_TYPE, 0));
2031 }
2032 const void *attribute() const {
2033 return GetPointer<const void *>(VT_ATTRIBUTE);
2034 }
2035 template<typename T> const T *attribute_as() const;
2036 const Pool2dAttribute *attribute_as_Pool2dAttribute() const {
2037 return attribute_type() == Attribute_Pool2dAttribute ? static_cast<const Pool2dAttribute *>(attribute()) : nullptr;
2038 }
2039 const Conv2dAttribute *attribute_as_Conv2dAttribute() const {
2040 return attribute_type() == Attribute_Conv2dAttribute ? static_cast<const Conv2dAttribute *>(attribute()) : nullptr;
2041 }
2042 const TransposeConv2dAttribute *attribute_as_TransposeConv2dAttribute() const {
2043 return attribute_type() == Attribute_TransposeConv2dAttribute ? static_cast<const TransposeConv2dAttribute *>(attribute()) : nullptr;
2044 }
2045 const ReluNAttribute *attribute_as_ReluNAttribute() const {
2046 return attribute_type() == Attribute_ReluNAttribute ? static_cast<const ReluNAttribute *>(attribute()) : nullptr;
2047 }
2048 const AxisAttribute *attribute_as_AxisAttribute() const {
2049 return attribute_type() == Attribute_AxisAttribute ? static_cast<const AxisAttribute *>(attribute()) : nullptr;
2050 }
2051 const ReshapeAttribute *attribute_as_ReshapeAttribute() const {
2052 return attribute_type() == Attribute_ReshapeAttribute ? static_cast<const ReshapeAttribute *>(attribute()) : nullptr;
2053 }
2054 const SliceAttribute *attribute_as_SliceAttribute() const {
2055 return attribute_type() == Attribute_SliceAttribute ? static_cast<const SliceAttribute *>(attribute()) : nullptr;
2056 }
2057 const TileAttribute *attribute_as_TileAttribute() const {
2058 return attribute_type() == Attribute_TileAttribute ? static_cast<const TileAttribute *>(attribute()) : nullptr;
2059 }
2060 const ResizeAttribute *attribute_as_ResizeAttribute() const {
2061 return attribute_type() == Attribute_ResizeAttribute ? static_cast<const ResizeAttribute *>(attribute()) : nullptr;
2062 }
2063 const ClampAttribute *attribute_as_ClampAttribute() const {
2064 return attribute_type() == Attribute_ClampAttribute ? static_cast<const ClampAttribute *>(attribute()) : nullptr;
2065 }
2066 const RescaleAttribute *attribute_as_RescaleAttribute() const {
2067 return attribute_type() == Attribute_RescaleAttribute ? static_cast<const RescaleAttribute *>(attribute()) : nullptr;
2068 }
2069 const CustomAttribute *attribute_as_CustomAttribute() const {
2070 return attribute_type() == Attribute_CustomAttribute ? static_cast<const CustomAttribute *>(attribute()) : nullptr;
2071 }
2072 const CondIfAttribute *attribute_as_CondIfAttribute() const {
2073 return attribute_type() == Attribute_CondIfAttribute ? static_cast<const CondIfAttribute *>(attribute()) : nullptr;
2074 }
2075 const WhileLoopAttribute *attribute_as_WhileLoopAttribute() const {
2076 return attribute_type() == Attribute_WhileLoopAttribute ? static_cast<const WhileLoopAttribute *>(attribute()) : nullptr;
2077 }
2078 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *inputs() const {
2079 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_INPUTS);
2080 }
2081 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputs() const {
2082 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OUTPUTS);
2083 }
2084 QuantInfo quant_info_type() const {
2085 return static_cast<QuantInfo>(GetField<uint8_t>(VT_QUANT_INFO_TYPE, 0));
2086 }
2087 const void *quant_info() const {
2088 return GetPointer<const void *>(VT_QUANT_INFO);
2089 }
2090 template<typename T> const T *quant_info_as() const;
2091 const UnaryQuantInfo *quant_info_as_UnaryQuantInfo() const {
2092 return quant_info_type() == QuantInfo_UnaryQuantInfo ? static_cast<const UnaryQuantInfo *>(quant_info()) : nullptr;
2093 }
2094 const ConvQuantInfo *quant_info_as_ConvQuantInfo() const {
2095 return quant_info_type() == QuantInfo_ConvQuantInfo ? static_cast<const ConvQuantInfo *>(quant_info()) : nullptr;
2096 }
2097 const MatMulQuantInfo *quant_info_as_MatMulQuantInfo() const {
2098 return quant_info_type() == QuantInfo_MatMulQuantInfo ? static_cast<const MatMulQuantInfo *>(quant_info()) : nullptr;
2099 }
2100 const PadQuantInfo *quant_info_as_PadQuantInfo() const {
2101 return quant_info_type() == QuantInfo_PadQuantInfo ? static_cast<const PadQuantInfo *>(quant_info()) : nullptr;
2102 }
2103 bool Verify(flatbuffers::Verifier &verifier) const {
2104 return VerifyTableStart(verifier) &&
2105 VerifyField<uint32_t>(verifier, VT_OP) &&
2106 VerifyField<uint8_t>(verifier, VT_ATTRIBUTE_TYPE) &&
2107 VerifyOffset(verifier, VT_ATTRIBUTE) &&
2108 VerifyAttribute(verifier, attribute(), attribute_type()) &&
2109 VerifyOffset(verifier, VT_INPUTS) &&
2110 verifier.VerifyVector(inputs()) &&
2111 verifier.VerifyVectorOfStrings(inputs()) &&
2112 VerifyOffset(verifier, VT_OUTPUTS) &&
2113 verifier.VerifyVector(outputs()) &&
2114 verifier.VerifyVectorOfStrings(outputs()) &&
2115 VerifyField<uint8_t>(verifier, VT_QUANT_INFO_TYPE) &&
2116 VerifyOffset(verifier, VT_QUANT_INFO) &&
2117 VerifyQuantInfo(verifier, quant_info(), quant_info_type()) &&
2118 verifier.EndTable();
2119 }
2120};
2121
2122template<> inline const Pool2dAttribute *TosaOperator::attribute_as<Pool2dAttribute>() const {
2123 return attribute_as_Pool2dAttribute();
2124}
2125
2126template<> inline const Conv2dAttribute *TosaOperator::attribute_as<Conv2dAttribute>() const {
2127 return attribute_as_Conv2dAttribute();
2128}
2129
2130template<> inline const TransposeConv2dAttribute *TosaOperator::attribute_as<TransposeConv2dAttribute>() const {
2131 return attribute_as_TransposeConv2dAttribute();
2132}
2133
2134template<> inline const ReluNAttribute *TosaOperator::attribute_as<ReluNAttribute>() const {
2135 return attribute_as_ReluNAttribute();
2136}
2137
2138template<> inline const AxisAttribute *TosaOperator::attribute_as<AxisAttribute>() const {
2139 return attribute_as_AxisAttribute();
2140}
2141
2142template<> inline const ReshapeAttribute *TosaOperator::attribute_as<ReshapeAttribute>() const {
2143 return attribute_as_ReshapeAttribute();
2144}
2145
2146template<> inline const SliceAttribute *TosaOperator::attribute_as<SliceAttribute>() const {
2147 return attribute_as_SliceAttribute();
2148}
2149
2150template<> inline const TileAttribute *TosaOperator::attribute_as<TileAttribute>() const {
2151 return attribute_as_TileAttribute();
2152}
2153
2154template<> inline const ResizeAttribute *TosaOperator::attribute_as<ResizeAttribute>() const {
2155 return attribute_as_ResizeAttribute();
2156}
2157
2158template<> inline const ClampAttribute *TosaOperator::attribute_as<ClampAttribute>() const {
2159 return attribute_as_ClampAttribute();
2160}
2161
2162template<> inline const RescaleAttribute *TosaOperator::attribute_as<RescaleAttribute>() const {
2163 return attribute_as_RescaleAttribute();
2164}
2165
2166template<> inline const CustomAttribute *TosaOperator::attribute_as<CustomAttribute>() const {
2167 return attribute_as_CustomAttribute();
2168}
2169
2170template<> inline const CondIfAttribute *TosaOperator::attribute_as<CondIfAttribute>() const {
2171 return attribute_as_CondIfAttribute();
2172}
2173
2174template<> inline const WhileLoopAttribute *TosaOperator::attribute_as<WhileLoopAttribute>() const {
2175 return attribute_as_WhileLoopAttribute();
2176}
2177
2178template<> inline const UnaryQuantInfo *TosaOperator::quant_info_as<UnaryQuantInfo>() const {
2179 return quant_info_as_UnaryQuantInfo();
2180}
2181
2182template<> inline const ConvQuantInfo *TosaOperator::quant_info_as<ConvQuantInfo>() const {
2183 return quant_info_as_ConvQuantInfo();
2184}
2185
2186template<> inline const MatMulQuantInfo *TosaOperator::quant_info_as<MatMulQuantInfo>() const {
2187 return quant_info_as_MatMulQuantInfo();
2188}
2189
2190template<> inline const PadQuantInfo *TosaOperator::quant_info_as<PadQuantInfo>() const {
2191 return quant_info_as_PadQuantInfo();
2192}
2193
2194struct TosaOperatorBuilder {
2195 flatbuffers::FlatBufferBuilder &fbb_;
2196 flatbuffers::uoffset_t start_;
2197 void add_op(Op op) {
2198 fbb_.AddElement<uint32_t>(TosaOperator::VT_OP, static_cast<uint32_t>(op), 0);
2199 }
2200 void add_attribute_type(Attribute attribute_type) {
2201 fbb_.AddElement<uint8_t>(TosaOperator::VT_ATTRIBUTE_TYPE, static_cast<uint8_t>(attribute_type), 0);
2202 }
2203 void add_attribute(flatbuffers::Offset<void> attribute) {
2204 fbb_.AddOffset(TosaOperator::VT_ATTRIBUTE, attribute);
2205 }
2206 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs) {
2207 fbb_.AddOffset(TosaOperator::VT_INPUTS, inputs);
2208 }
2209 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs) {
2210 fbb_.AddOffset(TosaOperator::VT_OUTPUTS, outputs);
2211 }
2212 void add_quant_info_type(QuantInfo quant_info_type) {
2213 fbb_.AddElement<uint8_t>(TosaOperator::VT_QUANT_INFO_TYPE, static_cast<uint8_t>(quant_info_type), 0);
2214 }
2215 void add_quant_info(flatbuffers::Offset<void> quant_info) {
2216 fbb_.AddOffset(TosaOperator::VT_QUANT_INFO, quant_info);
2217 }
2218 explicit TosaOperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2219 : fbb_(_fbb) {
2220 start_ = fbb_.StartTable();
2221 }
2222 TosaOperatorBuilder &operator=(const TosaOperatorBuilder &);
2223 flatbuffers::Offset<TosaOperator> Finish() {
2224 const auto end = fbb_.EndTable(start_);
2225 auto o = flatbuffers::Offset<TosaOperator>(end);
2226 return o;
2227 }
2228};
2229
2230inline flatbuffers::Offset<TosaOperator> CreateTosaOperator(
2231 flatbuffers::FlatBufferBuilder &_fbb,
2232 Op op = Op_UNKNOWN,
2233 Attribute attribute_type = Attribute_NONE,
2234 flatbuffers::Offset<void> attribute = 0,
2235 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs = 0,
2236 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs = 0,
2237 QuantInfo quant_info_type = QuantInfo_NONE,
2238 flatbuffers::Offset<void> quant_info = 0) {
2239 TosaOperatorBuilder builder_(_fbb);
2240 builder_.add_quant_info(quant_info);
2241 builder_.add_outputs(outputs);
2242 builder_.add_inputs(inputs);
2243 builder_.add_attribute(attribute);
2244 builder_.add_op(op);
2245 builder_.add_quant_info_type(quant_info_type);
2246 builder_.add_attribute_type(attribute_type);
2247 return builder_.Finish();
2248}
2249
2250inline flatbuffers::Offset<TosaOperator> CreateTosaOperatorDirect(
2251 flatbuffers::FlatBufferBuilder &_fbb,
2252 Op op = Op_UNKNOWN,
2253 Attribute attribute_type = Attribute_NONE,
2254 flatbuffers::Offset<void> attribute = 0,
2255 const std::vector<flatbuffers::Offset<flatbuffers::String>> *inputs = nullptr,
2256 const std::vector<flatbuffers::Offset<flatbuffers::String>> *outputs = nullptr,
2257 QuantInfo quant_info_type = QuantInfo_NONE,
2258 flatbuffers::Offset<void> quant_info = 0) {
2259 auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*inputs) : 0;
2260 auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*outputs) : 0;
2261 return tosa::CreateTosaOperator(
2262 _fbb,
2263 op,
2264 attribute_type,
2265 attribute,
2266 inputs__,
2267 outputs__,
2268 quant_info_type,
2269 quant_info);
2270}
2271
2272struct TosaBasicBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2273 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2274 VT_NAME = 4,
2275 VT_OPERATORS = 6,
2276 VT_TENSORS = 8,
2277 VT_INPUTS = 10,
2278 VT_OUTPUTS = 12
2279 };
2280 const flatbuffers::String *name() const {
2281 return GetPointer<const flatbuffers::String *>(VT_NAME);
2282 }
2283 const flatbuffers::Vector<flatbuffers::Offset<TosaOperator>> *operators() const {
2284 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TosaOperator>> *>(VT_OPERATORS);
2285 }
2286 const flatbuffers::Vector<flatbuffers::Offset<TosaTensor>> *tensors() const {
2287 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TosaTensor>> *>(VT_TENSORS);
2288 }
2289 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *inputs() const {
2290 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_INPUTS);
2291 }
2292 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputs() const {
2293 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OUTPUTS);
2294 }
2295 bool Verify(flatbuffers::Verifier &verifier) const {
2296 return VerifyTableStart(verifier) &&
2297 VerifyOffset(verifier, VT_NAME) &&
2298 verifier.VerifyString(name()) &&
2299 VerifyOffset(verifier, VT_OPERATORS) &&
2300 verifier.VerifyVector(operators()) &&
2301 verifier.VerifyVectorOfTables(operators()) &&
2302 VerifyOffset(verifier, VT_TENSORS) &&
2303 verifier.VerifyVector(tensors()) &&
2304 verifier.VerifyVectorOfTables(tensors()) &&
2305 VerifyOffset(verifier, VT_INPUTS) &&
2306 verifier.VerifyVector(inputs()) &&
2307 verifier.VerifyVectorOfStrings(inputs()) &&
2308 VerifyOffset(verifier, VT_OUTPUTS) &&
2309 verifier.VerifyVector(outputs()) &&
2310 verifier.VerifyVectorOfStrings(outputs()) &&
2311 verifier.EndTable();
2312 }
2313};
2314
2315struct TosaBasicBlockBuilder {
2316 flatbuffers::FlatBufferBuilder &fbb_;
2317 flatbuffers::uoffset_t start_;
2318 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
2319 fbb_.AddOffset(TosaBasicBlock::VT_NAME, name);
2320 }
2321 void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaOperator>>> operators) {
2322 fbb_.AddOffset(TosaBasicBlock::VT_OPERATORS, operators);
2323 }
2324 void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaTensor>>> tensors) {
2325 fbb_.AddOffset(TosaBasicBlock::VT_TENSORS, tensors);
2326 }
2327 void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs) {
2328 fbb_.AddOffset(TosaBasicBlock::VT_INPUTS, inputs);
2329 }
2330 void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs) {
2331 fbb_.AddOffset(TosaBasicBlock::VT_OUTPUTS, outputs);
2332 }
2333 explicit TosaBasicBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2334 : fbb_(_fbb) {
2335 start_ = fbb_.StartTable();
2336 }
2337 TosaBasicBlockBuilder &operator=(const TosaBasicBlockBuilder &);
2338 flatbuffers::Offset<TosaBasicBlock> Finish() {
2339 const auto end = fbb_.EndTable(start_);
2340 auto o = flatbuffers::Offset<TosaBasicBlock>(end);
2341 return o;
2342 }
2343};
2344
2345inline flatbuffers::Offset<TosaBasicBlock> CreateTosaBasicBlock(
2346 flatbuffers::FlatBufferBuilder &_fbb,
2347 flatbuffers::Offset<flatbuffers::String> name = 0,
2348 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaOperator>>> operators = 0,
2349 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaTensor>>> tensors = 0,
2350 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs = 0,
2351 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs = 0) {
2352 TosaBasicBlockBuilder builder_(_fbb);
2353 builder_.add_outputs(outputs);
2354 builder_.add_inputs(inputs);
2355 builder_.add_tensors(tensors);
2356 builder_.add_operators(operators);
2357 builder_.add_name(name);
2358 return builder_.Finish();
2359}
2360
2361inline flatbuffers::Offset<TosaBasicBlock> CreateTosaBasicBlockDirect(
2362 flatbuffers::FlatBufferBuilder &_fbb,
2363 const char *name = nullptr,
2364 const std::vector<flatbuffers::Offset<TosaOperator>> *operators = nullptr,
2365 const std::vector<flatbuffers::Offset<TosaTensor>> *tensors = nullptr,
2366 const std::vector<flatbuffers::Offset<flatbuffers::String>> *inputs = nullptr,
2367 const std::vector<flatbuffers::Offset<flatbuffers::String>> *outputs = nullptr) {
2368 auto name__ = name ? _fbb.CreateString(name) : 0;
2369 auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<TosaOperator>>(*operators) : 0;
2370 auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<TosaTensor>>(*tensors) : 0;
2371 auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*inputs) : 0;
2372 auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*outputs) : 0;
2373 return tosa::CreateTosaBasicBlock(
2374 _fbb,
2375 name__,
2376 operators__,
2377 tensors__,
2378 inputs__,
2379 outputs__);
2380}
2381
2382struct TosaGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2383 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2384 VT_VERSION = 4,
2385 VT_BLOCKS = 6
2386 };
2387 const Version *version() const {
2388 return GetPointer<const Version *>(VT_VERSION);
2389 }
2390 const flatbuffers::Vector<flatbuffers::Offset<TosaBasicBlock>> *blocks() const {
2391 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TosaBasicBlock>> *>(VT_BLOCKS);
2392 }
2393 bool Verify(flatbuffers::Verifier &verifier) const {
2394 return VerifyTableStart(verifier) &&
2395 VerifyOffset(verifier, VT_VERSION) &&
2396 verifier.VerifyTable(version()) &&
2397 VerifyOffset(verifier, VT_BLOCKS) &&
2398 verifier.VerifyVector(blocks()) &&
2399 verifier.VerifyVectorOfTables(blocks()) &&
2400 verifier.EndTable();
2401 }
2402};
2403
2404struct TosaGraphBuilder {
2405 flatbuffers::FlatBufferBuilder &fbb_;
2406 flatbuffers::uoffset_t start_;
2407 void add_version(flatbuffers::Offset<Version> version) {
2408 fbb_.AddOffset(TosaGraph::VT_VERSION, version);
2409 }
2410 void add_blocks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaBasicBlock>>> blocks) {
2411 fbb_.AddOffset(TosaGraph::VT_BLOCKS, blocks);
2412 }
2413 explicit TosaGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2414 : fbb_(_fbb) {
2415 start_ = fbb_.StartTable();
2416 }
2417 TosaGraphBuilder &operator=(const TosaGraphBuilder &);
2418 flatbuffers::Offset<TosaGraph> Finish() {
2419 const auto end = fbb_.EndTable(start_);
2420 auto o = flatbuffers::Offset<TosaGraph>(end);
2421 return o;
2422 }
2423};
2424
2425inline flatbuffers::Offset<TosaGraph> CreateTosaGraph(
2426 flatbuffers::FlatBufferBuilder &_fbb,
2427 flatbuffers::Offset<Version> version = 0,
2428 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaBasicBlock>>> blocks = 0) {
2429 TosaGraphBuilder builder_(_fbb);
2430 builder_.add_blocks(blocks);
2431 builder_.add_version(version);
2432 return builder_.Finish();
2433}
2434
2435inline flatbuffers::Offset<TosaGraph> CreateTosaGraphDirect(
2436 flatbuffers::FlatBufferBuilder &_fbb,
2437 flatbuffers::Offset<Version> version = 0,
2438 const std::vector<flatbuffers::Offset<TosaBasicBlock>> *blocks = nullptr) {
2439 auto blocks__ = blocks ? _fbb.CreateVector<flatbuffers::Offset<TosaBasicBlock>>(*blocks) : 0;
2440 return tosa::CreateTosaGraph(
2441 _fbb,
2442 version,
2443 blocks__);
2444}
2445
2446inline bool VerifyAttribute(flatbuffers::Verifier &verifier, const void *obj, Attribute type) {
2447 switch (type) {
2448 case Attribute_NONE: {
2449 return true;
2450 }
2451 case Attribute_Pool2dAttribute: {
2452 auto ptr = reinterpret_cast<const Pool2dAttribute *>(obj);
2453 return verifier.VerifyTable(ptr);
2454 }
2455 case Attribute_Conv2dAttribute: {
2456 auto ptr = reinterpret_cast<const Conv2dAttribute *>(obj);
2457 return verifier.VerifyTable(ptr);
2458 }
2459 case Attribute_TransposeConv2dAttribute: {
2460 auto ptr = reinterpret_cast<const TransposeConv2dAttribute *>(obj);
2461 return verifier.VerifyTable(ptr);
2462 }
2463 case Attribute_ReluNAttribute: {
2464 auto ptr = reinterpret_cast<const ReluNAttribute *>(obj);
2465 return verifier.VerifyTable(ptr);
2466 }
2467 case Attribute_AxisAttribute: {
2468 auto ptr = reinterpret_cast<const AxisAttribute *>(obj);
2469 return verifier.VerifyTable(ptr);
2470 }
2471 case Attribute_ReshapeAttribute: {
2472 auto ptr = reinterpret_cast<const ReshapeAttribute *>(obj);
2473 return verifier.VerifyTable(ptr);
2474 }
2475 case Attribute_SliceAttribute: {
2476 auto ptr = reinterpret_cast<const SliceAttribute *>(obj);
2477 return verifier.VerifyTable(ptr);
2478 }
2479 case Attribute_TileAttribute: {
2480 auto ptr = reinterpret_cast<const TileAttribute *>(obj);
2481 return verifier.VerifyTable(ptr);
2482 }
2483 case Attribute_ResizeAttribute: {
2484 auto ptr = reinterpret_cast<const ResizeAttribute *>(obj);
2485 return verifier.VerifyTable(ptr);
2486 }
2487 case Attribute_ClampAttribute: {
2488 auto ptr = reinterpret_cast<const ClampAttribute *>(obj);
2489 return verifier.VerifyTable(ptr);
2490 }
2491 case Attribute_RescaleAttribute: {
2492 auto ptr = reinterpret_cast<const RescaleAttribute *>(obj);
2493 return verifier.VerifyTable(ptr);
2494 }
2495 case Attribute_CustomAttribute: {
2496 auto ptr = reinterpret_cast<const CustomAttribute *>(obj);
2497 return verifier.VerifyTable(ptr);
2498 }
2499 case Attribute_CondIfAttribute: {
2500 auto ptr = reinterpret_cast<const CondIfAttribute *>(obj);
2501 return verifier.VerifyTable(ptr);
2502 }
2503 case Attribute_WhileLoopAttribute: {
2504 auto ptr = reinterpret_cast<const WhileLoopAttribute *>(obj);
2505 return verifier.VerifyTable(ptr);
2506 }
2507 default: return false;
2508 }
2509}
2510
2511inline bool VerifyAttributeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
2512 if (!values || !types) return !values && !types;
2513 if (values->size() != types->size()) return false;
2514 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2515 if (!VerifyAttribute(
2516 verifier, values->Get(i), types->GetEnum<Attribute>(i))) {
2517 return false;
2518 }
2519 }
2520 return true;
2521}
2522
2523inline bool VerifyQuantInfo(flatbuffers::Verifier &verifier, const void *obj, QuantInfo type) {
2524 switch (type) {
2525 case QuantInfo_NONE: {
2526 return true;
2527 }
2528 case QuantInfo_UnaryQuantInfo: {
2529 auto ptr = reinterpret_cast<const UnaryQuantInfo *>(obj);
2530 return verifier.VerifyTable(ptr);
2531 }
2532 case QuantInfo_ConvQuantInfo: {
2533 auto ptr = reinterpret_cast<const ConvQuantInfo *>(obj);
2534 return verifier.VerifyTable(ptr);
2535 }
2536 case QuantInfo_MatMulQuantInfo: {
2537 auto ptr = reinterpret_cast<const MatMulQuantInfo *>(obj);
2538 return verifier.VerifyTable(ptr);
2539 }
2540 case QuantInfo_PadQuantInfo: {
2541 auto ptr = reinterpret_cast<const PadQuantInfo *>(obj);
2542 return verifier.VerifyTable(ptr);
2543 }
2544 default: return false;
2545 }
2546}
2547
2548inline bool VerifyQuantInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) {
2549 if (!values || !types) return !values && !types;
2550 if (values->size() != types->size()) return false;
2551 for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) {
2552 if (!VerifyQuantInfo(
2553 verifier, values->Get(i), types->GetEnum<QuantInfo>(i))) {
2554 return false;
2555 }
2556 }
2557 return true;
2558}
2559
2560inline const tosa::TosaGraph *GetTosaGraph(const void *buf) {
2561 return flatbuffers::GetRoot<tosa::TosaGraph>(buf);
2562}
2563
2564inline const tosa::TosaGraph *GetSizePrefixedTosaGraph(const void *buf) {
2565 return flatbuffers::GetSizePrefixedRoot<tosa::TosaGraph>(buf);
2566}
2567
2568inline const char *TosaGraphIdentifier() {
2569 return "TOSA";
2570}
2571
2572inline bool TosaGraphBufferHasIdentifier(const void *buf) {
2573 return flatbuffers::BufferHasIdentifier(
2574 buf, TosaGraphIdentifier());
2575}
2576
2577inline bool VerifyTosaGraphBuffer(
2578 flatbuffers::Verifier &verifier) {
2579 return verifier.VerifyBuffer<tosa::TosaGraph>(TosaGraphIdentifier());
2580}
2581
2582inline bool VerifySizePrefixedTosaGraphBuffer(
2583 flatbuffers::Verifier &verifier) {
2584 return verifier.VerifySizePrefixedBuffer<tosa::TosaGraph>(TosaGraphIdentifier());
2585}
2586
2587inline const char *TosaGraphExtension() {
2588 return "tosa";
2589}
2590
2591inline void FinishTosaGraphBuffer(
2592 flatbuffers::FlatBufferBuilder &fbb,
2593 flatbuffers::Offset<tosa::TosaGraph> root) {
2594 fbb.Finish(root, TosaGraphIdentifier());
2595}
2596
2597inline void FinishSizePrefixedTosaGraphBuffer(
2598 flatbuffers::FlatBufferBuilder &fbb,
2599 flatbuffers::Offset<tosa::TosaGraph> root) {
2600 fbb.FinishSizePrefixed(root, TosaGraphIdentifier());
2601}
2602
2603} // namespace tosa
2604
2605#endif // FLATBUFFERS_GENERATED_TOSA_TOSA_H_