diff options
Diffstat (limited to 'include')
| -rw-r--r-- | include/attribute.def | 98 | ||||
| -rw-r--r-- | include/attribute.h | 181 | ||||
| -rw-r--r-- | include/numpy_utils.h | 81 | ||||
| -rw-r--r-- | include/operator.def | 124 | ||||
| -rw-r--r-- | include/quant_info.def | 43 | ||||
| -rw-r--r-- | include/quant_info.h | 164 | ||||
| -rw-r--r-- | include/tosa_generated.h | 2649 | ||||
| -rw-r--r-- | include/tosa_serialization_handler.h | 349 |
8 files changed, 3689 insertions, 0 deletions
diff --git a/include/attribute.def b/include/attribute.def new file mode 100644 index 0000000..12b9c96 --- /dev/null +++ b/include/attribute.def @@ -0,0 +1,98 @@ + +// Copyright (c) 2020-2021, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + Syntax: + DEF_ATTRIBUTE(ATTRIBUTE_NAME, NUM_ARGS_IN_ATTRIBUTES, ARG0_TYPE, ARG0_SCALAR_OR_VECTOR, ARGS0_NAME, ...) + + Description: + ATTRIBUTE_NAME: corresponding attribute name, must match corresponding "table XXXAttribute" in tosa.fbs + NUM_ARGS_IN_ATTRIBUTES: number of arguments in this attribute + ARG0_TYPE: data type of arg0 in attribute + ARG0_SCALAR_OR_VECTOR: is arg0 a scalar(S) or a vector(V) + ARG0_NAME: name of arg0 + ...: variadic variables for more arguments, depending on NUM_ARGS_IN_ATTRIBUTES +*/ + +DEF_ATTRIBUTE(Pool2d, 3, + int32_t, V, padding, + int32_t, V, kernel, + int32_t, V, stride) + +DEF_ATTRIBUTE(Conv2d, 3, + int32_t, V, padding, + int32_t, V, stride, + int32_t, V, dilation) + +DEF_ATTRIBUTE(TransposeConv2d, 4, + int32_t, V, outpad, + int32_t, V, stride, + int32_t, V, dilation, + int32_t, V, output_shape) + +DEF_ATTRIBUTE(ReluN, 2, + int32_t, S, max_int, + float, S, max_fp) + +DEF_ATTRIBUTE(Axis, 1, + int32_t, S, axis) + +DEF_ATTRIBUTE(Reshape, 1, + int32_t, V, shape) + +DEF_ATTRIBUTE(Slice, 2, + int32_t, V, begin, + int32_t, V, size) + +DEF_ATTRIBUTE(Tile, 1, + int32_t, V, multiples) + +DEF_ATTRIBUTE(Resize, 7, + int32_t, V, output_size, + int32_t, V, stride, + int32_t, V, offset, + int32_t, S, shift, + float, V, stride_fp, + float, V, offset_fp, + ResizeMode, S, mode) + +DEF_ATTRIBUTE(Clamp, 4, + int32_t, S, min_int, + int32_t, S, max_int, + float, S, min_fp, + float, S, max_fp) + +DEF_ATTRIBUTE(Rescale, 7, + int32_t, S, input_zp, + int32_t, S, output_zp, + int32_t, V, multiplier, + int32_t, V, shift, + bool, S, scale32, + bool, S, double_round, + bool, S, per_channel) + +DEF_ATTRIBUTE(Mul, 1, + int32_t, S, shift) + +DEF_ATTRIBUTE(ArithmeticRightShift, 1, + bool, S, round) + +DEF_ATTRIBUTE(CondIf, 2, + string, S, then_branch, + string, S, else_branch) + +DEF_ATTRIBUTE(WhileLoop, 2, + string, S, cond_branch, + string, S, body_branch) diff --git a/include/attribute.h b/include/attribute.h new file mode 100644 index 0000000..ff354cb --- /dev/null +++ b/include/attribute.h @@ -0,0 +1,181 @@ + +// Copyright (c) 2020-2021, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef _TOSA_SERIALIZATION_ATTRIBUTE_H +#define _TOSA_SERIALIZATION_ATTRIBUTE_H +#include "flatbuffers/idl.h" +#include "flatbuffers/util.h" +#include "tosa_generated.h" + +using std::string; + +namespace tosa +{ + +class TosaAttributeBase +{ +public: + virtual ~TosaAttributeBase() + {} +}; + +class TosaNoneAttribute : public TosaAttributeBase +{ +public: + TosaNoneAttribute() + {} + TosaNoneAttribute(TosaNoneAttribute* p) + {} +}; + +#define DEF_ARGS_VER0_S_STR(V) _##V = p->V()->str(); +#define DEF_ARGS_VER0_S_DEFAULT(V) _##V = p->V(); + +#define DEF_ARGS_VER0_S_int32_t(V) DEF_ARGS_VER0_S_DEFAULT(V) +#define DEF_ARGS_VER0_S_float(V) DEF_ARGS_VER0_S_DEFAULT(V) +#define DEF_ARGS_VER0_S_bool(V) DEF_ARGS_VER0_S_DEFAULT(V) +#define DEF_ARGS_VER0_S_ResizeMode(V) DEF_ARGS_VER0_S_DEFAULT(V) +#define DEF_ARGS_VER0_S_string(V) DEF_ARGS_VER0_S_STR(V) + +#define DEF_ARGS_VER0_S(T, V) DEF_ARGS_VER0_S_##T(V) +#define DEF_ARGS_VER0_V(T, V) _##V = std::vector<T>(p->V()->begin(), p->V()->end()); + +#define DEF_ARGS_VER1_S(T, V) const T& V +#define DEF_ARGS_VER1_V(T, V) const std::vector<T>& V +#define DEF_ARGS_VER2_S(T, V) _##V = V; +#define DEF_ARGS_VER2_V(T, V) _##V = V; +#define DEF_ARGS_VER3_S(T, V) \ + T V() const \ + { \ + return _##V; \ + } +#define DEF_ARGS_VER3_V(T, V) \ + std::vector<T> V() const \ + { \ + return _##V; \ + } +#define DEF_ARGS_VER4_S(T, V) T _##V; +#define DEF_ARGS_VER4_V(T, V) std::vector<T> _##V; + +// another level of preprocessor indirection to handle ", " as function's input argument +#define DEF_ARGS_VER1_TRUE(T, F, V) DEF_ARGS_VER1_##F(T, V) +#define DEF_ARGS_VER1_FALSE(T, F, V) , DEF_ARGS_VER1_##F(T, V) + +#define DEF_ARGS_VER0(FIRST, T, F, V) DEF_ARGS_VER0_##F(T, V) +#define DEF_ARGS_VER1(FIRST, T, F, V) DEF_ARGS_VER1_##FIRST(T, F, V) +#define DEF_ARGS_VER2(FIRST, T, F, V) DEF_ARGS_VER2_##F(T, V) +#define DEF_ARGS_VER3(FIRST, T, F, V) DEF_ARGS_VER3_##F(T, V) +#define DEF_ARGS_VER4(FIRST, T, F, V) DEF_ARGS_VER4_##F(T, V) + +#define DEF_ARGS_0(VER, ...) +#define DEF_ARGS_1(VER, T0, F0, V0) DEF_ARGS_##VER(TRUE, T0, F0, V0) +#define DEF_ARGS_2(VER, T0, F0, V0, T1, F1, V1) DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) +#define DEF_ARGS_3(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) +#define DEF_ARGS_4(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) +#define DEF_ARGS_5(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) + +#define DEF_ARGS_6(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) + +#define DEF_ARGS_7(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) + +#define DEF_VER0_VAR_DECL_PTR(NAME) const NAME* p = static_cast<const NAME*>(options); +#define DEF_VER0_VAR_0(NAME) +#define DEF_VER0_VAR_1(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_2(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_3(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_4(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_5(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_6(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_7(NAME) DEF_VER0_VAR_DECL_PTR(NAME) + +#define DEF_ATTRIBUTE(NAME, NUM_ARGS, ...) \ + class Tosa##NAME##Attribute : public TosaAttributeBase \ + { \ + public: \ + Tosa##NAME##Attribute(const TosaAttributeBase* options) \ + { \ + const Tosa##NAME##Attribute* p = reinterpret_cast<const Tosa##NAME##Attribute*>(options); \ + *this = *p; \ + } \ + Tosa##NAME##Attribute(const Tosa##NAME##Attribute* p) \ + { \ + *this = *p; \ + } \ + Tosa##NAME##Attribute(const void* options){ DEF_VER0_VAR_##NUM_ARGS(NAME##Attribute) \ + DEF_ARGS_##NUM_ARGS(VER0, __VA_ARGS__) } Tosa##NAME \ + ##Attribute(DEF_ARGS_##NUM_ARGS(VER1, __VA_ARGS__)) \ + { \ + DEF_ARGS_##NUM_ARGS(VER2, __VA_ARGS__) \ + } \ + virtual ~Tosa##NAME##Attribute() \ + {} \ + DEF_ARGS_##NUM_ARGS(VER3, __VA_ARGS__) private : DEF_ARGS_##NUM_ARGS(VER4, __VA_ARGS__) \ + }; + +#include "attribute.def" +#undef DEF_ATTRIBUTE +#undef DEF_ARGS_0 +#undef DEF_ARGS_1 +#undef DEF_ARGS_2 +#undef DEF_ARGS_3 +#undef DEF_ARGS_4 +#undef DEF_ARGS_5 +#undef DEF_ARGS_6 +#undef DEF_ARGS_7 +#undef DEF_ARGS_VER0 +#undef DEF_ARGS_VER1 +#undef DEF_ARGS_VER2 +#undef DEF_ARGS_VER3 +#undef DEF_ARGS_VER4 +#undef DEF_ARGS_VER0_S_int32_t +#undef DEF_ARGS_VER0_S_float +#undef DEF_ARGS_VER0_S_bool +#undef DEF_ARGS_VER0_S_ResizeMode +#undef DEF_ARGS_VER0_S_string +#undef DEF_ARGS_VER0_S_STR +#undef DEF_ARGS_VER0_S_DEFAULT +#undef DEF_ARGS_VER1_TRUE +#undef DEF_ARGS_VER1_FALSE +#undef DEF_ARGS_VER0_S +#undef DEF_ARGS_VER0_V +#undef DEF_ARGS_VER1_S +#undef DEF_ARGS_VER1_V +#undef DEF_ARGS_VER2_S +#undef DEF_ARGS_VER2_V +#undef DEF_ARGS_VER3_S +#undef DEF_ARGS_VER3_V +#undef DEF_ARGS_VER4_S +#undef DEF_ARGS_VER4_V +#undef DEF_VER0_VAR_0 +#undef DEF_VER0_VAR_1 +#undef DEF_VER0_VAR_2 +#undef DEF_VER0_VAR_3 +#undef DEF_VER0_VAR_4 +#undef DEF_VER0_VAR_5 +#undef DEF_VER0_VAR_DECL_PTR + +} // namespace tosa + +#endif // _TOSA_SERIALIZATION_ATTRIBUTE_H diff --git a/include/numpy_utils.h b/include/numpy_utils.h new file mode 100644 index 0000000..c64bc17 --- /dev/null +++ b/include/numpy_utils.h @@ -0,0 +1,81 @@ + +// Copyright (c) 2020-2021, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef _TOSA_NUMPY_UTILS_H +#define _TOSA_NUMPY_UTILS_H + +#include <cassert> +#include <cctype> +#include <cstdint> +#include <cstdio> +#include <cstdlib> +#include <cstring> +#include <vector> + +class NumpyUtilities +{ +public: + enum NPError + { + NO_ERROR = 0, + FILE_NOT_FOUND, + FILE_IO_ERROR, + FILE_TYPE_MISMATCH, + HEADER_PARSE_ERROR, + BUFFER_SIZE_MISMATCH, + }; + + static NPError readFromNpyFile(const char* filename, const uint32_t elems, float* databuf); + + static NPError readFromNpyFile(const char* filename, const uint32_t elems, int32_t* databuf); + + static NPError readFromNpyFile(const char* filename, const uint32_t elems, int64_t* databuf); + + static NPError readFromNpyFile(const char* filename, const uint32_t elems, bool* databuf); + + static NPError writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const bool* databuf); + + static NPError writeToNpyFile(const char* filename, const uint32_t elems, const bool* databuf); + + static NPError writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const int32_t* databuf); + + static NPError writeToNpyFile(const char* filename, const uint32_t elems, const int32_t* databuf); + + static NPError writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const int64_t* databuf); + + static NPError writeToNpyFile(const char* filename, const uint32_t elems, const int64_t* databuf); + + static NPError writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const float* databuf); + + static NPError writeToNpyFile(const char* filename, const uint32_t elems, const float* databuf); + +private: + static NPError writeToNpyFileCommon(const char* filename, + const char* dtype_str, + const size_t elementsize, + const std::vector<int32_t>& shape, + const void* databuf, + bool bool_translate); + static NPError readFromNpyFileCommon(const char* filename, + const char* dtype_str, + const size_t elementsize, + const uint32_t elems, + void* databuf, + bool bool_translate); + static NPError checkNpyHeader(FILE* infile, const uint32_t elems, const char* dtype_str); + static NPError writeNpyHeader(FILE* outfile, const std::vector<int32_t>& shape, const char* dtype_str); +}; + +#endif // _TOSA_NUMPY_UTILS_H diff --git a/include/operator.def b/include/operator.def new file mode 100644 index 0000000..80ae547 --- /dev/null +++ b/include/operator.def @@ -0,0 +1,124 @@ + +// Copyright (c) 2020-2021, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + Syntax: + DEF_OPERATOR(MLIR_NAME, SCHEMA_NAME, REF_IMPL_NAME, OPTIONS, QUANT_INFO) + + Description: + MLIR_NAME: the symbolic string of this op, must match tosa_ops.td + SCHEMA_NAME: corresponding operator name, must match "enum Op" in serialization/tosa.fbs + REF_IMPL_NAME: name used internally in tosa reference implementation + OPTIONS: compile time constant options of this op, corresponding to operator_option.def + QUANT_INFO: quantization infomation of this op, corresponding to quant_info.def +*/ + + +/* tensor operators */ +DEF_OPERATOR(argmax, ARGMAX, ArgMax, Axis, None) +DEF_OPERATOR(avg_pool2d, AVG_POOL2D, AvgPool2d, Pool2d, Unary) +DEF_OPERATOR(conv2d, CONV2D, Conv2d, Conv2d, Conv) +DEF_OPERATOR(conv3d, CONV3D, Conv3d, None, None) +DEF_OPERATOR(depthwise_conv2d, DEPTHWISE_CONV2D, DepthwiseConv2d, Conv2d, Conv) +DEF_OPERATOR(fully_connected, FULLY_CONNECTED, FullyConnected, None, Conv) +DEF_OPERATOR(matmul, MATMUL, MatMul, None, MatMul) +DEF_OPERATOR(max_pool2d, MAX_POOL2D, MaxPool2d, Pool2d, None) +DEF_OPERATOR(transpose_conv2d, TRANSPOSE_CONV2D, TransposeConv2d, TransposeConv2d, Conv) + +/* activation */ +DEF_OPERATOR(clamp, CLAMP, Clamp, Clamp, None) +DEF_OPERATOR(reluN, RELUN, ReluN, ReluN, None) +DEF_OPERATOR(sigmoid, SIGMOID, Sigmoid, None, None) +DEF_OPERATOR(tanh, TANH, Tanh, None, None) + +/* elementwise - binary */ +DEF_OPERATOR(add, ADD, Add, None, None) +DEF_OPERATOR(arithmetic_right_shift, ARITHMETIC_RIGHT_SHIFT, ArithmeticRightShift, ArithmeticRightShift, None) +DEF_OPERATOR(bitwise_and, BITWISE_AND, BitwiseAnd, None, None) +DEF_OPERATOR(bitwise_or, BITWISE_OR, BitwiseOr, None, None) +DEF_OPERATOR(bitwise_xor, BITWISE_XOR, BitwiseXor, None, None) +DEF_OPERATOR(logical_and, LOGICAL_AND, LogicalAnd, None, None) +DEF_OPERATOR(logical_left_shift, LOGICAL_LEFT_SHIFT, LogicalLeftShift, None, None) +DEF_OPERATOR(logical_right_shift, LOGICAL_RIGHT_SHIFT, LogicalRightShift, None, None) +DEF_OPERATOR(logical_or, LOGICAL_OR, LogicalOr, None, None) +DEF_OPERATOR(logical_xor, LOGICAL_XOR, LogicalXor, None, None) +DEF_OPERATOR(maximum, MAXIMUM, Maximum, None, None) +DEF_OPERATOR(minimum, MINIMUM, Minimum, None, None) +DEF_OPERATOR(mul, MUL, Mul, Mul, None) +DEF_OPERATOR(pow, POW, Pow, None, None) +DEF_OPERATOR(sub, SUB, Sub, None, None) +DEF_OPERATOR(table, TABLE, Table, None, None) + +/* elementwise - unary */ +DEF_OPERATOR(abs, ABS, Abs, None, None) +DEF_OPERATOR(bitwise_not, BITWISE_NOT, BitwiseNot, None, None) +DEF_OPERATOR(ceil, CEIL, Ceil, None, None) +DEF_OPERATOR(clz, CLZ, Clz, None, None) +DEF_OPERATOR(exp, EXP, Exp, None, None) +DEF_OPERATOR(floor, FLOOR, Floor, None, None) +DEF_OPERATOR(log, LOG, Log, None, None) +DEF_OPERATOR(logical_not, LOGICAL_NOT, LogicalNot, None, None) +DEF_OPERATOR(negate, NEGATE, Negate, None, Unary) +DEF_OPERATOR(reciprocal, RECIPROCAL, Reciprocal, None, None) +DEF_OPERATOR(rsqrt, RSQRT, Rsqrt, None, None) + +/* elementwise - ternary */ +DEF_OPERATOR(select, SELECT, Select, None, None) + +/* logical */ +DEF_OPERATOR(equal, EQUAL, Equal, None, None) +DEF_OPERATOR(greater, GREATER, Greater, None, None) +DEF_OPERATOR(greater_equal, GREATER_EQUAL, GreaterEqual, None, None) + +/* reduction */ +DEF_OPERATOR(reduce_any, REDUCE_ANY, ReduceAny, Reduce, None) +DEF_OPERATOR(reduce_all, REDUCE_ALL, ReduceAll, Reduce, None) +DEF_OPERATOR(reduce_max, REDUCE_MAX, ReduceMax, Reduce, None) +DEF_OPERATOR(reduce_min, REDUCE_MIN, ReduceMin, Reduce, None) +DEF_OPERATOR(reduce_prod, REDUCE_PRODUCT, ReduceProduct, Reduce, None) +DEF_OPERATOR(reduce_sum, REDUCE_SUM, ReduceSum, Reduce, None) + +/* memory operation */ +DEF_OPERATOR(concat, CONCAT, Concat, Axis, None) +DEF_OPERATOR(pad, PAD, Pad, None, Pad) +DEF_OPERATOR(reshape, RESHAPE, Reshape, Reshape, None) +DEF_OPERATOR(reverse, REVERSE, Reverse, Reverse, None) +DEF_OPERATOR(slice, SLICE, Slice, Slice, None) +DEF_OPERATOR(tile, TILE, Tile, Tile, None) +DEF_OPERATOR(transpose, TRANSPOSE, Transpose, None, None) + +/* gather/scatter */ +DEF_OPERATOR(gather, GATHER, Gather, None, None) +DEF_OPERATOR(scatter, SCATTER, Scatter, None, None) + +/* image */ +DEF_OPERATOR(resize, RESIZE, Resize, Resize, None) + +/* quantization */ +DEF_OPERATOR(cast, CAST, Cast, None, None) +DEF_OPERATOR(rescale, RESCALE, Rescale, Rescale, None) + +/* data nodes */ +DEF_OPERATOR(const, CONST, Const, None, None) +DEF_OPERATOR(placeholder, PLACEHOLDER, Placeholder, None, None) +DEF_OPERATOR(identity, IDENTITY, Identity, None, None) +DEF_OPERATOR(identityn, IDENTITYN, IdentityN, None, None) + +/* custom operations */ +DEF_OPERATOR(custom, CUSTOM, Custom, None, None) + +/* control flow operators */ +DEF_OPERATOR(cond_if, COND_IF, CondIf, CondIf, None) +DEF_OPERATOR(while_loop, WHILE_LOOP, WhileLoop, WhileLoop, None) diff --git a/include/quant_info.def b/include/quant_info.def new file mode 100644 index 0000000..888c183 --- /dev/null +++ b/include/quant_info.def @@ -0,0 +1,43 @@ + +// Copyright (c) 2020-2021, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + Syntax: + DEF_QUANTIZATION_INFO(NAME, NUM_ARGS_IN_OPTIONS, ARG0_TYPE, ARG0_SCALAR_OR_VECTOR, ARGS0_NAME, ...) + + Description: + NAME: corresponding quantization info name, must match corresponding "table XXXQuantInfo" in tosa.fbs + NUM_ARGS_IN_QINFO: number of arguments in this quantization info + ARG0_TYPE: data type of arg0 + ARG0_SCALAR_OR_VECTOR: is arg0 a scalar (S) or a vector (V) + ARG0_NAME: name of arg0 + ...: variadic variables for more arguments, depending on NUM_ARGS_IN_QINFO +*/ + + +DEF_QUANTIZATION_INFO(Unary, 2, + int32_t, S, input_zp, + int32_t, S, output_zp) + +DEF_QUANTIZATION_INFO(Conv, 2, + int32_t, S, input_zp, + int32_t, S, weight_zp) + +DEF_QUANTIZATION_INFO(MatMul, 2, + int32_t, S, a_zp, + int32_t, S, b_zp) + +DEF_QUANTIZATION_INFO(Pad, 1, + int32_t, S, input_zp) diff --git a/include/quant_info.h b/include/quant_info.h new file mode 100644 index 0000000..d83063d --- /dev/null +++ b/include/quant_info.h @@ -0,0 +1,164 @@ + +// Copyright (c) 2020-2021, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef _TOSA_SERIALIZATION_QUANT_INFO_H +#define _TOSA_SERIALIZATION_QUANT_INFO_H +#include "flatbuffers/idl.h" +#include "flatbuffers/util.h" +#include "tosa_generated.h" + +namespace tosa +{ + +class TosaQuantInfoBase +{ +public: + virtual ~TosaQuantInfoBase() + {} +}; + +class TosaNoneQuantInfo : public TosaQuantInfoBase +{ +public: + TosaNoneQuantInfo() + {} + TosaNoneQuantInfo(TosaNoneQuantInfo* p) + {} +}; + +#define DEF_ARGS_VER0_S(T, V) _##V = p->V(); +#define DEF_ARGS_VER0_V(T, V) _##V = std::vector<T>(p->V()->begin(), p->V()->end()); +#define DEF_ARGS_VER1_S(T, V) const T& V +#define DEF_ARGS_VER1_V(T, V) const std::vector<T>& V +#define DEF_ARGS_VER2_S(T, V) _##V = V; +#define DEF_ARGS_VER2_V(T, V) _##V = V; +#define DEF_ARGS_VER3_S(T, V) \ + T V() const \ + { \ + return _##V; \ + } +#define DEF_ARGS_VER3_V(T, V) \ + std::vector<T> V() const \ + { \ + return _##V; \ + } +#define DEF_ARGS_VER4_S(T, V) T _##V; +#define DEF_ARGS_VER4_V(T, V) std::vector<T> _##V; + +// another level of preprocessor indirection to handle ", " as function's input argument +#define DEF_ARGS_VER1_TRUE(T, F, V) DEF_ARGS_VER1_##F(T, V) +#define DEF_ARGS_VER1_FALSE(T, F, V) , DEF_ARGS_VER1_##F(T, V) + +#define DEF_ARGS_VER0(FIRST, T, F, V) DEF_ARGS_VER0_##F(T, V) +#define DEF_ARGS_VER1(FIRST, T, F, V) DEF_ARGS_VER1_##FIRST(T, F, V) +#define DEF_ARGS_VER2(FIRST, T, F, V) DEF_ARGS_VER2_##F(T, V) +#define DEF_ARGS_VER3(FIRST, T, F, V) DEF_ARGS_VER3_##F(T, V) +#define DEF_ARGS_VER4(FIRST, T, F, V) DEF_ARGS_VER4_##F(T, V) + +#define DEF_ARGS_1(VER, T0, F0, V0) DEF_ARGS_##VER(TRUE, T0, F0, V0) +#define DEF_ARGS_2(VER, T0, F0, V0, T1, F1, V1) DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) +#define DEF_ARGS_3(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) +#define DEF_ARGS_4(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) +#define DEF_ARGS_5(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) +#define DEF_ARGS_6(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) +#define DEF_ARGS_7(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) +#define DEF_ARGS_8(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6, T7, F7, \ + V7) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) DEF_ARGS_##VER(FALSE, T7, F7, V7) +#define DEF_ARGS_9(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6, T7, F7, \ + V7, T8, F8, V8) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) DEF_ARGS_##VER(FALSE, T7, F7, V7) DEF_ARGS_##VER(FALSE, T8, F8, V8) +#define DEF_ARGS_10(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6, T7, F7, \ + V7, T8, F8, V8, T9, F9, V9) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) DEF_ARGS_##VER(FALSE, T7, F7, V7) DEF_ARGS_##VER(FALSE, T8, F8, V8) \ + DEF_ARGS_##VER(FALSE, T9, F9, V9) + +#define DEF_QUANTIZATION_INFO(NAME, NUM_ARGS, ...) \ + class Tosa##NAME##QuantInfo : public TosaQuantInfoBase \ + { \ + public: \ + Tosa##NAME##QuantInfo(const TosaQuantInfoBase* qinfo) \ + { \ + const Tosa##NAME##QuantInfo* p = dynamic_cast<const Tosa##NAME##QuantInfo*>(qinfo); \ + assert(p); \ + *this = *p; \ + } \ + Tosa##NAME##QuantInfo(const Tosa##NAME##QuantInfo* p) \ + { \ + *this = *p; \ + } \ + Tosa##NAME##QuantInfo(const void* qinfo) \ + { \ + const NAME##QuantInfo* p = static_cast<const NAME##QuantInfo*>(qinfo); \ + DEF_ARGS_##NUM_ARGS(VER0, __VA_ARGS__) \ + } \ + Tosa##NAME##QuantInfo(DEF_ARGS_##NUM_ARGS(VER1, __VA_ARGS__)) \ + { \ + DEF_ARGS_##NUM_ARGS(VER2, __VA_ARGS__) \ + } \ + virtual ~Tosa##NAME##QuantInfo() \ + {} \ + DEF_ARGS_##NUM_ARGS(VER3, __VA_ARGS__) private : DEF_ARGS_##NUM_ARGS(VER4, __VA_ARGS__) \ + }; + +#include "quant_info.def" +#undef DEF_QUANTIZATION_INFO +#undef DEF_ARGS_1 +#undef DEF_ARGS_2 +#undef DEF_ARGS_3 +#undef DEF_ARGS_4 +#undef DEF_ARGS_5 +#undef DEF_ARGS_6 +#undef DEF_ARGS_7 +#undef DEF_ARGS_8 +#undef DEF_ARGS_9 +#undef DEF_ARGS_10 +#undef DEF_ARGS_VER0 +#undef DEF_ARGS_VER1 +#undef DEF_ARGS_VER2 +#undef DEF_ARGS_VER3 +#undef DEF_ARGS_VER4 +#undef DEF_ARGS_VER1_TRUE +#undef DEF_ARGS_VER1_FALSE +#undef DEF_ARGS_VER0_S +#undef DEF_ARGS_VER0_V +#undef DEF_ARGS_VER1_S +#undef DEF_ARGS_VER1_V +#undef DEF_ARGS_VER2_S +#undef DEF_ARGS_VER2_V +#undef DEF_ARGS_VER3_S +#undef DEF_ARGS_VER3_V +#undef DEF_ARGS_VER4_S +#undef DEF_ARGS_VER4_V + +} // namespace tosa + +#endif diff --git a/include/tosa_generated.h b/include/tosa_generated.h new file mode 100644 index 0000000..5e883a1 --- /dev/null +++ b/include/tosa_generated.h @@ -0,0 +1,2649 @@ + +// Copyright (c) 2020-2021, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_TOSA_TOSA_H_ +#define FLATBUFFERS_GENERATED_TOSA_TOSA_H_ + +#include "flatbuffers/flatbuffers.h" + +namespace tosa { + +struct Pool2dAttribute; +struct Pool2dAttributeBuilder; + +struct Conv2dAttribute; +struct Conv2dAttributeBuilder; + +struct TransposeConv2dAttribute; +struct TransposeConv2dAttributeBuilder; + +struct ReluNAttribute; +struct ReluNAttributeBuilder; + +struct AxisAttribute; +struct AxisAttributeBuilder; + +struct ReshapeAttribute; +struct ReshapeAttributeBuilder; + +struct SliceAttribute; +struct SliceAttributeBuilder; + +struct TileAttribute; +struct TileAttributeBuilder; + +struct ResizeAttribute; +struct ResizeAttributeBuilder; + +struct ClampAttribute; +struct ClampAttributeBuilder; + +struct RescaleAttribute; +struct RescaleAttributeBuilder; + +struct MulAttribute; +struct MulAttributeBuilder; + +struct ArithmeticRightShiftAttribute; +struct ArithmeticRightShiftAttributeBuilder; + +struct CondIfAttribute; +struct CondIfAttributeBuilder; + +struct WhileLoopAttribute; +struct WhileLoopAttributeBuilder; + +struct UnaryQuantInfo; +struct UnaryQuantInfoBuilder; + +struct ConvQuantInfo; +struct ConvQuantInfoBuilder; + +struct MatMulQuantInfo; +struct MatMulQuantInfoBuilder; + +struct PadQuantInfo; +struct PadQuantInfoBuilder; + +struct Version; +struct VersionBuilder; + +struct TosaTensor; +struct TosaTensorBuilder; + +struct TosaOperator; +struct TosaOperatorBuilder; + +struct TosaBasicBlock; +struct TosaBasicBlockBuilder; + +struct TosaGraph; +struct TosaGraphBuilder; + +enum DType { + DType_UNKNOWN = 0, + DType_BOOL = 1, + DType_UINT8 = 2, + DType_INT4 = 3, + DType_INT8 = 4, + DType_INT16 = 5, + DType_INT32 = 6, + DType_INT48 = 7, + DType_FLOAT = 8, + DType_MIN = DType_UNKNOWN, + DType_MAX = DType_FLOAT +}; + +inline const DType (&EnumValuesDType())[9] { + static const DType values[] = { + DType_UNKNOWN, + DType_BOOL, + DType_UINT8, + DType_INT4, + DType_INT8, + DType_INT16, + DType_INT32, + DType_INT48, + DType_FLOAT + }; + return values; +} + +inline const char * const *EnumNamesDType() { + static const char * const names[10] = { + "UNKNOWN", + "BOOL", + "UINT8", + "INT4", + "INT8", + "INT16", + "INT32", + "INT48", + "FLOAT", + nullptr + }; + return names; +} + +inline const char *EnumNameDType(DType e) { + if (flatbuffers::IsOutRange(e, DType_UNKNOWN, DType_FLOAT)) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesDType()[index]; +} + +enum ResizeMode { + ResizeMode_UNKNOWN = 0, + ResizeMode_NEAREST = 1, + ResizeMode_BILINEAR = 2, + ResizeMode_MIN = ResizeMode_UNKNOWN, + ResizeMode_MAX = ResizeMode_BILINEAR +}; + +inline const ResizeMode (&EnumValuesResizeMode())[3] { + static const ResizeMode values[] = { + ResizeMode_UNKNOWN, + ResizeMode_NEAREST, + ResizeMode_BILINEAR + }; + return values; +} + +inline const char * const *EnumNamesResizeMode() { + static const char * const names[4] = { + "UNKNOWN", + "NEAREST", + "BILINEAR", + nullptr + }; + return names; +} + +inline const char *EnumNameResizeMode(ResizeMode e) { + if (flatbuffers::IsOutRange(e, ResizeMode_UNKNOWN, ResizeMode_BILINEAR)) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesResizeMode()[index]; +} + +enum Op { + Op_UNKNOWN = 0, + Op_ARGMAX = 1, + Op_AVG_POOL2D = 2, + Op_CONV2D = 3, + Op_CONV3D = 4, + Op_DEPTHWISE_CONV2D = 5, + Op_FULLY_CONNECTED = 6, + Op_MATMUL = 7, + Op_MAX_POOL2D = 8, + Op_TRANSPOSE_CONV2D = 9, + Op_CLAMP = 10, + Op_RELUN = 11, + Op_SIGMOID = 12, + Op_TANH = 13, + Op_ADD = 14, + Op_ARITHMETIC_RIGHT_SHIFT = 15, + Op_BITWISE_AND = 16, + Op_BITWISE_OR = 17, + Op_BITWISE_XOR = 18, + Op_LOGICAL_AND = 19, + Op_LOGICAL_LEFT_SHIFT = 20, + Op_LOGICAL_RIGHT_SHIFT = 21, + Op_LOGICAL_OR = 22, + Op_LOGICAL_XOR = 23, + Op_MAXIMUM = 24, + Op_MINIMUM = 25, + Op_MUL = 26, + Op_POW = 27, + Op_SUB = 28, + Op_TABLE = 29, + Op_ABS = 30, + Op_BITWISE_NOT = 31, + Op_CEIL = 32, + Op_CLZ = 33, + Op_EXP = 34, + Op_FLOOR = 35, + Op_LOG = 36, + Op_LOGICAL_NOT = 37, + Op_NEGATE = 38, + Op_RECIPROCAL = 39, + Op_RSQRT = 40, + Op_SELECT = 41, + Op_EQUAL = 42, + Op_GREATER = 43, + Op_GREATER_EQUAL = 44, + Op_REDUCE_ANY = 45, + Op_REDUCE_ALL = 46, + Op_REDUCE_MAX = 47, + Op_REDUCE_MIN = 48, + Op_REDUCE_PRODUCT = 49, + Op_REDUCE_SUM = 50, + Op_CONCAT = 51, + Op_PAD = 52, + Op_RESHAPE = 53, + Op_REVERSE = 54, + Op_SLICE = 55, + Op_TILE = 56, + Op_TRANSPOSE = 57, + Op_GATHER = 58, + Op_SCATTER = 59, + Op_RESIZE = 60, + Op_CAST = 61, + Op_RESCALE = 62, + Op_CONST = 63, + Op_PLACEHOLDER = 64, + Op_IDENTITY = 65, + Op_IDENTITYN = 66, + Op_CUSTOM = 67, + Op_COND_IF = 68, + Op_WHILE_LOOP = 69, + Op_MIN = Op_UNKNOWN, + Op_MAX = Op_WHILE_LOOP +}; + +inline const Op (&EnumValuesOp())[70] { + static const Op values[] = { + Op_UNKNOWN, + Op_ARGMAX, + Op_AVG_POOL2D, + Op_CONV2D, + Op_CONV3D, + Op_DEPTHWISE_CONV2D, + Op_FULLY_CONNECTED, + Op_MATMUL, + Op_MAX_POOL2D, + Op_TRANSPOSE_CONV2D, + Op_CLAMP, + Op_RELUN, + Op_SIGMOID, + Op_TANH, + Op_ADD, + Op_ARITHMETIC_RIGHT_SHIFT, + Op_BITWISE_AND, + Op_BITWISE_OR, + Op_BITWISE_XOR, + Op_LOGICAL_AND, + Op_LOGICAL_LEFT_SHIFT, + Op_LOGICAL_RIGHT_SHIFT, + Op_LOGICAL_OR, + Op_LOGICAL_XOR, + Op_MAXIMUM, + Op_MINIMUM, + Op_MUL, + Op_POW, + Op_SUB, + Op_TABLE, + Op_ABS, + Op_BITWISE_NOT, + Op_CEIL, + Op_CLZ, + Op_EXP, + Op_FLOOR, + Op_LOG, + Op_LOGICAL_NOT, + Op_NEGATE, + Op_RECIPROCAL, + Op_RSQRT, + Op_SELECT, + Op_EQUAL, + Op_GREATER, + Op_GREATER_EQUAL, + Op_REDUCE_ANY, + Op_REDUCE_ALL, + Op_REDUCE_MAX, + Op_REDUCE_MIN, + Op_REDUCE_PRODUCT, + Op_REDUCE_SUM, + Op_CONCAT, + Op_PAD, + Op_RESHAPE, + Op_REVERSE, + Op_SLICE, + Op_TILE, + Op_TRANSPOSE, + Op_GATHER, + Op_SCATTER, + Op_RESIZE, + Op_CAST, + Op_RESCALE, + Op_CONST, + Op_PLACEHOLDER, + Op_IDENTITY, + Op_IDENTITYN, + Op_CUSTOM, + Op_COND_IF, + Op_WHILE_LOOP + }; + return values; +} + +inline const char * const *EnumNamesOp() { + static const char * const names[71] = { + "UNKNOWN", + "ARGMAX", + "AVG_POOL2D", + "CONV2D", + "CONV3D", + "DEPTHWISE_CONV2D", + "FULLY_CONNECTED", + "MATMUL", + "MAX_POOL2D", + "TRANSPOSE_CONV2D", + "CLAMP", + "RELUN", + "SIGMOID", + "TANH", + "ADD", + "ARITHMETIC_RIGHT_SHIFT", + "BITWISE_AND", + "BITWISE_OR", + "BITWISE_XOR", + "LOGICAL_AND", + "LOGICAL_LEFT_SHIFT", + "LOGICAL_RIGHT_SHIFT", + "LOGICAL_OR", + "LOGICAL_XOR", + "MAXIMUM", + "MINIMUM", + "MUL", + "POW", + "SUB", + "TABLE", + "ABS", + "BITWISE_NOT", + "CEIL", + "CLZ", + "EXP", + "FLOOR", + "LOG", + "LOGICAL_NOT", + "NEGATE", + "RECIPROCAL", + "RSQRT", + "SELECT", + "EQUAL", + "GREATER", + "GREATER_EQUAL", + "REDUCE_ANY", + "REDUCE_ALL", + "REDUCE_MAX", + "REDUCE_MIN", + "REDUCE_PRODUCT", + "REDUCE_SUM", + "CONCAT", + "PAD", + "RESHAPE", + "REVERSE", + "SLICE", + "TILE", + "TRANSPOSE", + "GATHER", + "SCATTER", + "RESIZE", + "CAST", + "RESCALE", + "CONST", + "PLACEHOLDER", + "IDENTITY", + "IDENTITYN", + "CUSTOM", + "COND_IF", + "WHILE_LOOP", + nullptr + }; + return names; +} + +inline const char *EnumNameOp(Op e) { + if (flatbuffers::IsOutRange(e, Op_UNKNOWN, Op_WHILE_LOOP)) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesOp()[index]; +} + +enum Attribute { + Attribute_NONE = 0, + Attribute_Pool2dAttribute = 1, + Attribute_Conv2dAttribute = 2, + Attribute_TransposeConv2dAttribute = 3, + Attribute_ReluNAttribute = 4, + Attribute_AxisAttribute = 5, + Attribute_ReshapeAttribute = 6, + Attribute_SliceAttribute = 7, + Attribute_TileAttribute = 8, + Attribute_ResizeAttribute = 9, + Attribute_ClampAttribute = 10, + Attribute_RescaleAttribute = 11, + Attribute_MulAttribute = 12, + Attribute_ArithmeticRightShiftAttribute = 13, + Attribute_CondIfAttribute = 14, + Attribute_WhileLoopAttribute = 15, + Attribute_MIN = Attribute_NONE, + Attribute_MAX = Attribute_WhileLoopAttribute +}; + +inline const Attribute (&EnumValuesAttribute())[16] { + static const Attribute values[] = { + Attribute_NONE, + Attribute_Pool2dAttribute, + Attribute_Conv2dAttribute, + Attribute_TransposeConv2dAttribute, + Attribute_ReluNAttribute, + Attribute_AxisAttribute, + Attribute_ReshapeAttribute, + Attribute_SliceAttribute, + Attribute_TileAttribute, + Attribute_ResizeAttribute, + Attribute_ClampAttribute, + Attribute_RescaleAttribute, + Attribute_MulAttribute, + Attribute_ArithmeticRightShiftAttribute, + Attribute_CondIfAttribute, + Attribute_WhileLoopAttribute + }; + return values; +} + +inline const char * const *EnumNamesAttribute() { + static const char * const names[17] = { + "NONE", + "Pool2dAttribute", + "Conv2dAttribute", + "TransposeConv2dAttribute", + "ReluNAttribute", + "AxisAttribute", + "ReshapeAttribute", + "SliceAttribute", + "TileAttribute", + "ResizeAttribute", + "ClampAttribute", + "RescaleAttribute", + "MulAttribute", + "ArithmeticRightShiftAttribute", + "CondIfAttribute", + "WhileLoopAttribute", + nullptr + }; + return names; +} + +inline const char *EnumNameAttribute(Attribute e) { + if (flatbuffers::IsOutRange(e, Attribute_NONE, Attribute_WhileLoopAttribute)) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesAttribute()[index]; +} + +template<typename T> struct AttributeTraits { + static const Attribute enum_value = Attribute_NONE; +}; + +template<> struct AttributeTraits<tosa::Pool2dAttribute> { + static const Attribute enum_value = Attribute_Pool2dAttribute; +}; + +template<> struct AttributeTraits<tosa::Conv2dAttribute> { + static const Attribute enum_value = Attribute_Conv2dAttribute; +}; + +template<> struct AttributeTraits<tosa::TransposeConv2dAttribute> { + static const Attribute enum_value = Attribute_TransposeConv2dAttribute; +}; + +template<> struct AttributeTraits<tosa::ReluNAttribute> { + static const Attribute enum_value = Attribute_ReluNAttribute; +}; + +template<> struct AttributeTraits<tosa::AxisAttribute> { + static const Attribute enum_value = Attribute_AxisAttribute; +}; + +template<> struct AttributeTraits<tosa::ReshapeAttribute> { + static const Attribute enum_value = Attribute_ReshapeAttribute; +}; + +template<> struct AttributeTraits<tosa::SliceAttribute> { + static const Attribute enum_value = Attribute_SliceAttribute; +}; + +template<> struct AttributeTraits<tosa::TileAttribute> { + static const Attribute enum_value = Attribute_TileAttribute; +}; + +template<> struct AttributeTraits<tosa::ResizeAttribute> { + static const Attribute enum_value = Attribute_ResizeAttribute; +}; + +template<> struct AttributeTraits<tosa::ClampAttribute> { + static const Attribute enum_value = Attribute_ClampAttribute; +}; + +template<> struct AttributeTraits<tosa::RescaleAttribute> { + static const Attribute enum_value = Attribute_RescaleAttribute; +}; + +template<> struct AttributeTraits<tosa::MulAttribute> { + static const Attribute enum_value = Attribute_MulAttribute; +}; + +template<> struct AttributeTraits<tosa::ArithmeticRightShiftAttribute> { + static const Attribute enum_value = Attribute_ArithmeticRightShiftAttribute; +}; + +template<> struct AttributeTraits<tosa::CondIfAttribute> { + static const Attribute enum_value = Attribute_CondIfAttribute; +}; + +template<> struct AttributeTraits<tosa::WhileLoopAttribute> { + static const Attribute enum_value = Attribute_WhileLoopAttribute; +}; + +bool VerifyAttribute(flatbuffers::Verifier &verifier, const void *obj, Attribute type); +bool VerifyAttributeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); + +enum QuantInfo { + QuantInfo_NONE = 0, + QuantInfo_UnaryQuantInfo = 1, + QuantInfo_ConvQuantInfo = 2, + QuantInfo_MatMulQuantInfo = 3, + QuantInfo_PadQuantInfo = 4, + QuantInfo_MIN = QuantInfo_NONE, + QuantInfo_MAX = QuantInfo_PadQuantInfo +}; + +inline const QuantInfo (&EnumValuesQuantInfo())[5] { + static const QuantInfo values[] = { + QuantInfo_NONE, + QuantInfo_UnaryQuantInfo, + QuantInfo_ConvQuantInfo, + QuantInfo_MatMulQuantInfo, + QuantInfo_PadQuantInfo + }; + return values; +} + +inline const char * const *EnumNamesQuantInfo() { + static const char * const names[6] = { + "NONE", + "UnaryQuantInfo", + "ConvQuantInfo", + "MatMulQuantInfo", + "PadQuantInfo", + nullptr + }; + return names; +} + +inline const char *EnumNameQuantInfo(QuantInfo e) { + if (flatbuffers::IsOutRange(e, QuantInfo_NONE, QuantInfo_PadQuantInfo)) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesQuantInfo()[index]; +} + +template<typename T> struct QuantInfoTraits { + static const QuantInfo enum_value = QuantInfo_NONE; +}; + +template<> struct QuantInfoTraits<tosa::UnaryQuantInfo> { + static const QuantInfo enum_value = QuantInfo_UnaryQuantInfo; +}; + +template<> struct QuantInfoTraits<tosa::ConvQuantInfo> { + static const QuantInfo enum_value = QuantInfo_ConvQuantInfo; +}; + +template<> struct QuantInfoTraits<tosa::MatMulQuantInfo> { + static const QuantInfo enum_value = QuantInfo_MatMulQuantInfo; +}; + +template<> struct QuantInfoTraits<tosa::PadQuantInfo> { + static const QuantInfo enum_value = QuantInfo_PadQuantInfo; +}; + +bool VerifyQuantInfo(flatbuffers::Verifier &verifier, const void *obj, QuantInfo type); +bool VerifyQuantInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); + +struct Pool2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Pool2dAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PADDING = 4, + VT_KERNEL = 6, + VT_STRIDE = 8 + }; + const flatbuffers::Vector<int32_t> *padding() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_PADDING); + } + const flatbuffers::Vector<int32_t> *kernel() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_KERNEL); + } + const flatbuffers::Vector<int32_t> *stride() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PADDING) && + verifier.VerifyVector(padding()) && + VerifyOffset(verifier, VT_KERNEL) && + verifier.VerifyVector(kernel()) && + VerifyOffset(verifier, VT_STRIDE) && + verifier.VerifyVector(stride()) && + verifier.EndTable(); + } +}; + +struct Pool2dAttributeBuilder { + typedef Pool2dAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padding(flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding) { + fbb_.AddOffset(Pool2dAttribute::VT_PADDING, padding); + } + void add_kernel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> kernel) { + fbb_.AddOffset(Pool2dAttribute::VT_KERNEL, kernel); + } + void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) { + fbb_.AddOffset(Pool2dAttribute::VT_STRIDE, stride); + } + explicit Pool2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Pool2dAttributeBuilder &operator=(const Pool2dAttributeBuilder &); + flatbuffers::Offset<Pool2dAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<Pool2dAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<Pool2dAttribute> CreatePool2dAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> kernel = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0) { + Pool2dAttributeBuilder builder_(_fbb); + builder_.add_stride(stride); + builder_.add_kernel(kernel); + builder_.add_padding(padding); + return builder_.Finish(); +} + +inline flatbuffers::Offset<Pool2dAttribute> CreatePool2dAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *padding = nullptr, + const std::vector<int32_t> *kernel = nullptr, + const std::vector<int32_t> *stride = nullptr) { + auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0; + auto kernel__ = kernel ? _fbb.CreateVector<int32_t>(*kernel) : 0; + auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0; + return tosa::CreatePool2dAttribute( + _fbb, + padding__, + kernel__, + stride__); +} + +struct Conv2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef Conv2dAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PADDING = 4, + VT_STRIDE = 6, + VT_DILATION = 8 + }; + const flatbuffers::Vector<int32_t> *padding() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_PADDING); + } + const flatbuffers::Vector<int32_t> *stride() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE); + } + const flatbuffers::Vector<int32_t> *dilation() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DILATION); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PADDING) && + verifier.VerifyVector(padding()) && + VerifyOffset(verifier, VT_STRIDE) && + verifier.VerifyVector(stride()) && + VerifyOffset(verifier, VT_DILATION) && + verifier.VerifyVector(dilation()) && + verifier.EndTable(); + } +}; + +struct Conv2dAttributeBuilder { + typedef Conv2dAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padding(flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding) { + fbb_.AddOffset(Conv2dAttribute::VT_PADDING, padding); + } + void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) { + fbb_.AddOffset(Conv2dAttribute::VT_STRIDE, stride); + } + void add_dilation(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation) { + fbb_.AddOffset(Conv2dAttribute::VT_DILATION, dilation); + } + explicit Conv2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Conv2dAttributeBuilder &operator=(const Conv2dAttributeBuilder &); + flatbuffers::Offset<Conv2dAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<Conv2dAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<Conv2dAttribute> CreateConv2dAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation = 0) { + Conv2dAttributeBuilder builder_(_fbb); + builder_.add_dilation(dilation); + builder_.add_stride(stride); + builder_.add_padding(padding); + return builder_.Finish(); +} + +inline flatbuffers::Offset<Conv2dAttribute> CreateConv2dAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *padding = nullptr, + const std::vector<int32_t> *stride = nullptr, + const std::vector<int32_t> *dilation = nullptr) { + auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0; + auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0; + auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0; + return tosa::CreateConv2dAttribute( + _fbb, + padding__, + stride__, + dilation__); +} + +struct TransposeConv2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TransposeConv2dAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OUTPAD = 4, + VT_STRIDE = 6, + VT_DILATION = 8, + VT_OUTPUT_SHAPE = 10 + }; + const flatbuffers::Vector<int32_t> *outpad() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPAD); + } + const flatbuffers::Vector<int32_t> *stride() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE); + } + const flatbuffers::Vector<int32_t> *dilation() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DILATION); + } + const flatbuffers::Vector<int32_t> *output_shape() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUT_SHAPE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_OUTPAD) && + verifier.VerifyVector(outpad()) && + VerifyOffset(verifier, VT_STRIDE) && + verifier.VerifyVector(stride()) && + VerifyOffset(verifier, VT_DILATION) && + verifier.VerifyVector(dilation()) && + VerifyOffset(verifier, VT_OUTPUT_SHAPE) && + verifier.VerifyVector(output_shape()) && + verifier.EndTable(); + } +}; + +struct TransposeConv2dAttributeBuilder { + typedef TransposeConv2dAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_outpad(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outpad) { + fbb_.AddOffset(TransposeConv2dAttribute::VT_OUTPAD, outpad); + } + void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) { + fbb_.AddOffset(TransposeConv2dAttribute::VT_STRIDE, stride); + } + void add_dilation(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation) { + fbb_.AddOffset(TransposeConv2dAttribute::VT_DILATION, dilation); + } + void add_output_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_shape) { + fbb_.AddOffset(TransposeConv2dAttribute::VT_OUTPUT_SHAPE, output_shape); + } + explicit TransposeConv2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TransposeConv2dAttributeBuilder &operator=(const TransposeConv2dAttributeBuilder &); + flatbuffers::Offset<TransposeConv2dAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TransposeConv2dAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<TransposeConv2dAttribute> CreateTransposeConv2dAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> outpad = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_shape = 0) { + TransposeConv2dAttributeBuilder builder_(_fbb); + builder_.add_output_shape(output_shape); + builder_.add_dilation(dilation); + builder_.add_stride(stride); + builder_.add_outpad(outpad); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TransposeConv2dAttribute> CreateTransposeConv2dAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *outpad = nullptr, + const std::vector<int32_t> *stride = nullptr, + const std::vector<int32_t> *dilation = nullptr, + const std::vector<int32_t> *output_shape = nullptr) { + auto outpad__ = outpad ? _fbb.CreateVector<int32_t>(*outpad) : 0; + auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0; + auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0; + auto output_shape__ = output_shape ? _fbb.CreateVector<int32_t>(*output_shape) : 0; + return tosa::CreateTransposeConv2dAttribute( + _fbb, + outpad__, + stride__, + dilation__, + output_shape__); +} + +struct ReluNAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ReluNAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MAX_INT = 4, + VT_MAX_FP = 6 + }; + int32_t max_int() const { + return GetField<int32_t>(VT_MAX_INT, 0); + } + float max_fp() const { + return GetField<float>(VT_MAX_FP, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_MAX_INT) && + VerifyField<float>(verifier, VT_MAX_FP) && + verifier.EndTable(); + } +}; + +struct ReluNAttributeBuilder { + typedef ReluNAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_max_int(int32_t max_int) { + fbb_.AddElement<int32_t>(ReluNAttribute::VT_MAX_INT, max_int, 0); + } + void add_max_fp(float max_fp) { + fbb_.AddElement<float>(ReluNAttribute::VT_MAX_FP, max_fp, 0.0f); + } + explicit ReluNAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ReluNAttributeBuilder &operator=(const ReluNAttributeBuilder &); + flatbuffers::Offset<ReluNAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ReluNAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<ReluNAttribute> CreateReluNAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t max_int = 0, + float max_fp = 0.0f) { + ReluNAttributeBuilder builder_(_fbb); + builder_.add_max_fp(max_fp); + builder_.add_max_int(max_int); + return builder_.Finish(); +} + +struct AxisAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef AxisAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_AXIS = 4 + }; + int32_t axis() const { + return GetField<int32_t>(VT_AXIS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_AXIS) && + verifier.EndTable(); + } +}; + +struct AxisAttributeBuilder { + typedef AxisAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_axis(int32_t axis) { + fbb_.AddElement<int32_t>(AxisAttribute::VT_AXIS, axis, 0); + } + explicit AxisAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + AxisAttributeBuilder &operator=(const AxisAttributeBuilder &); + flatbuffers::Offset<AxisAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<AxisAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<AxisAttribute> CreateAxisAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t axis = 0) { + AxisAttributeBuilder builder_(_fbb); + builder_.add_axis(axis); + return builder_.Finish(); +} + +struct ReshapeAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ReshapeAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_SHAPE = 4 + }; + const flatbuffers::Vector<int32_t> *shape() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_SHAPE) && + verifier.VerifyVector(shape()) && + verifier.EndTable(); + } +}; + +struct ReshapeAttributeBuilder { + typedef ReshapeAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) { + fbb_.AddOffset(ReshapeAttribute::VT_SHAPE, shape); + } + explicit ReshapeAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ReshapeAttributeBuilder &operator=(const ReshapeAttributeBuilder &); + flatbuffers::Offset<ReshapeAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ReshapeAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<ReshapeAttribute> CreateReshapeAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0) { + ReshapeAttributeBuilder builder_(_fbb); + builder_.add_shape(shape); + return builder_.Finish(); +} + +inline flatbuffers::Offset<ReshapeAttribute> CreateReshapeAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *shape = nullptr) { + auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0; + return tosa::CreateReshapeAttribute( + _fbb, + shape__); +} + +struct SliceAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef SliceAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BEGIN = 4, + VT_SIZE = 6 + }; + const flatbuffers::Vector<int32_t> *begin() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BEGIN); + } + const flatbuffers::Vector<int32_t> *size() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SIZE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BEGIN) && + verifier.VerifyVector(begin()) && + VerifyOffset(verifier, VT_SIZE) && + verifier.VerifyVector(size()) && + verifier.EndTable(); + } +}; + +struct SliceAttributeBuilder { + typedef SliceAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_begin(flatbuffers::Offset<flatbuffers::Vector<int32_t>> begin) { + fbb_.AddOffset(SliceAttribute::VT_BEGIN, begin); + } + void add_size(flatbuffers::Offset<flatbuffers::Vector<int32_t>> size) { + fbb_.AddOffset(SliceAttribute::VT_SIZE, size); + } + explicit SliceAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SliceAttributeBuilder &operator=(const SliceAttributeBuilder &); + flatbuffers::Offset<SliceAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<SliceAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<SliceAttribute> CreateSliceAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> begin = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> size = 0) { + SliceAttributeBuilder builder_(_fbb); + builder_.add_size(size); + builder_.add_begin(begin); + return builder_.Finish(); +} + +inline flatbuffers::Offset<SliceAttribute> CreateSliceAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *begin = nullptr, + const std::vector<int32_t> *size = nullptr) { + auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0; + auto size__ = size ? _fbb.CreateVector<int32_t>(*size) : 0; + return tosa::CreateSliceAttribute( + _fbb, + begin__, + size__); +} + +struct TileAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TileAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MULTIPLES = 4 + }; + const flatbuffers::Vector<int32_t> *multiples() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_MULTIPLES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_MULTIPLES) && + verifier.VerifyVector(multiples()) && + verifier.EndTable(); + } +}; + +struct TileAttributeBuilder { + typedef TileAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_multiples(flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiples) { + fbb_.AddOffset(TileAttribute::VT_MULTIPLES, multiples); + } + explicit TileAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TileAttributeBuilder &operator=(const TileAttributeBuilder &); + flatbuffers::Offset<TileAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TileAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<TileAttribute> CreateTileAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiples = 0) { + TileAttributeBuilder builder_(_fbb); + builder_.add_multiples(multiples); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TileAttribute> CreateTileAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *multiples = nullptr) { + auto multiples__ = multiples ? _fbb.CreateVector<int32_t>(*multiples) : 0; + return tosa::CreateTileAttribute( + _fbb, + multiples__); +} + +struct ResizeAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ResizeAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OUTPUT_SIZE = 4, + VT_STRIDE = 6, + VT_OFFSET = 8, + VT_SHIFT = 10, + VT_STRIDE_FP = 12, + VT_OFFSET_FP = 14, + VT_MODE = 16 + }; + const flatbuffers::Vector<int32_t> *output_size() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUT_SIZE); + } + const flatbuffers::Vector<int32_t> *stride() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE); + } + const flatbuffers::Vector<int32_t> *offset() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OFFSET); + } + int32_t shift() const { + return GetField<int32_t>(VT_SHIFT, 0); + } + const flatbuffers::Vector<float> *stride_fp() const { + return GetPointer<const flatbuffers::Vector<float> *>(VT_STRIDE_FP); + } + const flatbuffers::Vector<float> *offset_fp() const { + return GetPointer<const flatbuffers::Vector<float> *>(VT_OFFSET_FP); + } + tosa::ResizeMode mode() const { + return static_cast<tosa::ResizeMode>(GetField<uint32_t>(VT_MODE, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_OUTPUT_SIZE) && + verifier.VerifyVector(output_size()) && + VerifyOffset(verifier, VT_STRIDE) && + verifier.VerifyVector(stride()) && + VerifyOffset(verifier, VT_OFFSET) && + verifier.VerifyVector(offset()) && + VerifyField<int32_t>(verifier, VT_SHIFT) && + VerifyOffset(verifier, VT_STRIDE_FP) && + verifier.VerifyVector(stride_fp()) && + VerifyOffset(verifier, VT_OFFSET_FP) && + verifier.VerifyVector(offset_fp()) && + VerifyField<uint32_t>(verifier, VT_MODE) && + verifier.EndTable(); + } +}; + +struct ResizeAttributeBuilder { + typedef ResizeAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_output_size(flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_size) { + fbb_.AddOffset(ResizeAttribute::VT_OUTPUT_SIZE, output_size); + } + void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) { + fbb_.AddOffset(ResizeAttribute::VT_STRIDE, stride); + } + void add_offset(flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset) { + fbb_.AddOffset(ResizeAttribute::VT_OFFSET, offset); + } + void add_shift(int32_t shift) { + fbb_.AddElement<int32_t>(ResizeAttribute::VT_SHIFT, shift, 0); + } + void add_stride_fp(flatbuffers::Offset<flatbuffers::Vector<float>> stride_fp) { + fbb_.AddOffset(ResizeAttribute::VT_STRIDE_FP, stride_fp); + } + void add_offset_fp(flatbuffers::Offset<flatbuffers::Vector<float>> offset_fp) { + fbb_.AddOffset(ResizeAttribute::VT_OFFSET_FP, offset_fp); + } + void add_mode(tosa::ResizeMode mode) { + fbb_.AddElement<uint32_t>(ResizeAttribute::VT_MODE, static_cast<uint32_t>(mode), 0); + } + explicit ResizeAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ResizeAttributeBuilder &operator=(const ResizeAttributeBuilder &); + flatbuffers::Offset<ResizeAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ResizeAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<ResizeAttribute> CreateResizeAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_size = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset = 0, + int32_t shift = 0, + flatbuffers::Offset<flatbuffers::Vector<float>> stride_fp = 0, + flatbuffers::Offset<flatbuffers::Vector<float>> offset_fp = 0, + tosa::ResizeMode mode = tosa::ResizeMode_UNKNOWN) { + ResizeAttributeBuilder builder_(_fbb); + builder_.add_mode(mode); + builder_.add_offset_fp(offset_fp); + builder_.add_stride_fp(stride_fp); + builder_.add_shift(shift); + builder_.add_offset(offset); + builder_.add_stride(stride); + builder_.add_output_size(output_size); + return builder_.Finish(); +} + +inline flatbuffers::Offset<ResizeAttribute> CreateResizeAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *output_size = nullptr, + const std::vector<int32_t> *stride = nullptr, + const std::vector<int32_t> *offset = nullptr, + int32_t shift = 0, + const std::vector<float> *stride_fp = nullptr, + const std::vector<float> *offset_fp = nullptr, + tosa::ResizeMode mode = tosa::ResizeMode_UNKNOWN) { + auto output_size__ = output_size ? _fbb.CreateVector<int32_t>(*output_size) : 0; + auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0; + auto offset__ = offset ? _fbb.CreateVector<int32_t>(*offset) : 0; + auto stride_fp__ = stride_fp ? _fbb.CreateVector<float>(*stride_fp) : 0; + auto offset_fp__ = offset_fp ? _fbb.CreateVector<float>(*offset_fp) : 0; + return tosa::CreateResizeAttribute( + _fbb, + output_size__, + stride__, + offset__, + shift, + stride_fp__, + offset_fp__, + mode); +} + +struct ClampAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ClampAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MIN_INT = 4, + VT_MAX_INT = 6, + VT_MIN_FP = 8, + VT_MAX_FP = 10 + }; + int32_t min_int() const { + return GetField<int32_t>(VT_MIN_INT, 0); + } + int32_t max_int() const { + return GetField<int32_t>(VT_MAX_INT, 0); + } + float min_fp() const { + return GetField<float>(VT_MIN_FP, 0.0f); + } + float max_fp() const { + return GetField<float>(VT_MAX_FP, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_MIN_INT) && + VerifyField<int32_t>(verifier, VT_MAX_INT) && + VerifyField<float>(verifier, VT_MIN_FP) && + VerifyField<float>(verifier, VT_MAX_FP) && + verifier.EndTable(); + } +}; + +struct ClampAttributeBuilder { + typedef ClampAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_min_int(int32_t min_int) { + fbb_.AddElement<int32_t>(ClampAttribute::VT_MIN_INT, min_int, 0); + } + void add_max_int(int32_t max_int) { + fbb_.AddElement<int32_t>(ClampAttribute::VT_MAX_INT, max_int, 0); + } + void add_min_fp(float min_fp) { + fbb_.AddElement<float>(ClampAttribute::VT_MIN_FP, min_fp, 0.0f); + } + void add_max_fp(float max_fp) { + fbb_.AddElement<float>(ClampAttribute::VT_MAX_FP, max_fp, 0.0f); + } + explicit ClampAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ClampAttributeBuilder &operator=(const ClampAttributeBuilder &); + flatbuffers::Offset<ClampAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ClampAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<ClampAttribute> CreateClampAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t min_int = 0, + int32_t max_int = 0, + float min_fp = 0.0f, + float max_fp = 0.0f) { + ClampAttributeBuilder builder_(_fbb); + builder_.add_max_fp(max_fp); + builder_.add_min_fp(min_fp); + builder_.add_max_int(max_int); + builder_.add_min_int(min_int); + return builder_.Finish(); +} + +struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef RescaleAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUT_ZP = 4, + VT_OUTPUT_ZP = 6, + VT_MULTIPLIER = 8, + VT_SHIFT = 10, + VT_SCALE32 = 12, + VT_DOUBLE_ROUND = 14, + VT_PER_CHANNEL = 16 + }; + int32_t input_zp() const { + return GetField<int32_t>(VT_INPUT_ZP, 0); + } + int32_t output_zp() const { + return GetField<int32_t>(VT_OUTPUT_ZP, 0); + } + const flatbuffers::Vector<int32_t> *multiplier() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_MULTIPLIER); + } + const flatbuffers::Vector<int32_t> *shift() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHIFT); + } + bool scale32() const { + return GetField<uint8_t>(VT_SCALE32, 0) != 0; + } + bool double_round() const { + return GetField<uint8_t>(VT_DOUBLE_ROUND, 0) != 0; + } + bool per_channel() const { + return GetField<uint8_t>(VT_PER_CHANNEL, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_INPUT_ZP) && + VerifyField<int32_t>(verifier, VT_OUTPUT_ZP) && + VerifyOffset(verifier, VT_MULTIPLIER) && + verifier.VerifyVector(multiplier()) && + VerifyOffset(verifier, VT_SHIFT) && + verifier.VerifyVector(shift()) && + VerifyField<uint8_t>(verifier, VT_SCALE32) && + VerifyField<uint8_t>(verifier, VT_DOUBLE_ROUND) && + VerifyField<uint8_t>(verifier, VT_PER_CHANNEL) && + verifier.EndTable(); + } +}; + +struct RescaleAttributeBuilder { + typedef RescaleAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_input_zp(int32_t input_zp) { + fbb_.AddElement<int32_t>(RescaleAttribute::VT_INPUT_ZP, input_zp, 0); + } + void add_output_zp(int32_t output_zp) { + fbb_.AddElement<int32_t>(RescaleAttribute::VT_OUTPUT_ZP, output_zp, 0); + } + void add_multiplier(flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiplier) { + fbb_.AddOffset(RescaleAttribute::VT_MULTIPLIER, multiplier); + } + void add_shift(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shift) { + fbb_.AddOffset(RescaleAttribute::VT_SHIFT, shift); + } + void add_scale32(bool scale32) { + fbb_.AddElement<uint8_t>(RescaleAttribute::VT_SCALE32, static_cast<uint8_t>(scale32), 0); + } + void add_double_round(bool double_round) { + fbb_.AddElement<uint8_t>(RescaleAttribute::VT_DOUBLE_ROUND, static_cast<uint8_t>(double_round), 0); + } + void add_per_channel(bool per_channel) { + fbb_.AddElement<uint8_t>(RescaleAttribute::VT_PER_CHANNEL, static_cast<uint8_t>(per_channel), 0); + } + explicit RescaleAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + RescaleAttributeBuilder &operator=(const RescaleAttributeBuilder &); + flatbuffers::Offset<RescaleAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<RescaleAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<RescaleAttribute> CreateRescaleAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0, + int32_t output_zp = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiplier = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> shift = 0, + bool scale32 = false, + bool double_round = false, + bool per_channel = false) { + RescaleAttributeBuilder builder_(_fbb); + builder_.add_shift(shift); + builder_.add_multiplier(multiplier); + builder_.add_output_zp(output_zp); + builder_.add_input_zp(input_zp); + builder_.add_per_channel(per_channel); + builder_.add_double_round(double_round); + builder_.add_scale32(scale32); + return builder_.Finish(); +} + +inline flatbuffers::Offset<RescaleAttribute> CreateRescaleAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0, + int32_t output_zp = 0, + const std::vector<int32_t> *multiplier = nullptr, + const std::vector<int32_t> *shift = nullptr, + bool scale32 = false, + bool double_round = false, + bool per_channel = false) { + auto multiplier__ = multiplier ? _fbb.CreateVector<int32_t>(*multiplier) : 0; + auto shift__ = shift ? _fbb.CreateVector<int32_t>(*shift) : 0; + return tosa::CreateRescaleAttribute( + _fbb, + input_zp, + output_zp, + multiplier__, + shift__, + scale32, + double_round, + per_channel); +} + +struct MulAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MulAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_SHIFT = 4 + }; + int32_t shift() const { + return GetField<int32_t>(VT_SHIFT, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_SHIFT) && + verifier.EndTable(); + } +}; + +struct MulAttributeBuilder { + typedef MulAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_shift(int32_t shift) { + fbb_.AddElement<int32_t>(MulAttribute::VT_SHIFT, shift, 0); + } + explicit MulAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MulAttributeBuilder &operator=(const MulAttributeBuilder &); + flatbuffers::Offset<MulAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<MulAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<MulAttribute> CreateMulAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t shift = 0) { + MulAttributeBuilder builder_(_fbb); + builder_.add_shift(shift); + return builder_.Finish(); +} + +struct ArithmeticRightShiftAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ArithmeticRightShiftAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_ROUND = 4 + }; + bool round() const { + return GetField<uint8_t>(VT_ROUND, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<uint8_t>(verifier, VT_ROUND) && + verifier.EndTable(); + } +}; + +struct ArithmeticRightShiftAttributeBuilder { + typedef ArithmeticRightShiftAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_round(bool round) { + fbb_.AddElement<uint8_t>(ArithmeticRightShiftAttribute::VT_ROUND, static_cast<uint8_t>(round), 0); + } + explicit ArithmeticRightShiftAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ArithmeticRightShiftAttributeBuilder &operator=(const ArithmeticRightShiftAttributeBuilder &); + flatbuffers::Offset<ArithmeticRightShiftAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ArithmeticRightShiftAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<ArithmeticRightShiftAttribute> CreateArithmeticRightShiftAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + bool round = false) { + ArithmeticRightShiftAttributeBuilder builder_(_fbb); + builder_.add_round(round); + return builder_.Finish(); +} + +struct CondIfAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef CondIfAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_THEN_BRANCH = 4, + VT_ELSE_BRANCH = 6 + }; + const flatbuffers::String *then_branch() const { + return GetPointer<const flatbuffers::String *>(VT_THEN_BRANCH); + } + const flatbuffers::String *else_branch() const { + return GetPointer<const flatbuffers::String *>(VT_ELSE_BRANCH); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_THEN_BRANCH) && + verifier.VerifyString(then_branch()) && + VerifyOffset(verifier, VT_ELSE_BRANCH) && + verifier.VerifyString(else_branch()) && + verifier.EndTable(); + } +}; + +struct CondIfAttributeBuilder { + typedef CondIfAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_then_branch(flatbuffers::Offset<flatbuffers::String> then_branch) { + fbb_.AddOffset(CondIfAttribute::VT_THEN_BRANCH, then_branch); + } + void add_else_branch(flatbuffers::Offset<flatbuffers::String> else_branch) { + fbb_.AddOffset(CondIfAttribute::VT_ELSE_BRANCH, else_branch); + } + explicit CondIfAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + CondIfAttributeBuilder &operator=(const CondIfAttributeBuilder &); + flatbuffers::Offset<CondIfAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<CondIfAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<CondIfAttribute> CreateCondIfAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::String> then_branch = 0, + flatbuffers::Offset<flatbuffers::String> else_branch = 0) { + CondIfAttributeBuilder builder_(_fbb); + builder_.add_else_branch(else_branch); + builder_.add_then_branch(then_branch); + return builder_.Finish(); +} + +inline flatbuffers::Offset<CondIfAttribute> CreateCondIfAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *then_branch = nullptr, + const char *else_branch = nullptr) { + auto then_branch__ = then_branch ? _fbb.CreateString(then_branch) : 0; + auto else_branch__ = else_branch ? _fbb.CreateString(else_branch) : 0; + return tosa::CreateCondIfAttribute( + _fbb, + then_branch__, + else_branch__); +} + +struct WhileLoopAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef WhileLoopAttributeBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_COND_BRANCH = 4, + VT_BODY_BRANCH = 6 + }; + const flatbuffers::String *cond_branch() const { + return GetPointer<const flatbuffers::String *>(VT_COND_BRANCH); + } + const flatbuffers::String *body_branch() const { + return GetPointer<const flatbuffers::String *>(VT_BODY_BRANCH); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_COND_BRANCH) && + verifier.VerifyString(cond_branch()) && + VerifyOffset(verifier, VT_BODY_BRANCH) && + verifier.VerifyString(body_branch()) && + verifier.EndTable(); + } +}; + +struct WhileLoopAttributeBuilder { + typedef WhileLoopAttribute Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_cond_branch(flatbuffers::Offset<flatbuffers::String> cond_branch) { + fbb_.AddOffset(WhileLoopAttribute::VT_COND_BRANCH, cond_branch); + } + void add_body_branch(flatbuffers::Offset<flatbuffers::String> body_branch) { + fbb_.AddOffset(WhileLoopAttribute::VT_BODY_BRANCH, body_branch); + } + explicit WhileLoopAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + WhileLoopAttributeBuilder &operator=(const WhileLoopAttributeBuilder &); + flatbuffers::Offset<WhileLoopAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<WhileLoopAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<WhileLoopAttribute> CreateWhileLoopAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::String> cond_branch = 0, + flatbuffers::Offset<flatbuffers::String> body_branch = 0) { + WhileLoopAttributeBuilder builder_(_fbb); + builder_.add_body_branch(body_branch); + builder_.add_cond_branch(cond_branch); + return builder_.Finish(); +} + +inline flatbuffers::Offset<WhileLoopAttribute> CreateWhileLoopAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *cond_branch = nullptr, + const char *body_branch = nullptr) { + auto cond_branch__ = cond_branch ? _fbb.CreateString(cond_branch) : 0; + auto body_branch__ = body_branch ? _fbb.CreateString(body_branch) : 0; + return tosa::CreateWhileLoopAttribute( + _fbb, + cond_branch__, + body_branch__); +} + +struct UnaryQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef UnaryQuantInfoBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUT_ZP = 4, + VT_OUTPUT_ZP = 6 + }; + int32_t input_zp() const { + return GetField<int32_t>(VT_INPUT_ZP, 0); + } + int32_t output_zp() const { + return GetField<int32_t>(VT_OUTPUT_ZP, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_INPUT_ZP) && + VerifyField<int32_t>(verifier, VT_OUTPUT_ZP) && + verifier.EndTable(); + } +}; + +struct UnaryQuantInfoBuilder { + typedef UnaryQuantInfo Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_input_zp(int32_t input_zp) { + fbb_.AddElement<int32_t>(UnaryQuantInfo::VT_INPUT_ZP, input_zp, 0); + } + void add_output_zp(int32_t output_zp) { + fbb_.AddElement<int32_t>(UnaryQuantInfo::VT_OUTPUT_ZP, output_zp, 0); + } + explicit UnaryQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UnaryQuantInfoBuilder &operator=(const UnaryQuantInfoBuilder &); + flatbuffers::Offset<UnaryQuantInfo> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<UnaryQuantInfo>(end); + return o; + } +}; + +inline flatbuffers::Offset<UnaryQuantInfo> CreateUnaryQuantInfo( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0, + int32_t output_zp = 0) { + UnaryQuantInfoBuilder builder_(_fbb); + builder_.add_output_zp(output_zp); + builder_.add_input_zp(input_zp); + return builder_.Finish(); +} + +struct ConvQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef ConvQuantInfoBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUT_ZP = 4, + VT_WEIGHT_ZP = 6 + }; + int32_t input_zp() const { + return GetField<int32_t>(VT_INPUT_ZP, 0); + } + int32_t weight_zp() const { + return GetField<int32_t>(VT_WEIGHT_ZP, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_INPUT_ZP) && + VerifyField<int32_t>(verifier, VT_WEIGHT_ZP) && + verifier.EndTable(); + } +}; + +struct ConvQuantInfoBuilder { + typedef ConvQuantInfo Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_input_zp(int32_t input_zp) { + fbb_.AddElement<int32_t>(ConvQuantInfo::VT_INPUT_ZP, input_zp, 0); + } + void add_weight_zp(int32_t weight_zp) { + fbb_.AddElement<int32_t>(ConvQuantInfo::VT_WEIGHT_ZP, weight_zp, 0); + } + explicit ConvQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ConvQuantInfoBuilder &operator=(const ConvQuantInfoBuilder &); + flatbuffers::Offset<ConvQuantInfo> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ConvQuantInfo>(end); + return o; + } +}; + +inline flatbuffers::Offset<ConvQuantInfo> CreateConvQuantInfo( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0, + int32_t weight_zp = 0) { + ConvQuantInfoBuilder builder_(_fbb); + builder_.add_weight_zp(weight_zp); + builder_.add_input_zp(input_zp); + return builder_.Finish(); +} + +struct MatMulQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef MatMulQuantInfoBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_A_ZP = 4, + VT_B_ZP = 6 + }; + int32_t a_zp() const { + return GetField<int32_t>(VT_A_ZP, 0); + } + int32_t b_zp() const { + return GetField<int32_t>(VT_B_ZP, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_A_ZP) && + VerifyField<int32_t>(verifier, VT_B_ZP) && + verifier.EndTable(); + } +}; + +struct MatMulQuantInfoBuilder { + typedef MatMulQuantInfo Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_a_zp(int32_t a_zp) { + fbb_.AddElement<int32_t>(MatMulQuantInfo::VT_A_ZP, a_zp, 0); + } + void add_b_zp(int32_t b_zp) { + fbb_.AddElement<int32_t>(MatMulQuantInfo::VT_B_ZP, b_zp, 0); + } + explicit MatMulQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MatMulQuantInfoBuilder &operator=(const MatMulQuantInfoBuilder &); + flatbuffers::Offset<MatMulQuantInfo> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<MatMulQuantInfo>(end); + return o; + } +}; + +inline flatbuffers::Offset<MatMulQuantInfo> CreateMatMulQuantInfo( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t a_zp = 0, + int32_t b_zp = 0) { + MatMulQuantInfoBuilder builder_(_fbb); + builder_.add_b_zp(b_zp); + builder_.add_a_zp(a_zp); + return builder_.Finish(); +} + +struct PadQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef PadQuantInfoBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUT_ZP = 4 + }; + int32_t input_zp() const { + return GetField<int32_t>(VT_INPUT_ZP, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_INPUT_ZP) && + verifier.EndTable(); + } +}; + +struct PadQuantInfoBuilder { + typedef PadQuantInfo Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_input_zp(int32_t input_zp) { + fbb_.AddElement<int32_t>(PadQuantInfo::VT_INPUT_ZP, input_zp, 0); + } + explicit PadQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PadQuantInfoBuilder &operator=(const PadQuantInfoBuilder &); + flatbuffers::Offset<PadQuantInfo> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<PadQuantInfo>(end); + return o; + } +}; + +inline flatbuffers::Offset<PadQuantInfo> CreatePadQuantInfo( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0) { + PadQuantInfoBuilder builder_(_fbb); + builder_.add_input_zp(input_zp); + return builder_.Finish(); +} + +struct Version FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef VersionBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT__MAJOR = 4, + VT__MINOR = 6, + VT__PATCH = 8, + VT__EXPERIMENTAL = 10 + }; + int32_t _major() const { + return GetField<int32_t>(VT__MAJOR, 0); + } + int32_t _minor() const { + return GetField<int32_t>(VT__MINOR, 21); + } + int32_t _patch() const { + return GetField<int32_t>(VT__PATCH, 0); + } + bool _experimental() const { + return GetField<uint8_t>(VT__EXPERIMENTAL, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT__MAJOR) && + VerifyField<int32_t>(verifier, VT__MINOR) && + VerifyField<int32_t>(verifier, VT__PATCH) && + VerifyField<uint8_t>(verifier, VT__EXPERIMENTAL) && + verifier.EndTable(); + } +}; + +struct VersionBuilder { + typedef Version Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add__major(int32_t _major) { + fbb_.AddElement<int32_t>(Version::VT__MAJOR, _major, 0); + } + void add__minor(int32_t _minor) { + fbb_.AddElement<int32_t>(Version::VT__MINOR, _minor, 21); + } + void add__patch(int32_t _patch) { + fbb_.AddElement<int32_t>(Version::VT__PATCH, _patch, 0); + } + void add__experimental(bool _experimental) { + fbb_.AddElement<uint8_t>(Version::VT__EXPERIMENTAL, static_cast<uint8_t>(_experimental), 0); + } + explicit VersionBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + VersionBuilder &operator=(const VersionBuilder &); + flatbuffers::Offset<Version> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<Version>(end); + return o; + } +}; + +inline flatbuffers::Offset<Version> CreateVersion( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t _major = 0, + int32_t _minor = 21, + int32_t _patch = 0, + bool _experimental = false) { + VersionBuilder builder_(_fbb); + builder_.add__patch(_patch); + builder_.add__minor(_minor); + builder_.add__major(_major); + builder_.add__experimental(_experimental); + return builder_.Finish(); +} + +struct TosaTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TosaTensorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_SHAPE = 6, + VT_TYPE = 8, + VT_NPY_FILENAME = 10 + }; + const flatbuffers::String *name() const { + return GetPointer<const flatbuffers::String *>(VT_NAME); + } + const flatbuffers::Vector<int32_t> *shape() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE); + } + tosa::DType type() const { + return static_cast<tosa::DType>(GetField<uint32_t>(VT_TYPE, 0)); + } + const flatbuffers::String *npy_filename() const { + return GetPointer<const flatbuffers::String *>(VT_NPY_FILENAME); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_SHAPE) && + verifier.VerifyVector(shape()) && + VerifyField<uint32_t>(verifier, VT_TYPE) && + VerifyOffset(verifier, VT_NPY_FILENAME) && + verifier.VerifyString(npy_filename()) && + verifier.EndTable(); + } +}; + +struct TosaTensorBuilder { + typedef TosaTensor Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset<flatbuffers::String> name) { + fbb_.AddOffset(TosaTensor::VT_NAME, name); + } + void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) { + fbb_.AddOffset(TosaTensor::VT_SHAPE, shape); + } + void add_type(tosa::DType type) { + fbb_.AddElement<uint32_t>(TosaTensor::VT_TYPE, static_cast<uint32_t>(type), 0); + } + void add_npy_filename(flatbuffers::Offset<flatbuffers::String> npy_filename) { + fbb_.AddOffset(TosaTensor::VT_NPY_FILENAME, npy_filename); + } + explicit TosaTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TosaTensorBuilder &operator=(const TosaTensorBuilder &); + flatbuffers::Offset<TosaTensor> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TosaTensor>(end); + return o; + } +}; + +inline flatbuffers::Offset<TosaTensor> CreateTosaTensor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::String> name = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0, + tosa::DType type = tosa::DType_UNKNOWN, + flatbuffers::Offset<flatbuffers::String> npy_filename = 0) { + TosaTensorBuilder builder_(_fbb); + builder_.add_npy_filename(npy_filename); + builder_.add_type(type); + builder_.add_shape(shape); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TosaTensor> CreateTosaTensorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + const std::vector<int32_t> *shape = nullptr, + tosa::DType type = tosa::DType_UNKNOWN, + const char *npy_filename = nullptr) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0; + auto npy_filename__ = npy_filename ? _fbb.CreateString(npy_filename) : 0; + return tosa::CreateTosaTensor( + _fbb, + name__, + shape__, + type, + npy_filename__); +} + +struct TosaOperator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TosaOperatorBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OP = 4, + VT_ATTRIBUTE_TYPE = 6, + VT_ATTRIBUTE = 8, + VT_INPUTS = 10, + VT_OUTPUTS = 12, + VT_QUANT_INFO_TYPE = 14, + VT_QUANT_INFO = 16 + }; + tosa::Op op() const { + return static_cast<tosa::Op>(GetField<uint32_t>(VT_OP, 0)); + } + tosa::Attribute attribute_type() const { + return static_cast<tosa::Attribute>(GetField<uint8_t>(VT_ATTRIBUTE_TYPE, 0)); + } + const void *attribute() const { + return GetPointer<const void *>(VT_ATTRIBUTE); + } + template<typename T> const T *attribute_as() const; + const tosa::Pool2dAttribute *attribute_as_Pool2dAttribute() const { + return attribute_type() == tosa::Attribute_Pool2dAttribute ? static_cast<const tosa::Pool2dAttribute *>(attribute()) : nullptr; + } + const tosa::Conv2dAttribute *attribute_as_Conv2dAttribute() const { + return attribute_type() == tosa::Attribute_Conv2dAttribute ? static_cast<const tosa::Conv2dAttribute *>(attribute()) : nullptr; + } + const tosa::TransposeConv2dAttribute *attribute_as_TransposeConv2dAttribute() const { + return attribute_type() == tosa::Attribute_TransposeConv2dAttribute ? static_cast<const tosa::TransposeConv2dAttribute *>(attribute()) : nullptr; + } + const tosa::ReluNAttribute *attribute_as_ReluNAttribute() const { + return attribute_type() == tosa::Attribute_ReluNAttribute ? static_cast<const tosa::ReluNAttribute *>(attribute()) : nullptr; + } + const tosa::AxisAttribute *attribute_as_AxisAttribute() const { + return attribute_type() == tosa::Attribute_AxisAttribute ? static_cast<const tosa::AxisAttribute *>(attribute()) : nullptr; + } + const tosa::ReshapeAttribute *attribute_as_ReshapeAttribute() const { + return attribute_type() == tosa::Attribute_ReshapeAttribute ? static_cast<const tosa::ReshapeAttribute *>(attribute()) : nullptr; + } + const tosa::SliceAttribute *attribute_as_SliceAttribute() const { + return attribute_type() == tosa::Attribute_SliceAttribute ? static_cast<const tosa::SliceAttribute *>(attribute()) : nullptr; + } + const tosa::TileAttribute *attribute_as_TileAttribute() const { + return attribute_type() == tosa::Attribute_TileAttribute ? static_cast<const tosa::TileAttribute *>(attribute()) : nullptr; + } + const tosa::ResizeAttribute *attribute_as_ResizeAttribute() const { + return attribute_type() == tosa::Attribute_ResizeAttribute ? static_cast<const tosa::ResizeAttribute *>(attribute()) : nullptr; + } + const tosa::ClampAttribute *attribute_as_ClampAttribute() const { + return attribute_type() == tosa::Attribute_ClampAttribute ? static_cast<const tosa::ClampAttribute *>(attribute()) : nullptr; + } + const tosa::RescaleAttribute *attribute_as_RescaleAttribute() const { + return attribute_type() == tosa::Attribute_RescaleAttribute ? static_cast<const tosa::RescaleAttribute *>(attribute()) : nullptr; + } + const tosa::MulAttribute *attribute_as_MulAttribute() const { + return attribute_type() == tosa::Attribute_MulAttribute ? static_cast<const tosa::MulAttribute *>(attribute()) : nullptr; + } + const tosa::ArithmeticRightShiftAttribute *attribute_as_ArithmeticRightShiftAttribute() const { + return attribute_type() == tosa::Attribute_ArithmeticRightShiftAttribute ? static_cast<const tosa::ArithmeticRightShiftAttribute *>(attribute()) : nullptr; + } + const tosa::CondIfAttribute *attribute_as_CondIfAttribute() const { + return attribute_type() == tosa::Attribute_CondIfAttribute ? static_cast<const tosa::CondIfAttribute *>(attribute()) : nullptr; + } + const tosa::WhileLoopAttribute *attribute_as_WhileLoopAttribute() const { + return attribute_type() == tosa::Attribute_WhileLoopAttribute ? static_cast<const tosa::WhileLoopAttribute *>(attribute()) : nullptr; + } + const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *inputs() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_INPUTS); + } + const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputs() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OUTPUTS); + } + tosa::QuantInfo quant_info_type() const { + return static_cast<tosa::QuantInfo>(GetField<uint8_t>(VT_QUANT_INFO_TYPE, 0)); + } + const void *quant_info() const { + return GetPointer<const void *>(VT_QUANT_INFO); + } + template<typename T> const T *quant_info_as() const; + const tosa::UnaryQuantInfo *quant_info_as_UnaryQuantInfo() const { + return quant_info_type() == tosa::QuantInfo_UnaryQuantInfo ? static_cast<const tosa::UnaryQuantInfo *>(quant_info()) : nullptr; + } + const tosa::ConvQuantInfo *quant_info_as_ConvQuantInfo() const { + return quant_info_type() == tosa::QuantInfo_ConvQuantInfo ? static_cast<const tosa::ConvQuantInfo *>(quant_info()) : nullptr; + } + const tosa::MatMulQuantInfo *quant_info_as_MatMulQuantInfo() const { + return quant_info_type() == tosa::QuantInfo_MatMulQuantInfo ? static_cast<const tosa::MatMulQuantInfo *>(quant_info()) : nullptr; + } + const tosa::PadQuantInfo *quant_info_as_PadQuantInfo() const { + return quant_info_type() == tosa::QuantInfo_PadQuantInfo ? static_cast<const tosa::PadQuantInfo *>(quant_info()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<uint32_t>(verifier, VT_OP) && + VerifyField<uint8_t>(verifier, VT_ATTRIBUTE_TYPE) && + VerifyOffset(verifier, VT_ATTRIBUTE) && + VerifyAttribute(verifier, attribute(), attribute_type()) && + VerifyOffset(verifier, VT_INPUTS) && + verifier.VerifyVector(inputs()) && + verifier.VerifyVectorOfStrings(inputs()) && + VerifyOffset(verifier, VT_OUTPUTS) && + verifier.VerifyVector(outputs()) && + verifier.VerifyVectorOfStrings(outputs()) && + VerifyField<uint8_t>(verifier, VT_QUANT_INFO_TYPE) && + VerifyOffset(verifier, VT_QUANT_INFO) && + VerifyQuantInfo(verifier, quant_info(), quant_info_type()) && + verifier.EndTable(); + } +}; + +template<> inline const tosa::Pool2dAttribute *TosaOperator::attribute_as<tosa::Pool2dAttribute>() const { + return attribute_as_Pool2dAttribute(); +} + +template<> inline const tosa::Conv2dAttribute *TosaOperator::attribute_as<tosa::Conv2dAttribute>() const { + return attribute_as_Conv2dAttribute(); +} + +template<> inline const tosa::TransposeConv2dAttribute *TosaOperator::attribute_as<tosa::TransposeConv2dAttribute>() const { + return attribute_as_TransposeConv2dAttribute(); +} + +template<> inline const tosa::ReluNAttribute *TosaOperator::attribute_as<tosa::ReluNAttribute>() const { + return attribute_as_ReluNAttribute(); +} + +template<> inline const tosa::AxisAttribute *TosaOperator::attribute_as<tosa::AxisAttribute>() const { + return attribute_as_AxisAttribute(); +} + +template<> inline const tosa::ReshapeAttribute *TosaOperator::attribute_as<tosa::ReshapeAttribute>() const { + return attribute_as_ReshapeAttribute(); +} + +template<> inline const tosa::SliceAttribute *TosaOperator::attribute_as<tosa::SliceAttribute>() const { + return attribute_as_SliceAttribute(); +} + +template<> inline const tosa::TileAttribute *TosaOperator::attribute_as<tosa::TileAttribute>() const { + return attribute_as_TileAttribute(); +} + +template<> inline const tosa::ResizeAttribute *TosaOperator::attribute_as<tosa::ResizeAttribute>() const { + return attribute_as_ResizeAttribute(); +} + +template<> inline const tosa::ClampAttribute *TosaOperator::attribute_as<tosa::ClampAttribute>() const { + return attribute_as_ClampAttribute(); +} + +template<> inline const tosa::RescaleAttribute *TosaOperator::attribute_as<tosa::RescaleAttribute>() const { + return attribute_as_RescaleAttribute(); +} + +template<> inline const tosa::MulAttribute *TosaOperator::attribute_as<tosa::MulAttribute>() const { + return attribute_as_MulAttribute(); +} + +template<> inline const tosa::ArithmeticRightShiftAttribute *TosaOperator::attribute_as<tosa::ArithmeticRightShiftAttribute>() const { + return attribute_as_ArithmeticRightShiftAttribute(); +} + +template<> inline const tosa::CondIfAttribute *TosaOperator::attribute_as<tosa::CondIfAttribute>() const { + return attribute_as_CondIfAttribute(); +} + +template<> inline const tosa::WhileLoopAttribute *TosaOperator::attribute_as<tosa::WhileLoopAttribute>() const { + return attribute_as_WhileLoopAttribute(); +} + +template<> inline const tosa::UnaryQuantInfo *TosaOperator::quant_info_as<tosa::UnaryQuantInfo>() const { + return quant_info_as_UnaryQuantInfo(); +} + +template<> inline const tosa::ConvQuantInfo *TosaOperator::quant_info_as<tosa::ConvQuantInfo>() const { + return quant_info_as_ConvQuantInfo(); +} + +template<> inline const tosa::MatMulQuantInfo *TosaOperator::quant_info_as<tosa::MatMulQuantInfo>() const { + return quant_info_as_MatMulQuantInfo(); +} + +template<> inline const tosa::PadQuantInfo *TosaOperator::quant_info_as<tosa::PadQuantInfo>() const { + return quant_info_as_PadQuantInfo(); +} + +struct TosaOperatorBuilder { + typedef TosaOperator Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_op(tosa::Op op) { + fbb_.AddElement<uint32_t>(TosaOperator::VT_OP, static_cast<uint32_t>(op), 0); + } + void add_attribute_type(tosa::Attribute attribute_type) { + fbb_.AddElement<uint8_t>(TosaOperator::VT_ATTRIBUTE_TYPE, static_cast<uint8_t>(attribute_type), 0); + } + void add_attribute(flatbuffers::Offset<void> attribute) { + fbb_.AddOffset(TosaOperator::VT_ATTRIBUTE, attribute); + } + void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs) { + fbb_.AddOffset(TosaOperator::VT_INPUTS, inputs); + } + void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs) { + fbb_.AddOffset(TosaOperator::VT_OUTPUTS, outputs); + } + void add_quant_info_type(tosa::QuantInfo quant_info_type) { + fbb_.AddElement<uint8_t>(TosaOperator::VT_QUANT_INFO_TYPE, static_cast<uint8_t>(quant_info_type), 0); + } + void add_quant_info(flatbuffers::Offset<void> quant_info) { + fbb_.AddOffset(TosaOperator::VT_QUANT_INFO, quant_info); + } + explicit TosaOperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TosaOperatorBuilder &operator=(const TosaOperatorBuilder &); + flatbuffers::Offset<TosaOperator> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TosaOperator>(end); + return o; + } +}; + +inline flatbuffers::Offset<TosaOperator> CreateTosaOperator( + flatbuffers::FlatBufferBuilder &_fbb, + tosa::Op op = tosa::Op_UNKNOWN, + tosa::Attribute attribute_type = tosa::Attribute_NONE, + flatbuffers::Offset<void> attribute = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs = 0, + tosa::QuantInfo quant_info_type = tosa::QuantInfo_NONE, + flatbuffers::Offset<void> quant_info = 0) { + TosaOperatorBuilder builder_(_fbb); + builder_.add_quant_info(quant_info); + builder_.add_outputs(outputs); + builder_.add_inputs(inputs); + builder_.add_attribute(attribute); + builder_.add_op(op); + builder_.add_quant_info_type(quant_info_type); + builder_.add_attribute_type(attribute_type); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TosaOperator> CreateTosaOperatorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + tosa::Op op = tosa::Op_UNKNOWN, + tosa::Attribute attribute_type = tosa::Attribute_NONE, + flatbuffers::Offset<void> attribute = 0, + const std::vector<flatbuffers::Offset<flatbuffers::String>> *inputs = nullptr, + const std::vector<flatbuffers::Offset<flatbuffers::String>> *outputs = nullptr, + tosa::QuantInfo quant_info_type = tosa::QuantInfo_NONE, + flatbuffers::Offset<void> quant_info = 0) { + auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*inputs) : 0; + auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*outputs) : 0; + return tosa::CreateTosaOperator( + _fbb, + op, + attribute_type, + attribute, + inputs__, + outputs__, + quant_info_type, + quant_info); +} + +struct TosaBasicBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TosaBasicBlockBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_OPERATORS = 6, + VT_TENSORS = 8, + VT_INPUTS = 10, + VT_OUTPUTS = 12 + }; + const flatbuffers::String *name() const { + return GetPointer<const flatbuffers::String *>(VT_NAME); + } + const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaOperator>> *operators() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaOperator>> *>(VT_OPERATORS); + } + const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaTensor>> *tensors() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaTensor>> *>(VT_TENSORS); + } + const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *inputs() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_INPUTS); + } + const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputs() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OUTPUTS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_OPERATORS) && + verifier.VerifyVector(operators()) && + verifier.VerifyVectorOfTables(operators()) && + VerifyOffset(verifier, VT_TENSORS) && + verifier.VerifyVector(tensors()) && + verifier.VerifyVectorOfTables(tensors()) && + VerifyOffset(verifier, VT_INPUTS) && + verifier.VerifyVector(inputs()) && + verifier.VerifyVectorOfStrings(inputs()) && + VerifyOffset(verifier, VT_OUTPUTS) && + verifier.VerifyVector(outputs()) && + verifier.VerifyVectorOfStrings(outputs()) && + verifier.EndTable(); + } +}; + +struct TosaBasicBlockBuilder { + typedef TosaBasicBlock Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset<flatbuffers::String> name) { + fbb_.AddOffset(TosaBasicBlock::VT_NAME, name); + } + void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaOperator>>> operators) { + fbb_.AddOffset(TosaBasicBlock::VT_OPERATORS, operators); + } + void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaTensor>>> tensors) { + fbb_.AddOffset(TosaBasicBlock::VT_TENSORS, tensors); + } + void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs) { + fbb_.AddOffset(TosaBasicBlock::VT_INPUTS, inputs); + } + void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs) { + fbb_.AddOffset(TosaBasicBlock::VT_OUTPUTS, outputs); + } + explicit TosaBasicBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TosaBasicBlockBuilder &operator=(const TosaBasicBlockBuilder &); + flatbuffers::Offset<TosaBasicBlock> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TosaBasicBlock>(end); + return o; + } +}; + +inline flatbuffers::Offset<TosaBasicBlock> CreateTosaBasicBlock( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::String> name = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaOperator>>> operators = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaTensor>>> tensors = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs = 0) { + TosaBasicBlockBuilder builder_(_fbb); + builder_.add_outputs(outputs); + builder_.add_inputs(inputs); + builder_.add_tensors(tensors); + builder_.add_operators(operators); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TosaBasicBlock> CreateTosaBasicBlockDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + const std::vector<flatbuffers::Offset<tosa::TosaOperator>> *operators = nullptr, + const std::vector<flatbuffers::Offset<tosa::TosaTensor>> *tensors = nullptr, + const std::vector<flatbuffers::Offset<flatbuffers::String>> *inputs = nullptr, + const std::vector<flatbuffers::Offset<flatbuffers::String>> *outputs = nullptr) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<tosa::TosaOperator>>(*operators) : 0; + auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<tosa::TosaTensor>>(*tensors) : 0; + auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*inputs) : 0; + auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*outputs) : 0; + return tosa::CreateTosaBasicBlock( + _fbb, + name__, + operators__, + tensors__, + inputs__, + outputs__); +} + +struct TosaGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + typedef TosaGraphBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VERSION = 4, + VT_BLOCKS = 6 + }; + const tosa::Version *version() const { + return GetPointer<const tosa::Version *>(VT_VERSION); + } + const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaBasicBlock>> *blocks() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tosa::TosaBasicBlock>> *>(VT_BLOCKS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_VERSION) && + verifier.VerifyTable(version()) && + VerifyOffset(verifier, VT_BLOCKS) && + verifier.VerifyVector(blocks()) && + verifier.VerifyVectorOfTables(blocks()) && + verifier.EndTable(); + } +}; + +struct TosaGraphBuilder { + typedef TosaGraph Table; + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_version(flatbuffers::Offset<tosa::Version> version) { + fbb_.AddOffset(TosaGraph::VT_VERSION, version); + } + void add_blocks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaBasicBlock>>> blocks) { + fbb_.AddOffset(TosaGraph::VT_BLOCKS, blocks); + } + explicit TosaGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TosaGraphBuilder &operator=(const TosaGraphBuilder &); + flatbuffers::Offset<TosaGraph> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TosaGraph>(end); + return o; + } +}; + +inline flatbuffers::Offset<TosaGraph> CreateTosaGraph( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<tosa::Version> version = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tosa::TosaBasicBlock>>> blocks = 0) { + TosaGraphBuilder builder_(_fbb); + builder_.add_blocks(blocks); + builder_.add_version(version); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TosaGraph> CreateTosaGraphDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<tosa::Version> version = 0, + const std::vector<flatbuffers::Offset<tosa::TosaBasicBlock>> *blocks = nullptr) { + auto blocks__ = blocks ? _fbb.CreateVector<flatbuffers::Offset<tosa::TosaBasicBlock>>(*blocks) : 0; + return tosa::CreateTosaGraph( + _fbb, + version, + blocks__); +} + +inline bool VerifyAttribute(flatbuffers::Verifier &verifier, const void *obj, Attribute type) { + switch (type) { + case Attribute_NONE: { + return true; + } + case Attribute_Pool2dAttribute: { + auto ptr = reinterpret_cast<const tosa::Pool2dAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_Conv2dAttribute: { + auto ptr = reinterpret_cast<const tosa::Conv2dAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_TransposeConv2dAttribute: { + auto ptr = reinterpret_cast<const tosa::TransposeConv2dAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_ReluNAttribute: { + auto ptr = reinterpret_cast<const tosa::ReluNAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_AxisAttribute: { + auto ptr = reinterpret_cast<const tosa::AxisAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_ReshapeAttribute: { + auto ptr = reinterpret_cast<const tosa::ReshapeAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_SliceAttribute: { + auto ptr = reinterpret_cast<const tosa::SliceAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_TileAttribute: { + auto ptr = reinterpret_cast<const tosa::TileAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_ResizeAttribute: { + auto ptr = reinterpret_cast<const tosa::ResizeAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_ClampAttribute: { + auto ptr = reinterpret_cast<const tosa::ClampAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_RescaleAttribute: { + auto ptr = reinterpret_cast<const tosa::RescaleAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_MulAttribute: { + auto ptr = reinterpret_cast<const tosa::MulAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_ArithmeticRightShiftAttribute: { + auto ptr = reinterpret_cast<const tosa::ArithmeticRightShiftAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_CondIfAttribute: { + auto ptr = reinterpret_cast<const tosa::CondIfAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_WhileLoopAttribute: { + auto ptr = reinterpret_cast<const tosa::WhileLoopAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyAttributeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *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 (!VerifyAttribute( + verifier, values->Get(i), types->GetEnum<Attribute>(i))) { + return false; + } + } + return true; +} + +inline bool VerifyQuantInfo(flatbuffers::Verifier &verifier, const void *obj, QuantInfo type) { + switch (type) { + case QuantInfo_NONE: { + return true; + } + case QuantInfo_UnaryQuantInfo: { + auto ptr = reinterpret_cast<const tosa::UnaryQuantInfo *>(obj); + return verifier.VerifyTable(ptr); + } + case QuantInfo_ConvQuantInfo: { + auto ptr = reinterpret_cast<const tosa::ConvQuantInfo *>(obj); + return verifier.VerifyTable(ptr); + } + case QuantInfo_MatMulQuantInfo: { + auto ptr = reinterpret_cast<const tosa::MatMulQuantInfo *>(obj); + return verifier.VerifyTable(ptr); + } + case QuantInfo_PadQuantInfo: { + auto ptr = reinterpret_cast<const tosa::PadQuantInfo *>(obj); + return verifier.VerifyTable(ptr); + } + default: return true; + } +} + +inline bool VerifyQuantInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *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 (!VerifyQuantInfo( + verifier, values->Get(i), types->GetEnum<QuantInfo>(i))) { + return false; + } + } + return true; +} + +inline const tosa::TosaGraph *GetTosaGraph(const void *buf) { + return flatbuffers::GetRoot<tosa::TosaGraph>(buf); +} + +inline const tosa::TosaGraph *GetSizePrefixedTosaGraph(const void *buf) { + return flatbuffers::GetSizePrefixedRoot<tosa::TosaGraph>(buf); +} + +inline const char *TosaGraphIdentifier() { + return "TOSA"; +} + +inline bool TosaGraphBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, TosaGraphIdentifier()); +} + +inline bool VerifyTosaGraphBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer<tosa::TosaGraph>(TosaGraphIdentifier()); +} + +inline bool VerifySizePrefixedTosaGraphBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer<tosa::TosaGraph>(TosaGraphIdentifier()); +} + +inline const char *TosaGraphExtension() { + return "tosa"; +} + +inline void FinishTosaGraphBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset<tosa::TosaGraph> root) { + fbb.Finish(root, TosaGraphIdentifier()); +} + +inline void FinishSizePrefixedTosaGraphBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset<tosa::TosaGraph> root) { + fbb.FinishSizePrefixed(root, TosaGraphIdentifier()); +} + +} // namespace tosa + +#endif // FLATBUFFERS_GENERATED_TOSA_TOSA_H_ diff --git a/include/tosa_serialization_handler.h b/include/tosa_serialization_handler.h new file mode 100644 index 0000000..398590d --- /dev/null +++ b/include/tosa_serialization_handler.h @@ -0,0 +1,349 @@ + +// Copyright (c) 2020-2021, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef _TOSA_SERIALIZATION_HANDLER_H +#define _TOSA_SERIALIZATION_HANDLER_H +#include "attribute.h" +#include "flatbuffers/idl.h" +#include "flatbuffers/util.h" +#include "numpy_utils.h" +#include "quant_info.h" +#include "tosa_generated.h" +#include <cstdint> +#include <memory> +#include <string> +#include <vector> + +namespace tosa +{ + +enum tosa_err_t +{ + TOSA_OK, + TOSA_USER_ERROR, + TOSA_FILE_ERROR, + TOSA_MEMORY_ERROR, + TOSA_SCHEMA_MISSING, + TOSA_INTERNAL_ERROR, + TOSA_VERSION_MISMATCH, + NUM_TOSA_ERROR +}; + +struct TosaVersion +{ + int32_t _major; + int32_t _minor; + int32_t _patch; + bool _experimental; + bool _valid; + + TosaVersion() + { + _valid = false; + } + + TosaVersion(int32_t major, int32_t minor, int32_t patch, bool experimental) + { + set_version(major, minor, patch, experimental); + } + + void set_version(int32_t major, int32_t minor, int32_t patch, bool experimental) + { + _major = major; + _minor = minor; + _patch = patch; + _experimental = experimental; + _valid = true; + } + + std::string to_string() const + { + std::string str; + assert(_valid); + str += std::to_string(_major) + "."; + str += std::to_string(_minor) + "."; + str += std::to_string(_patch); + if (_experimental) + str += "(experimental)"; + return str; + }; + + bool operator==(const TosaVersion& rhs) + { + assert(_valid); + if (!_valid) + return false; + if (rhs._major == _major && rhs._minor == _minor && rhs._patch == _patch && rhs._experimental == _experimental) + { + return true; + } + return false; + } + + bool operator!=(const TosaVersion& rhs) + { + assert(_valid); + if (!_valid) + return true; + return !((*this) == rhs); + } +}; + +class TosaSerializationHandler; + +class TosaSerializationTensor +{ +public: + // constructor and destructor + TosaSerializationTensor(const flatbuffers::String* name, + const flatbuffers::Vector<int32_t>& shape, + DType dtype, + const flatbuffers::String* npy_filename); + TosaSerializationTensor(std::string& name, + const std::vector<int32_t>& shape, + DType dtype, + const std::string& npy_filename); + TosaSerializationTensor(); + ~TosaSerializationTensor(); + + // accessor + std::string GetName() const + { + return _name; + } + const std::vector<int32_t>& GetShape() const + { + return _shape; + } + DType GetDtype() + { + return _dtype; + } + const std::string& GetNpyFilePtr() const + { + return _npy_filename; + } + + // modifier + void SetDtype(DType dtype) + { + _dtype = dtype; + } + void SetName(std::string name) + { + _name = name; + } + +private: + DType _dtype; /* data type enumeration, see tosa_isa_generated.h */ + std::vector<int32_t> _shape; /* shape of the tensor */ + std::string _name; /* name of the tensor, used for solving dependency */ + std::string _npy_filename; /* numpy array filename if not null. so null is the distinguisher */ +}; + +class TosaSerializationOperator +{ +public: + // use default copy, void constructor + // constructor and destructor + TosaSerializationOperator(Op op, + Attribute attribute_type, + const TosaAttributeBase* attribute, + QuantInfo qinfo_type, + const TosaQuantInfoBase* qinfo, + std::vector<std::string> input_tensor_names, + std::vector<std::string> output_tensor_names); + ~TosaSerializationOperator(); + + // accessor + Op GetOp() const + { + return _op; + } + Attribute GetAttributeType() const + { + return _attribute_type; + } + TosaAttributeBase* GetAttribute() const + { + return _attribute; + } + QuantInfo GetQInfoType() const + { + return _qinfo_type; + } + TosaQuantInfoBase* GetQInfo() const + { + return _qinfo; + } + std::vector<std::string>& GetInputTensorNames() + { + return _input_tensor_names; + } + std::vector<std::string>& GetOutputTensorNames() + { + return _output_tensor_names; + } + +private: + Op _op; /* operator enum, see tosa_isa_generated.h for enumeration table */ + Attribute _attribute_type; /* operator attribute enum, used for dynamic casting TosaAttributeBase class */ + TosaAttributeBase* _attribute; /* real attribute class goes here */ + QuantInfo _qinfo_type; /* QuantInfo enum */ + TosaQuantInfoBase* _qinfo; /* base class pointer of QuantInfo */ + std::vector<std::string> _input_tensor_names; /* array of input tensor names */ + std::vector<std::string> _output_tensor_names; /* array of output tensor names */ +}; + +class TosaSerializationBasicBlock +{ +public: + // constructor and destructor + TosaSerializationBasicBlock(std::string name, + std::vector<TosaSerializationOperator*> operators, + std::vector<TosaSerializationTensor*> tensors, + std::vector<std::string> inputs, + std::vector<std::string> outputs); + ~TosaSerializationBasicBlock(); + + // accessor + std::string GetName() const + { + return _name; + } + std::vector<TosaSerializationOperator*>& GetOperators() + { + return _operators; + } + std::vector<TosaSerializationTensor*>& GetTensors() + { + return _tensors; + } + + TosaSerializationTensor* GetTensorByName(std::string name) + { + TosaSerializationTensor* result = nullptr; + for (auto tensor : GetTensors()) + { + if (tensor->GetName() == name) + { + result = tensor; + break; + } + } + return result; + } + + std::vector<std::string>& GetInputs() + { + return _inputs; + } + std::vector<std::string>& GetOutputs() + { + return _outputs; + } + +private: + std::string _name; /* name of basic block */ + std::vector<TosaSerializationOperator*> _operators; /* TosaSerializationOperator list */ + std::vector<TosaSerializationTensor*> _tensors; /* TosaSerializationTensor list */ + std::vector<std::string> _inputs; /* array of string to specify block inputs */ + std::vector<std::string> _outputs; /* array of string to specify block outputs */ +}; + +/* + * this is a helper class for writing/reading Tosa ISA + * supported format: .tosa (flatbuffer), .json + * and provide high-level std::vector-like interface + * to access internal data structure + */ +class TosaSerializationHandler +{ +public: + // constructor and destructor + TosaSerializationHandler(); + ~TosaSerializationHandler(); + + // file io + tosa_err_t LoadFileJson(const char* filename); + tosa_err_t LoadFileTosaFlatbuffer(const char* filename); + tosa_err_t SaveFileJson(const char* filename); + tosa_err_t SaveFileTosaFlatbuffer(const char* filename); + tosa_err_t LoadFileSchema(const char* schema_filename); + + // version + const TosaVersion& GetTosaVersion() const + { + return _version; + } + + // accessor + std::vector<TosaSerializationBasicBlock*>& GetBlocks() + { + return _blocks; + } + + TosaSerializationBasicBlock* GetBlockByName(std::string name) + { + TosaSerializationBasicBlock* result = nullptr; + for (auto block : GetBlocks()) + { + if (block->GetName() == name) + { + result = block; + break; + } + } + return result; + } + TosaSerializationBasicBlock* GetMainBlock() + { + TosaSerializationBasicBlock* main_block = GetBlockByName(std::string("main")); + assert(main_block); + return main_block; + } + + std::vector<std::string>& GetInputs() + { + return GetMainBlock()->GetInputs(); + } + std::vector<std::string>& GetOutputs() + { + return GetMainBlock()->GetOutputs(); + } + + bool GetSchemaLoaded() const + { + return _schemaLoaded; + } + +protected: + tosa_err_t Clear(); + tosa_err_t InitWithBuf(const uint8_t* buf); + tosa_err_t FreezeBuilder(); + tosa_err_t SetTosaVersion(); + tosa_err_t CheckTosaVersion(const TosaVersion& read_version); + +private: + TosaVersion _version; /* tosa version */ + flatbuffers::FlatBufferBuilder _builder; /* flatbuffer builder */ + flatbuffers::Parser _parser; /* flatbuffer parser, used for json parsing */ + std::vector<TosaSerializationBasicBlock*> _blocks; /* array structure to store all TosaSerializationBasicBlock */ + bool _schemaLoaded; /* is the schema properly loaded? */ +}; + +} // namespace tosa + +#endif // _TOSA_SERIALIZATION_HANDLER_H |