1 /* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
2
3 Licensed under the Apache License, Version 2.0 (the "License");
4 you may not use this file except in compliance with the License.
5 You may obtain a copy of the License at
6
7 http://www.apache.org/licenses/LICENSE-2.0
8
9 Unless required by applicable law or agreed to in writing, software
10 distributed under the License is distributed on an "AS IS" BASIS,
11 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 See the License for the specific language governing permissions and
13 limitations under the License.
14 ==============================================================================*/
15 // automatically generated by the FlatBuffers compiler, do not modify
16
17
18 #ifndef FLATBUFFERS_GENERATED_SERIALIZATIONBASE_TFLITE_GPU_DATA_H_
19 #define FLATBUFFERS_GENERATED_SERIALIZATIONBASE_TFLITE_GPU_DATA_H_
20
21 #include "flatbuffers/flatbuffers.h"
22
23 namespace tflite {
24 namespace gpu {
25 namespace data {
26
27 struct Int4;
28 struct Int4Builder;
29
30 struct Int3;
31 struct Int3Builder;
32
33 struct Int2;
34 struct Int2Builder;
35
36 struct StateVariable;
37 struct StateVariableBuilder;
38
39 struct GPUObjectDescriptor;
40 struct GPUObjectDescriptorBuilder;
41
42 struct IntValue;
43 struct IntValueBuilder;
44
45 struct FloatValue;
46 struct FloatValueBuilder;
47
48 struct HalfValue;
49 struct HalfValueBuilder;
50
51 struct BufferDescriptor;
52 struct BufferDescriptorBuilder;
53
54 struct Texture2DDescriptor;
55 struct Texture2DDescriptorBuilder;
56
57 struct TensorLinearDescriptor;
58 struct TensorLinearDescriptorBuilder;
59
60 struct BHWDC;
61 struct BHWDCBuilder;
62
63 struct TensorDescriptor;
64 struct TensorDescriptorBuilder;
65
66 struct BufferDescriptorMapValue;
67 struct BufferDescriptorMapValueBuilder;
68
69 struct Texture2DDescriptorMapValue;
70 struct Texture2DDescriptorMapValueBuilder;
71
72 struct TensorLinearDescriptorMapValue;
73 struct TensorLinearDescriptorMapValueBuilder;
74
75 struct TensorDescriptorMapValue;
76 struct TensorDescriptorMapValueBuilder;
77
78 struct Arguments;
79 struct ArgumentsBuilder;
80
81 struct OperationDef;
82 struct OperationDefBuilder;
83
84 struct CompilerOption;
85 struct CompilerOptionBuilder;
86
87 struct GPUOperation;
88 struct GPUOperationBuilder;
89
90 enum class AccessType : int8_t {
91 READ = 0,
92 WRITE = 1,
93 READ_WRITE = 2,
94 MIN = READ,
95 MAX = READ_WRITE
96 };
97
EnumValuesAccessType()98 inline const AccessType (&EnumValuesAccessType())[3] {
99 static const AccessType values[] = {
100 AccessType::READ,
101 AccessType::WRITE,
102 AccessType::READ_WRITE
103 };
104 return values;
105 }
106
EnumNamesAccessType()107 inline const char * const *EnumNamesAccessType() {
108 static const char * const names[4] = {
109 "READ",
110 "WRITE",
111 "READ_WRITE",
112 nullptr
113 };
114 return names;
115 }
116
EnumNameAccessType(AccessType e)117 inline const char *EnumNameAccessType(AccessType e) {
118 if (flatbuffers::IsOutRange(e, AccessType::READ, AccessType::READ_WRITE)) return "";
119 const size_t index = static_cast<size_t>(e);
120 return EnumNamesAccessType()[index];
121 }
122
123 enum class DataType : int8_t {
124 UNKNOWN = 0,
125 FLOAT16 = 1,
126 FLOAT32 = 2,
127 FLOAT64 = 3,
128 UINT8 = 4,
129 INT8 = 5,
130 UINT16 = 6,
131 INT16 = 7,
132 UINT32 = 8,
133 INT32 = 9,
134 UINT64 = 10,
135 INT64 = 11,
136 MIN = UNKNOWN,
137 MAX = INT64
138 };
139
EnumValuesDataType()140 inline const DataType (&EnumValuesDataType())[12] {
141 static const DataType values[] = {
142 DataType::UNKNOWN, DataType::FLOAT16, DataType::FLOAT32,
143 DataType::FLOAT64, DataType::UINT8, DataType::INT8,
144 DataType::UINT16, DataType::INT16, DataType::UINT32,
145 DataType::INT32, DataType::UINT64, DataType::INT64};
146 return values;
147 }
148
EnumNamesDataType()149 inline const char * const *EnumNamesDataType() {
150 static const char *const names[13] = {
151 "UNKNOWN", "FLOAT16", "FLOAT32", "FLOAT64", "UINT8", "INT8", "UINT16",
152 "INT16", "UINT32", "INT32", "UINT64", "INT64", nullptr};
153 return names;
154 }
155
EnumNameDataType(DataType e)156 inline const char *EnumNameDataType(DataType e) {
157 if (flatbuffers::IsOutRange(e, DataType::UNKNOWN, DataType::INT64)) return "";
158 const size_t index = static_cast<size_t>(e);
159 return EnumNamesDataType()[index];
160 }
161
162 enum class MemoryType : int8_t {
163 GLOBAL = 0,
164 CONSTANT = 1,
165 LOCAL = 2,
166 MIN = GLOBAL,
167 MAX = LOCAL
168 };
169
EnumValuesMemoryType()170 inline const MemoryType (&EnumValuesMemoryType())[3] {
171 static const MemoryType values[] = {
172 MemoryType::GLOBAL,
173 MemoryType::CONSTANT,
174 MemoryType::LOCAL
175 };
176 return values;
177 }
178
EnumNamesMemoryType()179 inline const char * const *EnumNamesMemoryType() {
180 static const char * const names[4] = {
181 "GLOBAL",
182 "CONSTANT",
183 "LOCAL",
184 nullptr
185 };
186 return names;
187 }
188
EnumNameMemoryType(MemoryType e)189 inline const char *EnumNameMemoryType(MemoryType e) {
190 if (flatbuffers::IsOutRange(e, MemoryType::GLOBAL, MemoryType::LOCAL)) return "";
191 const size_t index = static_cast<size_t>(e);
192 return EnumNamesMemoryType()[index];
193 }
194
195 enum class LinearStorageType : int8_t {
196 BUFFER = 0,
197 TEXTURE_2D = 1,
198 MIN = BUFFER,
199 MAX = TEXTURE_2D
200 };
201
EnumValuesLinearStorageType()202 inline const LinearStorageType (&EnumValuesLinearStorageType())[2] {
203 static const LinearStorageType values[] = {
204 LinearStorageType::BUFFER,
205 LinearStorageType::TEXTURE_2D
206 };
207 return values;
208 }
209
EnumNamesLinearStorageType()210 inline const char * const *EnumNamesLinearStorageType() {
211 static const char * const names[3] = {
212 "BUFFER",
213 "TEXTURE_2D",
214 nullptr
215 };
216 return names;
217 }
218
EnumNameLinearStorageType(LinearStorageType e)219 inline const char *EnumNameLinearStorageType(LinearStorageType e) {
220 if (flatbuffers::IsOutRange(e, LinearStorageType::BUFFER, LinearStorageType::TEXTURE_2D)) return "";
221 const size_t index = static_cast<size_t>(e);
222 return EnumNamesLinearStorageType()[index];
223 }
224
225 enum class TensorStorageType : int8_t {
226 UNKNOWN = 0,
227 BUFFER = 1,
228 IMAGE_BUFFER = 2,
229 TEXTURE_2D = 3,
230 TEXTURE_3D = 4,
231 TEXTURE_ARRAY = 5,
232 SINGLE_TEXTURE_2D = 6,
233 MIN = UNKNOWN,
234 MAX = SINGLE_TEXTURE_2D
235 };
236
EnumValuesTensorStorageType()237 inline const TensorStorageType (&EnumValuesTensorStorageType())[7] {
238 static const TensorStorageType values[] = {
239 TensorStorageType::UNKNOWN,
240 TensorStorageType::BUFFER,
241 TensorStorageType::IMAGE_BUFFER,
242 TensorStorageType::TEXTURE_2D,
243 TensorStorageType::TEXTURE_3D,
244 TensorStorageType::TEXTURE_ARRAY,
245 TensorStorageType::SINGLE_TEXTURE_2D
246 };
247 return values;
248 }
249
EnumNamesTensorStorageType()250 inline const char * const *EnumNamesTensorStorageType() {
251 static const char * const names[8] = {
252 "UNKNOWN",
253 "BUFFER",
254 "IMAGE_BUFFER",
255 "TEXTURE_2D",
256 "TEXTURE_3D",
257 "TEXTURE_ARRAY",
258 "SINGLE_TEXTURE_2D",
259 nullptr
260 };
261 return names;
262 }
263
EnumNameTensorStorageType(TensorStorageType e)264 inline const char *EnumNameTensorStorageType(TensorStorageType e) {
265 if (flatbuffers::IsOutRange(e, TensorStorageType::UNKNOWN, TensorStorageType::SINGLE_TEXTURE_2D)) return "";
266 const size_t index = static_cast<size_t>(e);
267 return EnumNamesTensorStorageType()[index];
268 }
269
270 enum class Layout : int8_t {
271 UNKNOWN = 0,
272 HWC = 1,
273 BHWC = 2,
274 HWDC = 3,
275 BHWDC = 4,
276 MIN = UNKNOWN,
277 MAX = BHWDC
278 };
279
EnumValuesLayout()280 inline const Layout (&EnumValuesLayout())[5] {
281 static const Layout values[] = {
282 Layout::UNKNOWN,
283 Layout::HWC,
284 Layout::BHWC,
285 Layout::HWDC,
286 Layout::BHWDC
287 };
288 return values;
289 }
290
EnumNamesLayout()291 inline const char * const *EnumNamesLayout() {
292 static const char * const names[6] = {
293 "UNKNOWN",
294 "HWC",
295 "BHWC",
296 "HWDC",
297 "BHWDC",
298 nullptr
299 };
300 return names;
301 }
302
EnumNameLayout(Layout e)303 inline const char *EnumNameLayout(Layout e) {
304 if (flatbuffers::IsOutRange(e, Layout::UNKNOWN, Layout::BHWDC)) return "";
305 const size_t index = static_cast<size_t>(e);
306 return EnumNamesLayout()[index];
307 }
308
309 enum class CalculationsPrecision : int8_t {
310 F32 = 0,
311 F32_F16 = 1,
312 F16 = 2,
313 MIN = F32,
314 MAX = F16
315 };
316
EnumValuesCalculationsPrecision()317 inline const CalculationsPrecision (&EnumValuesCalculationsPrecision())[3] {
318 static const CalculationsPrecision values[] = {CalculationsPrecision::F32,
319 CalculationsPrecision::F32_F16,
320 CalculationsPrecision::F16};
321 return values;
322 }
323
EnumNamesCalculationsPrecision()324 inline const char *const *EnumNamesCalculationsPrecision() {
325 static const char *const names[4] = {"F32", "F32_F16", "F16", nullptr};
326 return names;
327 }
328
EnumNameCalculationsPrecision(CalculationsPrecision e)329 inline const char *EnumNameCalculationsPrecision(CalculationsPrecision e) {
330 if (flatbuffers::IsOutRange(e, CalculationsPrecision::F32,
331 CalculationsPrecision::F16))
332 return "";
333 const size_t index = static_cast<size_t>(e);
334 return EnumNamesCalculationsPrecision()[index];
335 }
336
337 enum class TensorToGrid : int8_t {
338 CUSTOM = 0,
339 WB_TO_X_HD_TO_Y_S_TO_Z = 1,
340 WB_TO_X_HD_TO_Y_Z_IS_1 = 2,
341 WB_TO_X_H_TO_Y_D_TO_Z = 3,
342 B_TO_X_Y_IS_1_Z_IS_1 = 4,
343 MIN = CUSTOM,
344 MAX = B_TO_X_Y_IS_1_Z_IS_1
345 };
346
EnumValuesTensorToGrid()347 inline const TensorToGrid (&EnumValuesTensorToGrid())[5] {
348 static const TensorToGrid values[] = {
349 TensorToGrid::CUSTOM, TensorToGrid::WB_TO_X_HD_TO_Y_S_TO_Z,
350 TensorToGrid::WB_TO_X_HD_TO_Y_Z_IS_1, TensorToGrid::WB_TO_X_H_TO_Y_D_TO_Z,
351 TensorToGrid::B_TO_X_Y_IS_1_Z_IS_1};
352 return values;
353 }
354
EnumNamesTensorToGrid()355 inline const char *const *EnumNamesTensorToGrid() {
356 static const char *const names[6] = {"CUSTOM",
357 "WB_TO_X_HD_TO_Y_S_TO_Z",
358 "WB_TO_X_HD_TO_Y_Z_IS_1",
359 "WB_TO_X_H_TO_Y_D_TO_Z",
360 "B_TO_X_Y_IS_1_Z_IS_1",
361 nullptr};
362 return names;
363 }
364
EnumNameTensorToGrid(TensorToGrid e)365 inline const char *EnumNameTensorToGrid(TensorToGrid e) {
366 if (flatbuffers::IsOutRange(e, TensorToGrid::CUSTOM,
367 TensorToGrid::B_TO_X_Y_IS_1_Z_IS_1))
368 return "";
369 const size_t index = static_cast<size_t>(e);
370 return EnumNamesTensorToGrid()[index];
371 }
372
373 enum class CompilerOptions : int8_t {
374 ADRENO_FULL_SIMD_LINE = 0,
375 ADRENO_MORE_WAVES = 1,
376 POWERVR_FP16 = 2,
377 CL_OPT_DISABLE = 3,
378 CL_2_0 = 4,
379 CL_3_0 = 5,
380 MIN = ADRENO_FULL_SIMD_LINE,
381 MAX = CL_3_0
382 };
383
EnumValuesCompilerOptions()384 inline const CompilerOptions (&EnumValuesCompilerOptions())[6] {
385 static const CompilerOptions values[] = {
386 CompilerOptions::ADRENO_FULL_SIMD_LINE,
387 CompilerOptions::ADRENO_MORE_WAVES,
388 CompilerOptions::POWERVR_FP16,
389 CompilerOptions::CL_OPT_DISABLE,
390 CompilerOptions::CL_2_0,
391 CompilerOptions::CL_3_0};
392 return values;
393 }
394
EnumNamesCompilerOptions()395 inline const char *const *EnumNamesCompilerOptions() {
396 static const char *const names[7] = {"ADRENO_FULL_SIMD_LINE",
397 "ADRENO_MORE_WAVES",
398 "POWERVR_FP16",
399 "CL_OPT_DISABLE",
400 "CL_2_0",
401 "CL_3_0",
402 nullptr};
403 return names;
404 }
405
EnumNameCompilerOptions(CompilerOptions e)406 inline const char *EnumNameCompilerOptions(CompilerOptions e) {
407 if (flatbuffers::IsOutRange(e, CompilerOptions::ADRENO_FULL_SIMD_LINE,
408 CompilerOptions::CL_3_0))
409 return "";
410 const size_t index = static_cast<size_t>(e);
411 return EnumNamesCompilerOptions()[index];
412 }
413
414 struct Int4 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
415 typedef Int4Builder Builder;
416 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
417 VT_X = 4,
418 VT_Y = 6,
419 VT_Z = 8,
420 VT_W = 10
421 };
xFLATBUFFERS_FINAL_CLASS422 int32_t x() const {
423 return GetField<int32_t>(VT_X, 0);
424 }
yFLATBUFFERS_FINAL_CLASS425 int32_t y() const {
426 return GetField<int32_t>(VT_Y, 0);
427 }
zFLATBUFFERS_FINAL_CLASS428 int32_t z() const {
429 return GetField<int32_t>(VT_Z, 0);
430 }
wFLATBUFFERS_FINAL_CLASS431 int32_t w() const {
432 return GetField<int32_t>(VT_W, 0);
433 }
VerifyFLATBUFFERS_FINAL_CLASS434 bool Verify(flatbuffers::Verifier &verifier) const {
435 return VerifyTableStart(verifier) &&
436 VerifyField<int32_t>(verifier, VT_X) &&
437 VerifyField<int32_t>(verifier, VT_Y) &&
438 VerifyField<int32_t>(verifier, VT_Z) &&
439 VerifyField<int32_t>(verifier, VT_W) &&
440 verifier.EndTable();
441 }
442 };
443
444 struct Int4Builder {
445 typedef Int4 Table;
446 flatbuffers::FlatBufferBuilder &fbb_;
447 flatbuffers::uoffset_t start_;
add_xInt4Builder448 void add_x(int32_t x) {
449 fbb_.AddElement<int32_t>(Int4::VT_X, x, 0);
450 }
add_yInt4Builder451 void add_y(int32_t y) {
452 fbb_.AddElement<int32_t>(Int4::VT_Y, y, 0);
453 }
add_zInt4Builder454 void add_z(int32_t z) {
455 fbb_.AddElement<int32_t>(Int4::VT_Z, z, 0);
456 }
add_wInt4Builder457 void add_w(int32_t w) {
458 fbb_.AddElement<int32_t>(Int4::VT_W, w, 0);
459 }
Int4BuilderInt4Builder460 explicit Int4Builder(flatbuffers::FlatBufferBuilder &_fbb)
461 : fbb_(_fbb) {
462 start_ = fbb_.StartTable();
463 }
FinishInt4Builder464 flatbuffers::Offset<Int4> Finish() {
465 const auto end = fbb_.EndTable(start_);
466 auto o = flatbuffers::Offset<Int4>(end);
467 return o;
468 }
469 };
470
471 inline flatbuffers::Offset<Int4> CreateInt4(
472 flatbuffers::FlatBufferBuilder &_fbb,
473 int32_t x = 0,
474 int32_t y = 0,
475 int32_t z = 0,
476 int32_t w = 0) {
477 Int4Builder builder_(_fbb);
478 builder_.add_w(w);
479 builder_.add_z(z);
480 builder_.add_y(y);
481 builder_.add_x(x);
482 return builder_.Finish();
483 }
484
485 struct Int3 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
486 typedef Int3Builder Builder;
487 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
488 VT_X = 4,
489 VT_Y = 6,
490 VT_Z = 8
491 };
xFLATBUFFERS_FINAL_CLASS492 int32_t x() const {
493 return GetField<int32_t>(VT_X, 0);
494 }
yFLATBUFFERS_FINAL_CLASS495 int32_t y() const {
496 return GetField<int32_t>(VT_Y, 0);
497 }
zFLATBUFFERS_FINAL_CLASS498 int32_t z() const {
499 return GetField<int32_t>(VT_Z, 0);
500 }
VerifyFLATBUFFERS_FINAL_CLASS501 bool Verify(flatbuffers::Verifier &verifier) const {
502 return VerifyTableStart(verifier) &&
503 VerifyField<int32_t>(verifier, VT_X) &&
504 VerifyField<int32_t>(verifier, VT_Y) &&
505 VerifyField<int32_t>(verifier, VT_Z) &&
506 verifier.EndTable();
507 }
508 };
509
510 struct Int3Builder {
511 typedef Int3 Table;
512 flatbuffers::FlatBufferBuilder &fbb_;
513 flatbuffers::uoffset_t start_;
add_xInt3Builder514 void add_x(int32_t x) {
515 fbb_.AddElement<int32_t>(Int3::VT_X, x, 0);
516 }
add_yInt3Builder517 void add_y(int32_t y) {
518 fbb_.AddElement<int32_t>(Int3::VT_Y, y, 0);
519 }
add_zInt3Builder520 void add_z(int32_t z) {
521 fbb_.AddElement<int32_t>(Int3::VT_Z, z, 0);
522 }
Int3BuilderInt3Builder523 explicit Int3Builder(flatbuffers::FlatBufferBuilder &_fbb)
524 : fbb_(_fbb) {
525 start_ = fbb_.StartTable();
526 }
FinishInt3Builder527 flatbuffers::Offset<Int3> Finish() {
528 const auto end = fbb_.EndTable(start_);
529 auto o = flatbuffers::Offset<Int3>(end);
530 return o;
531 }
532 };
533
534 inline flatbuffers::Offset<Int3> CreateInt3(
535 flatbuffers::FlatBufferBuilder &_fbb,
536 int32_t x = 0,
537 int32_t y = 0,
538 int32_t z = 0) {
539 Int3Builder builder_(_fbb);
540 builder_.add_z(z);
541 builder_.add_y(y);
542 builder_.add_x(x);
543 return builder_.Finish();
544 }
545
546 struct Int2 FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
547 typedef Int2Builder Builder;
548 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
549 VT_X = 4,
550 VT_Y = 6
551 };
xFLATBUFFERS_FINAL_CLASS552 int32_t x() const {
553 return GetField<int32_t>(VT_X, 0);
554 }
yFLATBUFFERS_FINAL_CLASS555 int32_t y() const {
556 return GetField<int32_t>(VT_Y, 0);
557 }
VerifyFLATBUFFERS_FINAL_CLASS558 bool Verify(flatbuffers::Verifier &verifier) const {
559 return VerifyTableStart(verifier) &&
560 VerifyField<int32_t>(verifier, VT_X) &&
561 VerifyField<int32_t>(verifier, VT_Y) &&
562 verifier.EndTable();
563 }
564 };
565
566 struct Int2Builder {
567 typedef Int2 Table;
568 flatbuffers::FlatBufferBuilder &fbb_;
569 flatbuffers::uoffset_t start_;
add_xInt2Builder570 void add_x(int32_t x) {
571 fbb_.AddElement<int32_t>(Int2::VT_X, x, 0);
572 }
add_yInt2Builder573 void add_y(int32_t y) {
574 fbb_.AddElement<int32_t>(Int2::VT_Y, y, 0);
575 }
Int2BuilderInt2Builder576 explicit Int2Builder(flatbuffers::FlatBufferBuilder &_fbb)
577 : fbb_(_fbb) {
578 start_ = fbb_.StartTable();
579 }
FinishInt2Builder580 flatbuffers::Offset<Int2> Finish() {
581 const auto end = fbb_.EndTable(start_);
582 auto o = flatbuffers::Offset<Int2>(end);
583 return o;
584 }
585 };
586
587 inline flatbuffers::Offset<Int2> CreateInt2(
588 flatbuffers::FlatBufferBuilder &_fbb,
589 int32_t x = 0,
590 int32_t y = 0) {
591 Int2Builder builder_(_fbb);
592 builder_.add_y(y);
593 builder_.add_x(x);
594 return builder_.Finish();
595 }
596
597 struct StateVariable FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
598 typedef StateVariableBuilder Builder;
599 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
600 VT_KEY = 4,
601 VT_VALUE = 6
602 };
keyFLATBUFFERS_FINAL_CLASS603 const flatbuffers::String *key() const {
604 return GetPointer<const flatbuffers::String *>(VT_KEY);
605 }
valueFLATBUFFERS_FINAL_CLASS606 const flatbuffers::String *value() const {
607 return GetPointer<const flatbuffers::String *>(VT_VALUE);
608 }
VerifyFLATBUFFERS_FINAL_CLASS609 bool Verify(flatbuffers::Verifier &verifier) const {
610 return VerifyTableStart(verifier) &&
611 VerifyOffset(verifier, VT_KEY) &&
612 verifier.VerifyString(key()) &&
613 VerifyOffset(verifier, VT_VALUE) &&
614 verifier.VerifyString(value()) &&
615 verifier.EndTable();
616 }
617 };
618
619 struct StateVariableBuilder {
620 typedef StateVariable Table;
621 flatbuffers::FlatBufferBuilder &fbb_;
622 flatbuffers::uoffset_t start_;
add_keyStateVariableBuilder623 void add_key(flatbuffers::Offset<flatbuffers::String> key) {
624 fbb_.AddOffset(StateVariable::VT_KEY, key);
625 }
add_valueStateVariableBuilder626 void add_value(flatbuffers::Offset<flatbuffers::String> value) {
627 fbb_.AddOffset(StateVariable::VT_VALUE, value);
628 }
StateVariableBuilderStateVariableBuilder629 explicit StateVariableBuilder(flatbuffers::FlatBufferBuilder &_fbb)
630 : fbb_(_fbb) {
631 start_ = fbb_.StartTable();
632 }
FinishStateVariableBuilder633 flatbuffers::Offset<StateVariable> Finish() {
634 const auto end = fbb_.EndTable(start_);
635 auto o = flatbuffers::Offset<StateVariable>(end);
636 return o;
637 }
638 };
639
640 inline flatbuffers::Offset<StateVariable> CreateStateVariable(
641 flatbuffers::FlatBufferBuilder &_fbb,
642 flatbuffers::Offset<flatbuffers::String> key = 0,
643 flatbuffers::Offset<flatbuffers::String> value = 0) {
644 StateVariableBuilder builder_(_fbb);
645 builder_.add_value(value);
646 builder_.add_key(key);
647 return builder_.Finish();
648 }
649
650 inline flatbuffers::Offset<StateVariable> CreateStateVariableDirect(
651 flatbuffers::FlatBufferBuilder &_fbb,
652 const char *key = nullptr,
653 const char *value = nullptr) {
654 auto key__ = key ? _fbb.CreateString(key) : 0;
655 auto value__ = value ? _fbb.CreateString(value) : 0;
656 return tflite::gpu::data::CreateStateVariable(
657 _fbb,
658 key__,
659 value__);
660 }
661
662 struct GPUObjectDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
663 typedef GPUObjectDescriptorBuilder Builder;
664 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
665 VT_STATE_VARS = 4,
666 VT_ACCESS_TYPE = 6
667 };
state_varsFLATBUFFERS_FINAL_CLASS668 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>> *state_vars() const {
669 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>> *>(VT_STATE_VARS);
670 }
access_typeFLATBUFFERS_FINAL_CLASS671 tflite::gpu::data::AccessType access_type() const {
672 return static_cast<tflite::gpu::data::AccessType>(GetField<int8_t>(VT_ACCESS_TYPE, 0));
673 }
VerifyFLATBUFFERS_FINAL_CLASS674 bool Verify(flatbuffers::Verifier &verifier) const {
675 return VerifyTableStart(verifier) &&
676 VerifyOffset(verifier, VT_STATE_VARS) &&
677 verifier.VerifyVector(state_vars()) &&
678 verifier.VerifyVectorOfTables(state_vars()) &&
679 VerifyField<int8_t>(verifier, VT_ACCESS_TYPE) &&
680 verifier.EndTable();
681 }
682 };
683
684 struct GPUObjectDescriptorBuilder {
685 typedef GPUObjectDescriptor Table;
686 flatbuffers::FlatBufferBuilder &fbb_;
687 flatbuffers::uoffset_t start_;
add_state_varsGPUObjectDescriptorBuilder688 void add_state_vars(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>>> state_vars) {
689 fbb_.AddOffset(GPUObjectDescriptor::VT_STATE_VARS, state_vars);
690 }
add_access_typeGPUObjectDescriptorBuilder691 void add_access_type(tflite::gpu::data::AccessType access_type) {
692 fbb_.AddElement<int8_t>(GPUObjectDescriptor::VT_ACCESS_TYPE, static_cast<int8_t>(access_type), 0);
693 }
GPUObjectDescriptorBuilderGPUObjectDescriptorBuilder694 explicit GPUObjectDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
695 : fbb_(_fbb) {
696 start_ = fbb_.StartTable();
697 }
FinishGPUObjectDescriptorBuilder698 flatbuffers::Offset<GPUObjectDescriptor> Finish() {
699 const auto end = fbb_.EndTable(start_);
700 auto o = flatbuffers::Offset<GPUObjectDescriptor>(end);
701 return o;
702 }
703 };
704
705 inline flatbuffers::Offset<GPUObjectDescriptor> CreateGPUObjectDescriptor(
706 flatbuffers::FlatBufferBuilder &_fbb,
707 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>>> state_vars = 0,
708 tflite::gpu::data::AccessType access_type = tflite::gpu::data::AccessType::READ) {
709 GPUObjectDescriptorBuilder builder_(_fbb);
710 builder_.add_state_vars(state_vars);
711 builder_.add_access_type(access_type);
712 return builder_.Finish();
713 }
714
715 inline flatbuffers::Offset<GPUObjectDescriptor> CreateGPUObjectDescriptorDirect(
716 flatbuffers::FlatBufferBuilder &_fbb,
717 const std::vector<flatbuffers::Offset<tflite::gpu::data::StateVariable>> *state_vars = nullptr,
718 tflite::gpu::data::AccessType access_type = tflite::gpu::data::AccessType::READ) {
719 auto state_vars__ = state_vars ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::StateVariable>>(*state_vars) : 0;
720 return tflite::gpu::data::CreateGPUObjectDescriptor(
721 _fbb,
722 state_vars__,
723 access_type);
724 }
725
726 struct IntValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
727 typedef IntValueBuilder Builder;
728 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
729 VT_NAME = 4,
730 VT_VALUE = 6,
731 VT_ACTIVE = 8
732 };
nameFLATBUFFERS_FINAL_CLASS733 const flatbuffers::String *name() const {
734 return GetPointer<const flatbuffers::String *>(VT_NAME);
735 }
valueFLATBUFFERS_FINAL_CLASS736 int32_t value() const {
737 return GetField<int32_t>(VT_VALUE, 0);
738 }
activeFLATBUFFERS_FINAL_CLASS739 bool active() const {
740 return GetField<uint8_t>(VT_ACTIVE, 0) != 0;
741 }
VerifyFLATBUFFERS_FINAL_CLASS742 bool Verify(flatbuffers::Verifier &verifier) const {
743 return VerifyTableStart(verifier) &&
744 VerifyOffset(verifier, VT_NAME) &&
745 verifier.VerifyString(name()) &&
746 VerifyField<int32_t>(verifier, VT_VALUE) &&
747 VerifyField<uint8_t>(verifier, VT_ACTIVE) &&
748 verifier.EndTable();
749 }
750 };
751
752 struct IntValueBuilder {
753 typedef IntValue Table;
754 flatbuffers::FlatBufferBuilder &fbb_;
755 flatbuffers::uoffset_t start_;
add_nameIntValueBuilder756 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
757 fbb_.AddOffset(IntValue::VT_NAME, name);
758 }
add_valueIntValueBuilder759 void add_value(int32_t value) {
760 fbb_.AddElement<int32_t>(IntValue::VT_VALUE, value, 0);
761 }
add_activeIntValueBuilder762 void add_active(bool active) {
763 fbb_.AddElement<uint8_t>(IntValue::VT_ACTIVE, static_cast<uint8_t>(active), 0);
764 }
IntValueBuilderIntValueBuilder765 explicit IntValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
766 : fbb_(_fbb) {
767 start_ = fbb_.StartTable();
768 }
FinishIntValueBuilder769 flatbuffers::Offset<IntValue> Finish() {
770 const auto end = fbb_.EndTable(start_);
771 auto o = flatbuffers::Offset<IntValue>(end);
772 return o;
773 }
774 };
775
776 inline flatbuffers::Offset<IntValue> CreateIntValue(
777 flatbuffers::FlatBufferBuilder &_fbb,
778 flatbuffers::Offset<flatbuffers::String> name = 0,
779 int32_t value = 0,
780 bool active = false) {
781 IntValueBuilder builder_(_fbb);
782 builder_.add_value(value);
783 builder_.add_name(name);
784 builder_.add_active(active);
785 return builder_.Finish();
786 }
787
788 inline flatbuffers::Offset<IntValue> CreateIntValueDirect(
789 flatbuffers::FlatBufferBuilder &_fbb,
790 const char *name = nullptr,
791 int32_t value = 0,
792 bool active = false) {
793 auto name__ = name ? _fbb.CreateString(name) : 0;
794 return tflite::gpu::data::CreateIntValue(
795 _fbb,
796 name__,
797 value,
798 active);
799 }
800
801 struct FloatValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
802 typedef FloatValueBuilder Builder;
803 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
804 VT_NAME = 4,
805 VT_VALUE = 6,
806 VT_ACTIVE = 8
807 };
nameFLATBUFFERS_FINAL_CLASS808 const flatbuffers::String *name() const {
809 return GetPointer<const flatbuffers::String *>(VT_NAME);
810 }
valueFLATBUFFERS_FINAL_CLASS811 float value() const {
812 return GetField<float>(VT_VALUE, 0.0f);
813 }
activeFLATBUFFERS_FINAL_CLASS814 bool active() const {
815 return GetField<uint8_t>(VT_ACTIVE, 0) != 0;
816 }
VerifyFLATBUFFERS_FINAL_CLASS817 bool Verify(flatbuffers::Verifier &verifier) const {
818 return VerifyTableStart(verifier) &&
819 VerifyOffset(verifier, VT_NAME) &&
820 verifier.VerifyString(name()) &&
821 VerifyField<float>(verifier, VT_VALUE) &&
822 VerifyField<uint8_t>(verifier, VT_ACTIVE) &&
823 verifier.EndTable();
824 }
825 };
826
827 struct FloatValueBuilder {
828 typedef FloatValue Table;
829 flatbuffers::FlatBufferBuilder &fbb_;
830 flatbuffers::uoffset_t start_;
add_nameFloatValueBuilder831 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
832 fbb_.AddOffset(FloatValue::VT_NAME, name);
833 }
add_valueFloatValueBuilder834 void add_value(float value) {
835 fbb_.AddElement<float>(FloatValue::VT_VALUE, value, 0.0f);
836 }
add_activeFloatValueBuilder837 void add_active(bool active) {
838 fbb_.AddElement<uint8_t>(FloatValue::VT_ACTIVE, static_cast<uint8_t>(active), 0);
839 }
FloatValueBuilderFloatValueBuilder840 explicit FloatValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
841 : fbb_(_fbb) {
842 start_ = fbb_.StartTable();
843 }
FinishFloatValueBuilder844 flatbuffers::Offset<FloatValue> Finish() {
845 const auto end = fbb_.EndTable(start_);
846 auto o = flatbuffers::Offset<FloatValue>(end);
847 return o;
848 }
849 };
850
851 inline flatbuffers::Offset<FloatValue> CreateFloatValue(
852 flatbuffers::FlatBufferBuilder &_fbb,
853 flatbuffers::Offset<flatbuffers::String> name = 0,
854 float value = 0.0f,
855 bool active = false) {
856 FloatValueBuilder builder_(_fbb);
857 builder_.add_value(value);
858 builder_.add_name(name);
859 builder_.add_active(active);
860 return builder_.Finish();
861 }
862
863 inline flatbuffers::Offset<FloatValue> CreateFloatValueDirect(
864 flatbuffers::FlatBufferBuilder &_fbb,
865 const char *name = nullptr,
866 float value = 0.0f,
867 bool active = false) {
868 auto name__ = name ? _fbb.CreateString(name) : 0;
869 return tflite::gpu::data::CreateFloatValue(
870 _fbb,
871 name__,
872 value,
873 active);
874 }
875
876 struct HalfValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
877 typedef HalfValueBuilder Builder;
878 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
879 VT_NAME = 4,
880 VT_VALUE = 6,
881 VT_ACTIVE = 8
882 };
nameFLATBUFFERS_FINAL_CLASS883 const flatbuffers::String *name() const {
884 return GetPointer<const flatbuffers::String *>(VT_NAME);
885 }
valueFLATBUFFERS_FINAL_CLASS886 float value() const {
887 return GetField<float>(VT_VALUE, 0.0f);
888 }
activeFLATBUFFERS_FINAL_CLASS889 bool active() const {
890 return GetField<uint8_t>(VT_ACTIVE, 0) != 0;
891 }
VerifyFLATBUFFERS_FINAL_CLASS892 bool Verify(flatbuffers::Verifier &verifier) const {
893 return VerifyTableStart(verifier) &&
894 VerifyOffset(verifier, VT_NAME) &&
895 verifier.VerifyString(name()) &&
896 VerifyField<float>(verifier, VT_VALUE) &&
897 VerifyField<uint8_t>(verifier, VT_ACTIVE) &&
898 verifier.EndTable();
899 }
900 };
901
902 struct HalfValueBuilder {
903 typedef HalfValue Table;
904 flatbuffers::FlatBufferBuilder &fbb_;
905 flatbuffers::uoffset_t start_;
add_nameHalfValueBuilder906 void add_name(flatbuffers::Offset<flatbuffers::String> name) {
907 fbb_.AddOffset(HalfValue::VT_NAME, name);
908 }
add_valueHalfValueBuilder909 void add_value(float value) {
910 fbb_.AddElement<float>(HalfValue::VT_VALUE, value, 0.0f);
911 }
add_activeHalfValueBuilder912 void add_active(bool active) {
913 fbb_.AddElement<uint8_t>(HalfValue::VT_ACTIVE, static_cast<uint8_t>(active), 0);
914 }
HalfValueBuilderHalfValueBuilder915 explicit HalfValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
916 : fbb_(_fbb) {
917 start_ = fbb_.StartTable();
918 }
FinishHalfValueBuilder919 flatbuffers::Offset<HalfValue> Finish() {
920 const auto end = fbb_.EndTable(start_);
921 auto o = flatbuffers::Offset<HalfValue>(end);
922 return o;
923 }
924 };
925
926 inline flatbuffers::Offset<HalfValue> CreateHalfValue(
927 flatbuffers::FlatBufferBuilder &_fbb,
928 flatbuffers::Offset<flatbuffers::String> name = 0,
929 float value = 0.0f,
930 bool active = false) {
931 HalfValueBuilder builder_(_fbb);
932 builder_.add_value(value);
933 builder_.add_name(name);
934 builder_.add_active(active);
935 return builder_.Finish();
936 }
937
938 inline flatbuffers::Offset<HalfValue> CreateHalfValueDirect(
939 flatbuffers::FlatBufferBuilder &_fbb,
940 const char *name = nullptr,
941 float value = 0.0f,
942 bool active = false) {
943 auto name__ = name ? _fbb.CreateString(name) : 0;
944 return tflite::gpu::data::CreateHalfValue(
945 _fbb,
946 name__,
947 value,
948 active);
949 }
950
951 struct BufferDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
952 typedef BufferDescriptorBuilder Builder;
953 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
954 VT_BASE_OBJ = 4,
955 VT_ELEMENT_TYPE = 6,
956 VT_ELEMENT_SIZE = 8,
957 VT_MEMORY_TYPE = 10,
958 VT_ATTRIBUTES = 12,
959 VT_SIZE = 14,
960 VT_DATA = 16
961 };
base_objFLATBUFFERS_FINAL_CLASS962 const tflite::gpu::data::GPUObjectDescriptor *base_obj() const {
963 return GetPointer<const tflite::gpu::data::GPUObjectDescriptor *>(VT_BASE_OBJ);
964 }
element_typeFLATBUFFERS_FINAL_CLASS965 tflite::gpu::data::DataType element_type() const {
966 return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_ELEMENT_TYPE, 0));
967 }
element_sizeFLATBUFFERS_FINAL_CLASS968 int32_t element_size() const {
969 return GetField<int32_t>(VT_ELEMENT_SIZE, 0);
970 }
memory_typeFLATBUFFERS_FINAL_CLASS971 tflite::gpu::data::MemoryType memory_type() const {
972 return static_cast<tflite::gpu::data::MemoryType>(GetField<int8_t>(VT_MEMORY_TYPE, 0));
973 }
attributesFLATBUFFERS_FINAL_CLASS974 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *attributes() const {
975 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_ATTRIBUTES);
976 }
sizeFLATBUFFERS_FINAL_CLASS977 int32_t size() const {
978 return GetField<int32_t>(VT_SIZE, 0);
979 }
dataFLATBUFFERS_FINAL_CLASS980 const flatbuffers::Vector<uint8_t> *data() const {
981 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
982 }
VerifyFLATBUFFERS_FINAL_CLASS983 bool Verify(flatbuffers::Verifier &verifier) const {
984 return VerifyTableStart(verifier) &&
985 VerifyOffset(verifier, VT_BASE_OBJ) &&
986 verifier.VerifyTable(base_obj()) &&
987 VerifyField<int8_t>(verifier, VT_ELEMENT_TYPE) &&
988 VerifyField<int32_t>(verifier, VT_ELEMENT_SIZE) &&
989 VerifyField<int8_t>(verifier, VT_MEMORY_TYPE) &&
990 VerifyOffset(verifier, VT_ATTRIBUTES) &&
991 verifier.VerifyVector(attributes()) &&
992 verifier.VerifyVectorOfStrings(attributes()) &&
993 VerifyField<int32_t>(verifier, VT_SIZE) &&
994 VerifyOffset(verifier, VT_DATA) &&
995 verifier.VerifyVector(data()) &&
996 verifier.EndTable();
997 }
998 };
999
1000 struct BufferDescriptorBuilder {
1001 typedef BufferDescriptor Table;
1002 flatbuffers::FlatBufferBuilder &fbb_;
1003 flatbuffers::uoffset_t start_;
add_base_objBufferDescriptorBuilder1004 void add_base_obj(flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj) {
1005 fbb_.AddOffset(BufferDescriptor::VT_BASE_OBJ, base_obj);
1006 }
add_element_typeBufferDescriptorBuilder1007 void add_element_type(tflite::gpu::data::DataType element_type) {
1008 fbb_.AddElement<int8_t>(BufferDescriptor::VT_ELEMENT_TYPE, static_cast<int8_t>(element_type), 0);
1009 }
add_element_sizeBufferDescriptorBuilder1010 void add_element_size(int32_t element_size) {
1011 fbb_.AddElement<int32_t>(BufferDescriptor::VT_ELEMENT_SIZE, element_size, 0);
1012 }
add_memory_typeBufferDescriptorBuilder1013 void add_memory_type(tflite::gpu::data::MemoryType memory_type) {
1014 fbb_.AddElement<int8_t>(BufferDescriptor::VT_MEMORY_TYPE, static_cast<int8_t>(memory_type), 0);
1015 }
add_attributesBufferDescriptorBuilder1016 void add_attributes(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> attributes) {
1017 fbb_.AddOffset(BufferDescriptor::VT_ATTRIBUTES, attributes);
1018 }
add_sizeBufferDescriptorBuilder1019 void add_size(int32_t size) {
1020 fbb_.AddElement<int32_t>(BufferDescriptor::VT_SIZE, size, 0);
1021 }
add_dataBufferDescriptorBuilder1022 void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
1023 fbb_.AddOffset(BufferDescriptor::VT_DATA, data);
1024 }
BufferDescriptorBuilderBufferDescriptorBuilder1025 explicit BufferDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1026 : fbb_(_fbb) {
1027 start_ = fbb_.StartTable();
1028 }
FinishBufferDescriptorBuilder1029 flatbuffers::Offset<BufferDescriptor> Finish() {
1030 const auto end = fbb_.EndTable(start_);
1031 auto o = flatbuffers::Offset<BufferDescriptor>(end);
1032 return o;
1033 }
1034 };
1035
1036 inline flatbuffers::Offset<BufferDescriptor> CreateBufferDescriptor(
1037 flatbuffers::FlatBufferBuilder &_fbb,
1038 flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1039 tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1040 int32_t element_size = 0,
1041 tflite::gpu::data::MemoryType memory_type = tflite::gpu::data::MemoryType::GLOBAL,
1042 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> attributes = 0,
1043 int32_t size = 0,
1044 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
1045 BufferDescriptorBuilder builder_(_fbb);
1046 builder_.add_data(data);
1047 builder_.add_size(size);
1048 builder_.add_attributes(attributes);
1049 builder_.add_element_size(element_size);
1050 builder_.add_base_obj(base_obj);
1051 builder_.add_memory_type(memory_type);
1052 builder_.add_element_type(element_type);
1053 return builder_.Finish();
1054 }
1055
1056 inline flatbuffers::Offset<BufferDescriptor> CreateBufferDescriptorDirect(
1057 flatbuffers::FlatBufferBuilder &_fbb,
1058 flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1059 tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1060 int32_t element_size = 0,
1061 tflite::gpu::data::MemoryType memory_type = tflite::gpu::data::MemoryType::GLOBAL,
1062 const std::vector<flatbuffers::Offset<flatbuffers::String>> *attributes = nullptr,
1063 int32_t size = 0,
1064 const std::vector<uint8_t> *data = nullptr) {
1065 auto attributes__ = attributes ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*attributes) : 0;
1066 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
1067 return tflite::gpu::data::CreateBufferDescriptor(
1068 _fbb,
1069 base_obj,
1070 element_type,
1071 element_size,
1072 memory_type,
1073 attributes__,
1074 size,
1075 data__);
1076 }
1077
1078 struct Texture2DDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1079 typedef Texture2DDescriptorBuilder Builder;
1080 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1081 VT_BASE_OBJ = 4,
1082 VT_ELEMENT_TYPE = 6,
1083 VT_NORMALIZED = 8,
1084 VT_NORMALIZED_TYPE = 10,
1085 VT_SIZE = 12,
1086 VT_DATA = 14
1087 };
base_objFLATBUFFERS_FINAL_CLASS1088 const tflite::gpu::data::GPUObjectDescriptor *base_obj() const {
1089 return GetPointer<const tflite::gpu::data::GPUObjectDescriptor *>(VT_BASE_OBJ);
1090 }
element_typeFLATBUFFERS_FINAL_CLASS1091 tflite::gpu::data::DataType element_type() const {
1092 return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_ELEMENT_TYPE, 0));
1093 }
normalizedFLATBUFFERS_FINAL_CLASS1094 bool normalized() const {
1095 return GetField<uint8_t>(VT_NORMALIZED, 0) != 0;
1096 }
normalized_typeFLATBUFFERS_FINAL_CLASS1097 tflite::gpu::data::DataType normalized_type() const {
1098 return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_NORMALIZED_TYPE, 0));
1099 }
sizeFLATBUFFERS_FINAL_CLASS1100 const tflite::gpu::data::Int2 *size() const {
1101 return GetPointer<const tflite::gpu::data::Int2 *>(VT_SIZE);
1102 }
dataFLATBUFFERS_FINAL_CLASS1103 const flatbuffers::Vector<uint8_t> *data() const {
1104 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
1105 }
VerifyFLATBUFFERS_FINAL_CLASS1106 bool Verify(flatbuffers::Verifier &verifier) const {
1107 return VerifyTableStart(verifier) &&
1108 VerifyOffset(verifier, VT_BASE_OBJ) &&
1109 verifier.VerifyTable(base_obj()) &&
1110 VerifyField<int8_t>(verifier, VT_ELEMENT_TYPE) &&
1111 VerifyField<uint8_t>(verifier, VT_NORMALIZED) &&
1112 VerifyField<int8_t>(verifier, VT_NORMALIZED_TYPE) &&
1113 VerifyOffset(verifier, VT_SIZE) &&
1114 verifier.VerifyTable(size()) &&
1115 VerifyOffset(verifier, VT_DATA) &&
1116 verifier.VerifyVector(data()) &&
1117 verifier.EndTable();
1118 }
1119 };
1120
1121 struct Texture2DDescriptorBuilder {
1122 typedef Texture2DDescriptor Table;
1123 flatbuffers::FlatBufferBuilder &fbb_;
1124 flatbuffers::uoffset_t start_;
add_base_objTexture2DDescriptorBuilder1125 void add_base_obj(flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj) {
1126 fbb_.AddOffset(Texture2DDescriptor::VT_BASE_OBJ, base_obj);
1127 }
add_element_typeTexture2DDescriptorBuilder1128 void add_element_type(tflite::gpu::data::DataType element_type) {
1129 fbb_.AddElement<int8_t>(Texture2DDescriptor::VT_ELEMENT_TYPE, static_cast<int8_t>(element_type), 0);
1130 }
add_normalizedTexture2DDescriptorBuilder1131 void add_normalized(bool normalized) {
1132 fbb_.AddElement<uint8_t>(Texture2DDescriptor::VT_NORMALIZED, static_cast<uint8_t>(normalized), 0);
1133 }
add_normalized_typeTexture2DDescriptorBuilder1134 void add_normalized_type(tflite::gpu::data::DataType normalized_type) {
1135 fbb_.AddElement<int8_t>(Texture2DDescriptor::VT_NORMALIZED_TYPE, static_cast<int8_t>(normalized_type), 0);
1136 }
add_sizeTexture2DDescriptorBuilder1137 void add_size(flatbuffers::Offset<tflite::gpu::data::Int2> size) {
1138 fbb_.AddOffset(Texture2DDescriptor::VT_SIZE, size);
1139 }
add_dataTexture2DDescriptorBuilder1140 void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
1141 fbb_.AddOffset(Texture2DDescriptor::VT_DATA, data);
1142 }
Texture2DDescriptorBuilderTexture2DDescriptorBuilder1143 explicit Texture2DDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1144 : fbb_(_fbb) {
1145 start_ = fbb_.StartTable();
1146 }
FinishTexture2DDescriptorBuilder1147 flatbuffers::Offset<Texture2DDescriptor> Finish() {
1148 const auto end = fbb_.EndTable(start_);
1149 auto o = flatbuffers::Offset<Texture2DDescriptor>(end);
1150 return o;
1151 }
1152 };
1153
1154 inline flatbuffers::Offset<Texture2DDescriptor> CreateTexture2DDescriptor(
1155 flatbuffers::FlatBufferBuilder &_fbb,
1156 flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1157 tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1158 bool normalized = false,
1159 tflite::gpu::data::DataType normalized_type = tflite::gpu::data::DataType::UNKNOWN,
1160 flatbuffers::Offset<tflite::gpu::data::Int2> size = 0,
1161 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
1162 Texture2DDescriptorBuilder builder_(_fbb);
1163 builder_.add_data(data);
1164 builder_.add_size(size);
1165 builder_.add_base_obj(base_obj);
1166 builder_.add_normalized_type(normalized_type);
1167 builder_.add_normalized(normalized);
1168 builder_.add_element_type(element_type);
1169 return builder_.Finish();
1170 }
1171
1172 inline flatbuffers::Offset<Texture2DDescriptor> CreateTexture2DDescriptorDirect(
1173 flatbuffers::FlatBufferBuilder &_fbb,
1174 flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1175 tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1176 bool normalized = false,
1177 tflite::gpu::data::DataType normalized_type = tflite::gpu::data::DataType::UNKNOWN,
1178 flatbuffers::Offset<tflite::gpu::data::Int2> size = 0,
1179 const std::vector<uint8_t> *data = nullptr) {
1180 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
1181 return tflite::gpu::data::CreateTexture2DDescriptor(
1182 _fbb,
1183 base_obj,
1184 element_type,
1185 normalized,
1186 normalized_type,
1187 size,
1188 data__);
1189 }
1190
1191 struct TensorLinearDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1192 typedef TensorLinearDescriptorBuilder Builder;
1193 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1194 VT_BASE_OBJ = 4,
1195 VT_STORAGE_TYPE = 6,
1196 VT_ELEMENT_TYPE = 8,
1197 VT_MEMORY_TYPE = 10,
1198 VT_SIZE = 12,
1199 VT_DATA = 14
1200 };
base_objFLATBUFFERS_FINAL_CLASS1201 const tflite::gpu::data::GPUObjectDescriptor *base_obj() const {
1202 return GetPointer<const tflite::gpu::data::GPUObjectDescriptor *>(VT_BASE_OBJ);
1203 }
storage_typeFLATBUFFERS_FINAL_CLASS1204 tflite::gpu::data::LinearStorageType storage_type() const {
1205 return static_cast<tflite::gpu::data::LinearStorageType>(GetField<int8_t>(VT_STORAGE_TYPE, 0));
1206 }
element_typeFLATBUFFERS_FINAL_CLASS1207 tflite::gpu::data::DataType element_type() const {
1208 return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_ELEMENT_TYPE, 0));
1209 }
memory_typeFLATBUFFERS_FINAL_CLASS1210 tflite::gpu::data::MemoryType memory_type() const {
1211 return static_cast<tflite::gpu::data::MemoryType>(GetField<int8_t>(VT_MEMORY_TYPE, 0));
1212 }
sizeFLATBUFFERS_FINAL_CLASS1213 int32_t size() const {
1214 return GetField<int32_t>(VT_SIZE, 0);
1215 }
dataFLATBUFFERS_FINAL_CLASS1216 const flatbuffers::Vector<uint8_t> *data() const {
1217 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
1218 }
VerifyFLATBUFFERS_FINAL_CLASS1219 bool Verify(flatbuffers::Verifier &verifier) const {
1220 return VerifyTableStart(verifier) &&
1221 VerifyOffset(verifier, VT_BASE_OBJ) &&
1222 verifier.VerifyTable(base_obj()) &&
1223 VerifyField<int8_t>(verifier, VT_STORAGE_TYPE) &&
1224 VerifyField<int8_t>(verifier, VT_ELEMENT_TYPE) &&
1225 VerifyField<int8_t>(verifier, VT_MEMORY_TYPE) &&
1226 VerifyField<int32_t>(verifier, VT_SIZE) &&
1227 VerifyOffset(verifier, VT_DATA) &&
1228 verifier.VerifyVector(data()) &&
1229 verifier.EndTable();
1230 }
1231 };
1232
1233 struct TensorLinearDescriptorBuilder {
1234 typedef TensorLinearDescriptor Table;
1235 flatbuffers::FlatBufferBuilder &fbb_;
1236 flatbuffers::uoffset_t start_;
add_base_objTensorLinearDescriptorBuilder1237 void add_base_obj(flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj) {
1238 fbb_.AddOffset(TensorLinearDescriptor::VT_BASE_OBJ, base_obj);
1239 }
add_storage_typeTensorLinearDescriptorBuilder1240 void add_storage_type(tflite::gpu::data::LinearStorageType storage_type) {
1241 fbb_.AddElement<int8_t>(TensorLinearDescriptor::VT_STORAGE_TYPE, static_cast<int8_t>(storage_type), 0);
1242 }
add_element_typeTensorLinearDescriptorBuilder1243 void add_element_type(tflite::gpu::data::DataType element_type) {
1244 fbb_.AddElement<int8_t>(TensorLinearDescriptor::VT_ELEMENT_TYPE, static_cast<int8_t>(element_type), 0);
1245 }
add_memory_typeTensorLinearDescriptorBuilder1246 void add_memory_type(tflite::gpu::data::MemoryType memory_type) {
1247 fbb_.AddElement<int8_t>(TensorLinearDescriptor::VT_MEMORY_TYPE, static_cast<int8_t>(memory_type), 0);
1248 }
add_sizeTensorLinearDescriptorBuilder1249 void add_size(int32_t size) {
1250 fbb_.AddElement<int32_t>(TensorLinearDescriptor::VT_SIZE, size, 0);
1251 }
add_dataTensorLinearDescriptorBuilder1252 void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
1253 fbb_.AddOffset(TensorLinearDescriptor::VT_DATA, data);
1254 }
TensorLinearDescriptorBuilderTensorLinearDescriptorBuilder1255 explicit TensorLinearDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1256 : fbb_(_fbb) {
1257 start_ = fbb_.StartTable();
1258 }
FinishTensorLinearDescriptorBuilder1259 flatbuffers::Offset<TensorLinearDescriptor> Finish() {
1260 const auto end = fbb_.EndTable(start_);
1261 auto o = flatbuffers::Offset<TensorLinearDescriptor>(end);
1262 return o;
1263 }
1264 };
1265
1266 inline flatbuffers::Offset<TensorLinearDescriptor> CreateTensorLinearDescriptor(
1267 flatbuffers::FlatBufferBuilder &_fbb,
1268 flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1269 tflite::gpu::data::LinearStorageType storage_type = tflite::gpu::data::LinearStorageType::BUFFER,
1270 tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1271 tflite::gpu::data::MemoryType memory_type = tflite::gpu::data::MemoryType::GLOBAL,
1272 int32_t size = 0,
1273 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
1274 TensorLinearDescriptorBuilder builder_(_fbb);
1275 builder_.add_data(data);
1276 builder_.add_size(size);
1277 builder_.add_base_obj(base_obj);
1278 builder_.add_memory_type(memory_type);
1279 builder_.add_element_type(element_type);
1280 builder_.add_storage_type(storage_type);
1281 return builder_.Finish();
1282 }
1283
1284 inline flatbuffers::Offset<TensorLinearDescriptor> CreateTensorLinearDescriptorDirect(
1285 flatbuffers::FlatBufferBuilder &_fbb,
1286 flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1287 tflite::gpu::data::LinearStorageType storage_type = tflite::gpu::data::LinearStorageType::BUFFER,
1288 tflite::gpu::data::DataType element_type = tflite::gpu::data::DataType::UNKNOWN,
1289 tflite::gpu::data::MemoryType memory_type = tflite::gpu::data::MemoryType::GLOBAL,
1290 int32_t size = 0,
1291 const std::vector<uint8_t> *data = nullptr) {
1292 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
1293 return tflite::gpu::data::CreateTensorLinearDescriptor(
1294 _fbb,
1295 base_obj,
1296 storage_type,
1297 element_type,
1298 memory_type,
1299 size,
1300 data__);
1301 }
1302
1303 struct BHWDC FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1304 typedef BHWDCBuilder Builder;
1305 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1306 VT_B = 4,
1307 VT_H = 6,
1308 VT_W = 8,
1309 VT_D = 10,
1310 VT_C = 12
1311 };
bFLATBUFFERS_FINAL_CLASS1312 int32_t b() const {
1313 return GetField<int32_t>(VT_B, 0);
1314 }
hFLATBUFFERS_FINAL_CLASS1315 int32_t h() const {
1316 return GetField<int32_t>(VT_H, 0);
1317 }
wFLATBUFFERS_FINAL_CLASS1318 int32_t w() const {
1319 return GetField<int32_t>(VT_W, 0);
1320 }
dFLATBUFFERS_FINAL_CLASS1321 int32_t d() const {
1322 return GetField<int32_t>(VT_D, 0);
1323 }
cFLATBUFFERS_FINAL_CLASS1324 int32_t c() const {
1325 return GetField<int32_t>(VT_C, 0);
1326 }
VerifyFLATBUFFERS_FINAL_CLASS1327 bool Verify(flatbuffers::Verifier &verifier) const {
1328 return VerifyTableStart(verifier) &&
1329 VerifyField<int32_t>(verifier, VT_B) &&
1330 VerifyField<int32_t>(verifier, VT_H) &&
1331 VerifyField<int32_t>(verifier, VT_W) &&
1332 VerifyField<int32_t>(verifier, VT_D) &&
1333 VerifyField<int32_t>(verifier, VT_C) &&
1334 verifier.EndTable();
1335 }
1336 };
1337
1338 struct BHWDCBuilder {
1339 typedef BHWDC Table;
1340 flatbuffers::FlatBufferBuilder &fbb_;
1341 flatbuffers::uoffset_t start_;
add_bBHWDCBuilder1342 void add_b(int32_t b) {
1343 fbb_.AddElement<int32_t>(BHWDC::VT_B, b, 0);
1344 }
add_hBHWDCBuilder1345 void add_h(int32_t h) {
1346 fbb_.AddElement<int32_t>(BHWDC::VT_H, h, 0);
1347 }
add_wBHWDCBuilder1348 void add_w(int32_t w) {
1349 fbb_.AddElement<int32_t>(BHWDC::VT_W, w, 0);
1350 }
add_dBHWDCBuilder1351 void add_d(int32_t d) {
1352 fbb_.AddElement<int32_t>(BHWDC::VT_D, d, 0);
1353 }
add_cBHWDCBuilder1354 void add_c(int32_t c) {
1355 fbb_.AddElement<int32_t>(BHWDC::VT_C, c, 0);
1356 }
BHWDCBuilderBHWDCBuilder1357 explicit BHWDCBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1358 : fbb_(_fbb) {
1359 start_ = fbb_.StartTable();
1360 }
FinishBHWDCBuilder1361 flatbuffers::Offset<BHWDC> Finish() {
1362 const auto end = fbb_.EndTable(start_);
1363 auto o = flatbuffers::Offset<BHWDC>(end);
1364 return o;
1365 }
1366 };
1367
1368 inline flatbuffers::Offset<BHWDC> CreateBHWDC(
1369 flatbuffers::FlatBufferBuilder &_fbb,
1370 int32_t b = 0,
1371 int32_t h = 0,
1372 int32_t w = 0,
1373 int32_t d = 0,
1374 int32_t c = 0) {
1375 BHWDCBuilder builder_(_fbb);
1376 builder_.add_c(c);
1377 builder_.add_d(d);
1378 builder_.add_w(w);
1379 builder_.add_h(h);
1380 builder_.add_b(b);
1381 return builder_.Finish();
1382 }
1383
1384 struct TensorDescriptor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1385 typedef TensorDescriptorBuilder Builder;
1386 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1387 VT_BASE_OBJ = 4,
1388 VT_DATA_TYPE = 6,
1389 VT_STORAGE_TYPE = 8,
1390 VT_LAYOUT = 10,
1391 VT_SHAPE = 12,
1392 VT_DATA = 14
1393 };
base_objFLATBUFFERS_FINAL_CLASS1394 const tflite::gpu::data::GPUObjectDescriptor *base_obj() const {
1395 return GetPointer<const tflite::gpu::data::GPUObjectDescriptor *>(VT_BASE_OBJ);
1396 }
data_typeFLATBUFFERS_FINAL_CLASS1397 tflite::gpu::data::DataType data_type() const {
1398 return static_cast<tflite::gpu::data::DataType>(GetField<int8_t>(VT_DATA_TYPE, 0));
1399 }
storage_typeFLATBUFFERS_FINAL_CLASS1400 tflite::gpu::data::TensorStorageType storage_type() const {
1401 return static_cast<tflite::gpu::data::TensorStorageType>(GetField<int8_t>(VT_STORAGE_TYPE, 0));
1402 }
layoutFLATBUFFERS_FINAL_CLASS1403 tflite::gpu::data::Layout layout() const {
1404 return static_cast<tflite::gpu::data::Layout>(GetField<int8_t>(VT_LAYOUT, 0));
1405 }
shapeFLATBUFFERS_FINAL_CLASS1406 const tflite::gpu::data::BHWDC *shape() const {
1407 return GetPointer<const tflite::gpu::data::BHWDC *>(VT_SHAPE);
1408 }
dataFLATBUFFERS_FINAL_CLASS1409 const flatbuffers::Vector<uint8_t> *data() const {
1410 return GetPointer<const flatbuffers::Vector<uint8_t> *>(VT_DATA);
1411 }
VerifyFLATBUFFERS_FINAL_CLASS1412 bool Verify(flatbuffers::Verifier &verifier) const {
1413 return VerifyTableStart(verifier) &&
1414 VerifyOffset(verifier, VT_BASE_OBJ) &&
1415 verifier.VerifyTable(base_obj()) &&
1416 VerifyField<int8_t>(verifier, VT_DATA_TYPE) &&
1417 VerifyField<int8_t>(verifier, VT_STORAGE_TYPE) &&
1418 VerifyField<int8_t>(verifier, VT_LAYOUT) &&
1419 VerifyOffset(verifier, VT_SHAPE) &&
1420 verifier.VerifyTable(shape()) &&
1421 VerifyOffset(verifier, VT_DATA) &&
1422 verifier.VerifyVector(data()) &&
1423 verifier.EndTable();
1424 }
1425 };
1426
1427 struct TensorDescriptorBuilder {
1428 typedef TensorDescriptor Table;
1429 flatbuffers::FlatBufferBuilder &fbb_;
1430 flatbuffers::uoffset_t start_;
add_base_objTensorDescriptorBuilder1431 void add_base_obj(flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj) {
1432 fbb_.AddOffset(TensorDescriptor::VT_BASE_OBJ, base_obj);
1433 }
add_data_typeTensorDescriptorBuilder1434 void add_data_type(tflite::gpu::data::DataType data_type) {
1435 fbb_.AddElement<int8_t>(TensorDescriptor::VT_DATA_TYPE, static_cast<int8_t>(data_type), 0);
1436 }
add_storage_typeTensorDescriptorBuilder1437 void add_storage_type(tflite::gpu::data::TensorStorageType storage_type) {
1438 fbb_.AddElement<int8_t>(TensorDescriptor::VT_STORAGE_TYPE, static_cast<int8_t>(storage_type), 0);
1439 }
add_layoutTensorDescriptorBuilder1440 void add_layout(tflite::gpu::data::Layout layout) {
1441 fbb_.AddElement<int8_t>(TensorDescriptor::VT_LAYOUT, static_cast<int8_t>(layout), 0);
1442 }
add_shapeTensorDescriptorBuilder1443 void add_shape(flatbuffers::Offset<tflite::gpu::data::BHWDC> shape) {
1444 fbb_.AddOffset(TensorDescriptor::VT_SHAPE, shape);
1445 }
add_dataTensorDescriptorBuilder1446 void add_data(flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data) {
1447 fbb_.AddOffset(TensorDescriptor::VT_DATA, data);
1448 }
TensorDescriptorBuilderTensorDescriptorBuilder1449 explicit TensorDescriptorBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1450 : fbb_(_fbb) {
1451 start_ = fbb_.StartTable();
1452 }
FinishTensorDescriptorBuilder1453 flatbuffers::Offset<TensorDescriptor> Finish() {
1454 const auto end = fbb_.EndTable(start_);
1455 auto o = flatbuffers::Offset<TensorDescriptor>(end);
1456 return o;
1457 }
1458 };
1459
1460 inline flatbuffers::Offset<TensorDescriptor> CreateTensorDescriptor(
1461 flatbuffers::FlatBufferBuilder &_fbb,
1462 flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1463 tflite::gpu::data::DataType data_type = tflite::gpu::data::DataType::UNKNOWN,
1464 tflite::gpu::data::TensorStorageType storage_type = tflite::gpu::data::TensorStorageType::UNKNOWN,
1465 tflite::gpu::data::Layout layout = tflite::gpu::data::Layout::UNKNOWN,
1466 flatbuffers::Offset<tflite::gpu::data::BHWDC> shape = 0,
1467 flatbuffers::Offset<flatbuffers::Vector<uint8_t>> data = 0) {
1468 TensorDescriptorBuilder builder_(_fbb);
1469 builder_.add_data(data);
1470 builder_.add_shape(shape);
1471 builder_.add_base_obj(base_obj);
1472 builder_.add_layout(layout);
1473 builder_.add_storage_type(storage_type);
1474 builder_.add_data_type(data_type);
1475 return builder_.Finish();
1476 }
1477
1478 inline flatbuffers::Offset<TensorDescriptor> CreateTensorDescriptorDirect(
1479 flatbuffers::FlatBufferBuilder &_fbb,
1480 flatbuffers::Offset<tflite::gpu::data::GPUObjectDescriptor> base_obj = 0,
1481 tflite::gpu::data::DataType data_type = tflite::gpu::data::DataType::UNKNOWN,
1482 tflite::gpu::data::TensorStorageType storage_type = tflite::gpu::data::TensorStorageType::UNKNOWN,
1483 tflite::gpu::data::Layout layout = tflite::gpu::data::Layout::UNKNOWN,
1484 flatbuffers::Offset<tflite::gpu::data::BHWDC> shape = 0,
1485 const std::vector<uint8_t> *data = nullptr) {
1486 auto data__ = data ? _fbb.CreateVector<uint8_t>(*data) : 0;
1487 return tflite::gpu::data::CreateTensorDescriptor(
1488 _fbb,
1489 base_obj,
1490 data_type,
1491 storage_type,
1492 layout,
1493 shape,
1494 data__);
1495 }
1496
1497 struct BufferDescriptorMapValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1498 typedef BufferDescriptorMapValueBuilder Builder;
1499 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1500 VT_KEY = 4,
1501 VT_VALUE = 6
1502 };
keyFLATBUFFERS_FINAL_CLASS1503 const flatbuffers::String *key() const {
1504 return GetPointer<const flatbuffers::String *>(VT_KEY);
1505 }
valueFLATBUFFERS_FINAL_CLASS1506 const tflite::gpu::data::BufferDescriptor *value() const {
1507 return GetPointer<const tflite::gpu::data::BufferDescriptor *>(VT_VALUE);
1508 }
VerifyFLATBUFFERS_FINAL_CLASS1509 bool Verify(flatbuffers::Verifier &verifier) const {
1510 return VerifyTableStart(verifier) &&
1511 VerifyOffset(verifier, VT_KEY) &&
1512 verifier.VerifyString(key()) &&
1513 VerifyOffset(verifier, VT_VALUE) &&
1514 verifier.VerifyTable(value()) &&
1515 verifier.EndTable();
1516 }
1517 };
1518
1519 struct BufferDescriptorMapValueBuilder {
1520 typedef BufferDescriptorMapValue Table;
1521 flatbuffers::FlatBufferBuilder &fbb_;
1522 flatbuffers::uoffset_t start_;
add_keyBufferDescriptorMapValueBuilder1523 void add_key(flatbuffers::Offset<flatbuffers::String> key) {
1524 fbb_.AddOffset(BufferDescriptorMapValue::VT_KEY, key);
1525 }
add_valueBufferDescriptorMapValueBuilder1526 void add_value(flatbuffers::Offset<tflite::gpu::data::BufferDescriptor> value) {
1527 fbb_.AddOffset(BufferDescriptorMapValue::VT_VALUE, value);
1528 }
BufferDescriptorMapValueBuilderBufferDescriptorMapValueBuilder1529 explicit BufferDescriptorMapValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1530 : fbb_(_fbb) {
1531 start_ = fbb_.StartTable();
1532 }
FinishBufferDescriptorMapValueBuilder1533 flatbuffers::Offset<BufferDescriptorMapValue> Finish() {
1534 const auto end = fbb_.EndTable(start_);
1535 auto o = flatbuffers::Offset<BufferDescriptorMapValue>(end);
1536 return o;
1537 }
1538 };
1539
1540 inline flatbuffers::Offset<BufferDescriptorMapValue> CreateBufferDescriptorMapValue(
1541 flatbuffers::FlatBufferBuilder &_fbb,
1542 flatbuffers::Offset<flatbuffers::String> key = 0,
1543 flatbuffers::Offset<tflite::gpu::data::BufferDescriptor> value = 0) {
1544 BufferDescriptorMapValueBuilder builder_(_fbb);
1545 builder_.add_value(value);
1546 builder_.add_key(key);
1547 return builder_.Finish();
1548 }
1549
1550 inline flatbuffers::Offset<BufferDescriptorMapValue> CreateBufferDescriptorMapValueDirect(
1551 flatbuffers::FlatBufferBuilder &_fbb,
1552 const char *key = nullptr,
1553 flatbuffers::Offset<tflite::gpu::data::BufferDescriptor> value = 0) {
1554 auto key__ = key ? _fbb.CreateString(key) : 0;
1555 return tflite::gpu::data::CreateBufferDescriptorMapValue(
1556 _fbb,
1557 key__,
1558 value);
1559 }
1560
1561 struct Texture2DDescriptorMapValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1562 typedef Texture2DDescriptorMapValueBuilder Builder;
1563 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1564 VT_KEY = 4,
1565 VT_VALUE = 6
1566 };
keyFLATBUFFERS_FINAL_CLASS1567 const flatbuffers::String *key() const {
1568 return GetPointer<const flatbuffers::String *>(VT_KEY);
1569 }
valueFLATBUFFERS_FINAL_CLASS1570 const tflite::gpu::data::Texture2DDescriptor *value() const {
1571 return GetPointer<const tflite::gpu::data::Texture2DDescriptor *>(VT_VALUE);
1572 }
VerifyFLATBUFFERS_FINAL_CLASS1573 bool Verify(flatbuffers::Verifier &verifier) const {
1574 return VerifyTableStart(verifier) &&
1575 VerifyOffset(verifier, VT_KEY) &&
1576 verifier.VerifyString(key()) &&
1577 VerifyOffset(verifier, VT_VALUE) &&
1578 verifier.VerifyTable(value()) &&
1579 verifier.EndTable();
1580 }
1581 };
1582
1583 struct Texture2DDescriptorMapValueBuilder {
1584 typedef Texture2DDescriptorMapValue Table;
1585 flatbuffers::FlatBufferBuilder &fbb_;
1586 flatbuffers::uoffset_t start_;
add_keyTexture2DDescriptorMapValueBuilder1587 void add_key(flatbuffers::Offset<flatbuffers::String> key) {
1588 fbb_.AddOffset(Texture2DDescriptorMapValue::VT_KEY, key);
1589 }
add_valueTexture2DDescriptorMapValueBuilder1590 void add_value(flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptor> value) {
1591 fbb_.AddOffset(Texture2DDescriptorMapValue::VT_VALUE, value);
1592 }
Texture2DDescriptorMapValueBuilderTexture2DDescriptorMapValueBuilder1593 explicit Texture2DDescriptorMapValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1594 : fbb_(_fbb) {
1595 start_ = fbb_.StartTable();
1596 }
FinishTexture2DDescriptorMapValueBuilder1597 flatbuffers::Offset<Texture2DDescriptorMapValue> Finish() {
1598 const auto end = fbb_.EndTable(start_);
1599 auto o = flatbuffers::Offset<Texture2DDescriptorMapValue>(end);
1600 return o;
1601 }
1602 };
1603
1604 inline flatbuffers::Offset<Texture2DDescriptorMapValue> CreateTexture2DDescriptorMapValue(
1605 flatbuffers::FlatBufferBuilder &_fbb,
1606 flatbuffers::Offset<flatbuffers::String> key = 0,
1607 flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptor> value = 0) {
1608 Texture2DDescriptorMapValueBuilder builder_(_fbb);
1609 builder_.add_value(value);
1610 builder_.add_key(key);
1611 return builder_.Finish();
1612 }
1613
1614 inline flatbuffers::Offset<Texture2DDescriptorMapValue> CreateTexture2DDescriptorMapValueDirect(
1615 flatbuffers::FlatBufferBuilder &_fbb,
1616 const char *key = nullptr,
1617 flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptor> value = 0) {
1618 auto key__ = key ? _fbb.CreateString(key) : 0;
1619 return tflite::gpu::data::CreateTexture2DDescriptorMapValue(
1620 _fbb,
1621 key__,
1622 value);
1623 }
1624
1625 struct TensorLinearDescriptorMapValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1626 typedef TensorLinearDescriptorMapValueBuilder Builder;
1627 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1628 VT_KEY = 4,
1629 VT_VALUE = 6
1630 };
keyFLATBUFFERS_FINAL_CLASS1631 const flatbuffers::String *key() const {
1632 return GetPointer<const flatbuffers::String *>(VT_KEY);
1633 }
valueFLATBUFFERS_FINAL_CLASS1634 const tflite::gpu::data::TensorLinearDescriptor *value() const {
1635 return GetPointer<const tflite::gpu::data::TensorLinearDescriptor *>(VT_VALUE);
1636 }
VerifyFLATBUFFERS_FINAL_CLASS1637 bool Verify(flatbuffers::Verifier &verifier) const {
1638 return VerifyTableStart(verifier) &&
1639 VerifyOffset(verifier, VT_KEY) &&
1640 verifier.VerifyString(key()) &&
1641 VerifyOffset(verifier, VT_VALUE) &&
1642 verifier.VerifyTable(value()) &&
1643 verifier.EndTable();
1644 }
1645 };
1646
1647 struct TensorLinearDescriptorMapValueBuilder {
1648 typedef TensorLinearDescriptorMapValue Table;
1649 flatbuffers::FlatBufferBuilder &fbb_;
1650 flatbuffers::uoffset_t start_;
add_keyTensorLinearDescriptorMapValueBuilder1651 void add_key(flatbuffers::Offset<flatbuffers::String> key) {
1652 fbb_.AddOffset(TensorLinearDescriptorMapValue::VT_KEY, key);
1653 }
add_valueTensorLinearDescriptorMapValueBuilder1654 void add_value(flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptor> value) {
1655 fbb_.AddOffset(TensorLinearDescriptorMapValue::VT_VALUE, value);
1656 }
TensorLinearDescriptorMapValueBuilderTensorLinearDescriptorMapValueBuilder1657 explicit TensorLinearDescriptorMapValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1658 : fbb_(_fbb) {
1659 start_ = fbb_.StartTable();
1660 }
FinishTensorLinearDescriptorMapValueBuilder1661 flatbuffers::Offset<TensorLinearDescriptorMapValue> Finish() {
1662 const auto end = fbb_.EndTable(start_);
1663 auto o = flatbuffers::Offset<TensorLinearDescriptorMapValue>(end);
1664 return o;
1665 }
1666 };
1667
1668 inline flatbuffers::Offset<TensorLinearDescriptorMapValue> CreateTensorLinearDescriptorMapValue(
1669 flatbuffers::FlatBufferBuilder &_fbb,
1670 flatbuffers::Offset<flatbuffers::String> key = 0,
1671 flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptor> value = 0) {
1672 TensorLinearDescriptorMapValueBuilder builder_(_fbb);
1673 builder_.add_value(value);
1674 builder_.add_key(key);
1675 return builder_.Finish();
1676 }
1677
1678 inline flatbuffers::Offset<TensorLinearDescriptorMapValue> CreateTensorLinearDescriptorMapValueDirect(
1679 flatbuffers::FlatBufferBuilder &_fbb,
1680 const char *key = nullptr,
1681 flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptor> value = 0) {
1682 auto key__ = key ? _fbb.CreateString(key) : 0;
1683 return tflite::gpu::data::CreateTensorLinearDescriptorMapValue(
1684 _fbb,
1685 key__,
1686 value);
1687 }
1688
1689 struct TensorDescriptorMapValue FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1690 typedef TensorDescriptorMapValueBuilder Builder;
1691 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1692 VT_KEY = 4,
1693 VT_VALUE = 6
1694 };
keyFLATBUFFERS_FINAL_CLASS1695 const flatbuffers::String *key() const {
1696 return GetPointer<const flatbuffers::String *>(VT_KEY);
1697 }
valueFLATBUFFERS_FINAL_CLASS1698 const tflite::gpu::data::TensorDescriptor *value() const {
1699 return GetPointer<const tflite::gpu::data::TensorDescriptor *>(VT_VALUE);
1700 }
VerifyFLATBUFFERS_FINAL_CLASS1701 bool Verify(flatbuffers::Verifier &verifier) const {
1702 return VerifyTableStart(verifier) &&
1703 VerifyOffset(verifier, VT_KEY) &&
1704 verifier.VerifyString(key()) &&
1705 VerifyOffset(verifier, VT_VALUE) &&
1706 verifier.VerifyTable(value()) &&
1707 verifier.EndTable();
1708 }
1709 };
1710
1711 struct TensorDescriptorMapValueBuilder {
1712 typedef TensorDescriptorMapValue Table;
1713 flatbuffers::FlatBufferBuilder &fbb_;
1714 flatbuffers::uoffset_t start_;
add_keyTensorDescriptorMapValueBuilder1715 void add_key(flatbuffers::Offset<flatbuffers::String> key) {
1716 fbb_.AddOffset(TensorDescriptorMapValue::VT_KEY, key);
1717 }
add_valueTensorDescriptorMapValueBuilder1718 void add_value(flatbuffers::Offset<tflite::gpu::data::TensorDescriptor> value) {
1719 fbb_.AddOffset(TensorDescriptorMapValue::VT_VALUE, value);
1720 }
TensorDescriptorMapValueBuilderTensorDescriptorMapValueBuilder1721 explicit TensorDescriptorMapValueBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1722 : fbb_(_fbb) {
1723 start_ = fbb_.StartTable();
1724 }
FinishTensorDescriptorMapValueBuilder1725 flatbuffers::Offset<TensorDescriptorMapValue> Finish() {
1726 const auto end = fbb_.EndTable(start_);
1727 auto o = flatbuffers::Offset<TensorDescriptorMapValue>(end);
1728 return o;
1729 }
1730 };
1731
1732 inline flatbuffers::Offset<TensorDescriptorMapValue> CreateTensorDescriptorMapValue(
1733 flatbuffers::FlatBufferBuilder &_fbb,
1734 flatbuffers::Offset<flatbuffers::String> key = 0,
1735 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor> value = 0) {
1736 TensorDescriptorMapValueBuilder builder_(_fbb);
1737 builder_.add_value(value);
1738 builder_.add_key(key);
1739 return builder_.Finish();
1740 }
1741
1742 inline flatbuffers::Offset<TensorDescriptorMapValue> CreateTensorDescriptorMapValueDirect(
1743 flatbuffers::FlatBufferBuilder &_fbb,
1744 const char *key = nullptr,
1745 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor> value = 0) {
1746 auto key__ = key ? _fbb.CreateString(key) : 0;
1747 return tflite::gpu::data::CreateTensorDescriptorMapValue(
1748 _fbb,
1749 key__,
1750 value);
1751 }
1752
1753 struct Arguments FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1754 typedef ArgumentsBuilder Builder;
1755 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1756 VT_INT_VALUES = 4,
1757 VT_FLOAT_VALUES = 6,
1758 VT_HALF_VALUES = 8,
1759 VT_BUFFER_REFS = 10,
1760 VT_TEXTURE2D_REFS = 12,
1761 VT_TENSOR_LINEAR_REFS = 14,
1762 VT_TENSOR_REFS = 16,
1763 VT_BUFFER_OBJECTS = 18,
1764 VT_TEXTURE2D_OBJECTS = 20,
1765 VT_TENSOR_LINEAR_OBJECTS = 22,
1766 VT_TENSOR_OBJECTS = 24
1767 };
int_valuesFLATBUFFERS_FINAL_CLASS1768 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::IntValue>> *int_values() const {
1769 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::IntValue>> *>(VT_INT_VALUES);
1770 }
float_valuesFLATBUFFERS_FINAL_CLASS1771 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>> *float_values() const {
1772 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>> *>(VT_FLOAT_VALUES);
1773 }
half_valuesFLATBUFFERS_FINAL_CLASS1774 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>> *half_values() const {
1775 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>> *>(VT_HALF_VALUES);
1776 }
buffer_refsFLATBUFFERS_FINAL_CLASS1777 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *buffer_refs() const {
1778 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *>(VT_BUFFER_REFS);
1779 }
texture2d_refsFLATBUFFERS_FINAL_CLASS1780 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *texture2d_refs() const {
1781 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *>(VT_TEXTURE2D_REFS);
1782 }
tensor_linear_refsFLATBUFFERS_FINAL_CLASS1783 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *tensor_linear_refs() const {
1784 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *>(VT_TENSOR_LINEAR_REFS);
1785 }
tensor_refsFLATBUFFERS_FINAL_CLASS1786 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *tensor_refs() const {
1787 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *>(VT_TENSOR_REFS);
1788 }
buffer_objectsFLATBUFFERS_FINAL_CLASS1789 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *buffer_objects() const {
1790 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *>(VT_BUFFER_OBJECTS);
1791 }
texture2d_objectsFLATBUFFERS_FINAL_CLASS1792 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *texture2d_objects() const {
1793 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *>(VT_TEXTURE2D_OBJECTS);
1794 }
tensor_linear_objectsFLATBUFFERS_FINAL_CLASS1795 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *tensor_linear_objects() const {
1796 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *>(VT_TENSOR_LINEAR_OBJECTS);
1797 }
tensor_objectsFLATBUFFERS_FINAL_CLASS1798 const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *tensor_objects() const {
1799 return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *>(VT_TENSOR_OBJECTS);
1800 }
VerifyFLATBUFFERS_FINAL_CLASS1801 bool Verify(flatbuffers::Verifier &verifier) const {
1802 return VerifyTableStart(verifier) &&
1803 VerifyOffset(verifier, VT_INT_VALUES) &&
1804 verifier.VerifyVector(int_values()) &&
1805 verifier.VerifyVectorOfTables(int_values()) &&
1806 VerifyOffset(verifier, VT_FLOAT_VALUES) &&
1807 verifier.VerifyVector(float_values()) &&
1808 verifier.VerifyVectorOfTables(float_values()) &&
1809 VerifyOffset(verifier, VT_HALF_VALUES) &&
1810 verifier.VerifyVector(half_values()) &&
1811 verifier.VerifyVectorOfTables(half_values()) &&
1812 VerifyOffset(verifier, VT_BUFFER_REFS) &&
1813 verifier.VerifyVector(buffer_refs()) &&
1814 verifier.VerifyVectorOfTables(buffer_refs()) &&
1815 VerifyOffset(verifier, VT_TEXTURE2D_REFS) &&
1816 verifier.VerifyVector(texture2d_refs()) &&
1817 verifier.VerifyVectorOfTables(texture2d_refs()) &&
1818 VerifyOffset(verifier, VT_TENSOR_LINEAR_REFS) &&
1819 verifier.VerifyVector(tensor_linear_refs()) &&
1820 verifier.VerifyVectorOfTables(tensor_linear_refs()) &&
1821 VerifyOffset(verifier, VT_TENSOR_REFS) &&
1822 verifier.VerifyVector(tensor_refs()) &&
1823 verifier.VerifyVectorOfTables(tensor_refs()) &&
1824 VerifyOffset(verifier, VT_BUFFER_OBJECTS) &&
1825 verifier.VerifyVector(buffer_objects()) &&
1826 verifier.VerifyVectorOfTables(buffer_objects()) &&
1827 VerifyOffset(verifier, VT_TEXTURE2D_OBJECTS) &&
1828 verifier.VerifyVector(texture2d_objects()) &&
1829 verifier.VerifyVectorOfTables(texture2d_objects()) &&
1830 VerifyOffset(verifier, VT_TENSOR_LINEAR_OBJECTS) &&
1831 verifier.VerifyVector(tensor_linear_objects()) &&
1832 verifier.VerifyVectorOfTables(tensor_linear_objects()) &&
1833 VerifyOffset(verifier, VT_TENSOR_OBJECTS) &&
1834 verifier.VerifyVector(tensor_objects()) &&
1835 verifier.VerifyVectorOfTables(tensor_objects()) &&
1836 verifier.EndTable();
1837 }
1838 };
1839
1840 struct ArgumentsBuilder {
1841 typedef Arguments Table;
1842 flatbuffers::FlatBufferBuilder &fbb_;
1843 flatbuffers::uoffset_t start_;
add_int_valuesArgumentsBuilder1844 void add_int_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::IntValue>>> int_values) {
1845 fbb_.AddOffset(Arguments::VT_INT_VALUES, int_values);
1846 }
add_float_valuesArgumentsBuilder1847 void add_float_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>>> float_values) {
1848 fbb_.AddOffset(Arguments::VT_FLOAT_VALUES, float_values);
1849 }
add_half_valuesArgumentsBuilder1850 void add_half_values(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>>> half_values) {
1851 fbb_.AddOffset(Arguments::VT_HALF_VALUES, half_values);
1852 }
add_buffer_refsArgumentsBuilder1853 void add_buffer_refs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>> buffer_refs) {
1854 fbb_.AddOffset(Arguments::VT_BUFFER_REFS, buffer_refs);
1855 }
add_texture2d_refsArgumentsBuilder1856 void add_texture2d_refs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>> texture2d_refs) {
1857 fbb_.AddOffset(Arguments::VT_TEXTURE2D_REFS, texture2d_refs);
1858 }
add_tensor_linear_refsArgumentsBuilder1859 void add_tensor_linear_refs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>> tensor_linear_refs) {
1860 fbb_.AddOffset(Arguments::VT_TENSOR_LINEAR_REFS, tensor_linear_refs);
1861 }
add_tensor_refsArgumentsBuilder1862 void add_tensor_refs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>> tensor_refs) {
1863 fbb_.AddOffset(Arguments::VT_TENSOR_REFS, tensor_refs);
1864 }
add_buffer_objectsArgumentsBuilder1865 void add_buffer_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>> buffer_objects) {
1866 fbb_.AddOffset(Arguments::VT_BUFFER_OBJECTS, buffer_objects);
1867 }
add_texture2d_objectsArgumentsBuilder1868 void add_texture2d_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>> texture2d_objects) {
1869 fbb_.AddOffset(Arguments::VT_TEXTURE2D_OBJECTS, texture2d_objects);
1870 }
add_tensor_linear_objectsArgumentsBuilder1871 void add_tensor_linear_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>> tensor_linear_objects) {
1872 fbb_.AddOffset(Arguments::VT_TENSOR_LINEAR_OBJECTS, tensor_linear_objects);
1873 }
add_tensor_objectsArgumentsBuilder1874 void add_tensor_objects(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>> tensor_objects) {
1875 fbb_.AddOffset(Arguments::VT_TENSOR_OBJECTS, tensor_objects);
1876 }
ArgumentsBuilderArgumentsBuilder1877 explicit ArgumentsBuilder(flatbuffers::FlatBufferBuilder &_fbb)
1878 : fbb_(_fbb) {
1879 start_ = fbb_.StartTable();
1880 }
FinishArgumentsBuilder1881 flatbuffers::Offset<Arguments> Finish() {
1882 const auto end = fbb_.EndTable(start_);
1883 auto o = flatbuffers::Offset<Arguments>(end);
1884 return o;
1885 }
1886 };
1887
1888 inline flatbuffers::Offset<Arguments> CreateArguments(
1889 flatbuffers::FlatBufferBuilder &_fbb,
1890 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::IntValue>>> int_values = 0,
1891 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>>> float_values = 0,
1892 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>>> half_values = 0,
1893 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>> buffer_refs = 0,
1894 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>> texture2d_refs = 0,
1895 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>> tensor_linear_refs = 0,
1896 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>> tensor_refs = 0,
1897 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>> buffer_objects = 0,
1898 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>> texture2d_objects = 0,
1899 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>> tensor_linear_objects = 0,
1900 flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>> tensor_objects = 0) {
1901 ArgumentsBuilder builder_(_fbb);
1902 builder_.add_tensor_objects(tensor_objects);
1903 builder_.add_tensor_linear_objects(tensor_linear_objects);
1904 builder_.add_texture2d_objects(texture2d_objects);
1905 builder_.add_buffer_objects(buffer_objects);
1906 builder_.add_tensor_refs(tensor_refs);
1907 builder_.add_tensor_linear_refs(tensor_linear_refs);
1908 builder_.add_texture2d_refs(texture2d_refs);
1909 builder_.add_buffer_refs(buffer_refs);
1910 builder_.add_half_values(half_values);
1911 builder_.add_float_values(float_values);
1912 builder_.add_int_values(int_values);
1913 return builder_.Finish();
1914 }
1915
1916 inline flatbuffers::Offset<Arguments> CreateArgumentsDirect(
1917 flatbuffers::FlatBufferBuilder &_fbb,
1918 const std::vector<flatbuffers::Offset<tflite::gpu::data::IntValue>> *int_values = nullptr,
1919 const std::vector<flatbuffers::Offset<tflite::gpu::data::FloatValue>> *float_values = nullptr,
1920 const std::vector<flatbuffers::Offset<tflite::gpu::data::HalfValue>> *half_values = nullptr,
1921 const std::vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *buffer_refs = nullptr,
1922 const std::vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *texture2d_refs = nullptr,
1923 const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *tensor_linear_refs = nullptr,
1924 const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *tensor_refs = nullptr,
1925 const std::vector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>> *buffer_objects = nullptr,
1926 const std::vector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>> *texture2d_objects = nullptr,
1927 const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>> *tensor_linear_objects = nullptr,
1928 const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>> *tensor_objects = nullptr) {
1929 auto int_values__ = int_values ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::IntValue>>(*int_values) : 0;
1930 auto float_values__ = float_values ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::FloatValue>>(*float_values) : 0;
1931 auto half_values__ = half_values ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::HalfValue>>(*half_values) : 0;
1932 auto buffer_refs__ = buffer_refs ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>(*buffer_refs) : 0;
1933 auto texture2d_refs__ = texture2d_refs ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>(*texture2d_refs) : 0;
1934 auto tensor_linear_refs__ = tensor_linear_refs ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>(*tensor_linear_refs) : 0;
1935 auto tensor_refs__ = tensor_refs ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>(*tensor_refs) : 0;
1936 auto buffer_objects__ = buffer_objects ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::BufferDescriptorMapValue>>(*buffer_objects) : 0;
1937 auto texture2d_objects__ = texture2d_objects ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::Texture2DDescriptorMapValue>>(*texture2d_objects) : 0;
1938 auto tensor_linear_objects__ = tensor_linear_objects ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::TensorLinearDescriptorMapValue>>(*tensor_linear_objects) : 0;
1939 auto tensor_objects__ = tensor_objects ? _fbb.CreateVector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptorMapValue>>(*tensor_objects) : 0;
1940 return tflite::gpu::data::CreateArguments(
1941 _fbb,
1942 int_values__,
1943 float_values__,
1944 half_values__,
1945 buffer_refs__,
1946 texture2d_refs__,
1947 tensor_linear_refs__,
1948 tensor_refs__,
1949 buffer_objects__,
1950 texture2d_objects__,
1951 tensor_linear_objects__,
1952 tensor_objects__);
1953 }
1954
1955 struct OperationDef FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
1956 typedef OperationDefBuilder Builder;
1957 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
1958 VT_PRECISION = 4,
1959 VT_SRC_TENSORS = 6,
1960 VT_DST_TENSORS = 8
1961 };
precisionFLATBUFFERS_FINAL_CLASS1962 tflite::gpu::data::CalculationsPrecision precision() const {
1963 return static_cast<tflite::gpu::data::CalculationsPrecision>(
1964 GetField<int8_t>(VT_PRECISION, 0));
1965 }
1966 const flatbuffers::Vector<
1967 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>
src_tensorsFLATBUFFERS_FINAL_CLASS1968 *src_tensors() const {
1969 return GetPointer<const flatbuffers::Vector<
1970 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>> *>(
1971 VT_SRC_TENSORS);
1972 }
1973 const flatbuffers::Vector<
1974 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>
dst_tensorsFLATBUFFERS_FINAL_CLASS1975 *dst_tensors() const {
1976 return GetPointer<const flatbuffers::Vector<
1977 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>> *>(
1978 VT_DST_TENSORS);
1979 }
VerifyFLATBUFFERS_FINAL_CLASS1980 bool Verify(flatbuffers::Verifier &verifier) const {
1981 return VerifyTableStart(verifier) &&
1982 VerifyField<int8_t>(verifier, VT_PRECISION) &&
1983 VerifyOffset(verifier, VT_SRC_TENSORS) &&
1984 verifier.VerifyVector(src_tensors()) &&
1985 verifier.VerifyVectorOfTables(src_tensors()) &&
1986 VerifyOffset(verifier, VT_DST_TENSORS) &&
1987 verifier.VerifyVector(dst_tensors()) &&
1988 verifier.VerifyVectorOfTables(dst_tensors()) && verifier.EndTable();
1989 }
1990 };
1991
1992 struct OperationDefBuilder {
1993 typedef OperationDef Table;
1994 flatbuffers::FlatBufferBuilder &fbb_;
1995 flatbuffers::uoffset_t start_;
add_precisionOperationDefBuilder1996 void add_precision(tflite::gpu::data::CalculationsPrecision precision) {
1997 fbb_.AddElement<int8_t>(OperationDef::VT_PRECISION,
1998 static_cast<int8_t>(precision), 0);
1999 }
add_src_tensorsOperationDefBuilder2000 void add_src_tensors(
2001 flatbuffers::Offset<flatbuffers::Vector<
2002 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>>
2003 src_tensors) {
2004 fbb_.AddOffset(OperationDef::VT_SRC_TENSORS, src_tensors);
2005 }
add_dst_tensorsOperationDefBuilder2006 void add_dst_tensors(
2007 flatbuffers::Offset<flatbuffers::Vector<
2008 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>>
2009 dst_tensors) {
2010 fbb_.AddOffset(OperationDef::VT_DST_TENSORS, dst_tensors);
2011 }
OperationDefBuilderOperationDefBuilder2012 explicit OperationDefBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2013 : fbb_(_fbb) {
2014 start_ = fbb_.StartTable();
2015 }
FinishOperationDefBuilder2016 flatbuffers::Offset<OperationDef> Finish() {
2017 const auto end = fbb_.EndTable(start_);
2018 auto o = flatbuffers::Offset<OperationDef>(end);
2019 return o;
2020 }
2021 };
2022
2023 inline flatbuffers::Offset<OperationDef> CreateOperationDef(
2024 flatbuffers::FlatBufferBuilder &_fbb,
2025 tflite::gpu::data::CalculationsPrecision precision =
2026 tflite::gpu::data::CalculationsPrecision::F32,
2027 flatbuffers::Offset<flatbuffers::Vector<
2028 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>>
2029 src_tensors = 0,
2030 flatbuffers::Offset<flatbuffers::Vector<
2031 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>>
2032 dst_tensors = 0) {
2033 OperationDefBuilder builder_(_fbb);
2034 builder_.add_dst_tensors(dst_tensors);
2035 builder_.add_src_tensors(src_tensors);
2036 builder_.add_precision(precision);
2037 return builder_.Finish();
2038 }
2039
2040 inline flatbuffers::Offset<OperationDef> CreateOperationDefDirect(
2041 flatbuffers::FlatBufferBuilder &_fbb,
2042 tflite::gpu::data::CalculationsPrecision precision =
2043 tflite::gpu::data::CalculationsPrecision::F32,
2044 const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>
2045 *src_tensors = nullptr,
2046 const std::vector<flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>
2047 *dst_tensors = nullptr) {
2048 auto src_tensors__ =
2049 src_tensors
2050 ? _fbb.CreateVector<
2051 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>(
2052 *src_tensors)
2053 : 0;
2054 auto dst_tensors__ =
2055 dst_tensors
2056 ? _fbb.CreateVector<
2057 flatbuffers::Offset<tflite::gpu::data::TensorDescriptor>>(
2058 *dst_tensors)
2059 : 0;
2060 return tflite::gpu::data::CreateOperationDef(_fbb, precision, src_tensors__,
2061 dst_tensors__);
2062 }
2063
2064 struct CompilerOption FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2065 typedef CompilerOptionBuilder Builder;
2066 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2067 VT_OPTION = 4
2068 };
optionFLATBUFFERS_FINAL_CLASS2069 tflite::gpu::data::CompilerOptions option() const {
2070 return static_cast<tflite::gpu::data::CompilerOptions>(
2071 GetField<int8_t>(VT_OPTION, 0));
2072 }
VerifyFLATBUFFERS_FINAL_CLASS2073 bool Verify(flatbuffers::Verifier &verifier) const {
2074 return VerifyTableStart(verifier) &&
2075 VerifyField<int8_t>(verifier, VT_OPTION) && verifier.EndTable();
2076 }
2077 };
2078
2079 struct CompilerOptionBuilder {
2080 typedef CompilerOption Table;
2081 flatbuffers::FlatBufferBuilder &fbb_;
2082 flatbuffers::uoffset_t start_;
add_optionCompilerOptionBuilder2083 void add_option(tflite::gpu::data::CompilerOptions option) {
2084 fbb_.AddElement<int8_t>(CompilerOption::VT_OPTION,
2085 static_cast<int8_t>(option), 0);
2086 }
CompilerOptionBuilderCompilerOptionBuilder2087 explicit CompilerOptionBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2088 : fbb_(_fbb) {
2089 start_ = fbb_.StartTable();
2090 }
FinishCompilerOptionBuilder2091 flatbuffers::Offset<CompilerOption> Finish() {
2092 const auto end = fbb_.EndTable(start_);
2093 auto o = flatbuffers::Offset<CompilerOption>(end);
2094 return o;
2095 }
2096 };
2097
2098 inline flatbuffers::Offset<CompilerOption> CreateCompilerOption(
2099 flatbuffers::FlatBufferBuilder &_fbb,
2100 tflite::gpu::data::CompilerOptions option =
2101 tflite::gpu::data::CompilerOptions::ADRENO_FULL_SIMD_LINE) {
2102 CompilerOptionBuilder builder_(_fbb);
2103 builder_.add_option(option);
2104 return builder_.Finish();
2105 }
2106
2107 struct GPUOperation FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
2108 typedef GPUOperationBuilder Builder;
2109 enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
2110 VT_ARGUMENTS = 4,
2111 VT_CODE = 6,
2112 VT_WORK_GROUP_SIZE = 8,
2113 VT_COMPILER_OPTIONS = 10,
2114 VT_TENSOR_TO_GRID = 12,
2115 VT_ELEMENTWISE = 14,
2116 VT_LINKABLE = 16,
2117 VT_CHECK_SRC_CHANNELS_SIZE = 18,
2118 VT_DEFINITION = 20,
2119 VT_GRID_DIMENSION = 22,
2120 VT_WORK_GROUP_LAUNCH_ORDER = 24,
2121 VT_GRID_SIZE = 26,
2122 VT_SRC_TENSORS_NAMES = 28,
2123 VT_DST_TENSORS_NAMES = 30,
2124 VT_WORK_GROUPS_COUNT = 32,
2125 VT_LINKABLE_COUNT = 34,
2126 VT_ELEMENTWISE_CODE = 36
2127 };
argumentsFLATBUFFERS_FINAL_CLASS2128 const tflite::gpu::data::Arguments *arguments() const {
2129 return GetPointer<const tflite::gpu::data::Arguments *>(VT_ARGUMENTS);
2130 }
codeFLATBUFFERS_FINAL_CLASS2131 const flatbuffers::String *code() const {
2132 return GetPointer<const flatbuffers::String *>(VT_CODE);
2133 }
work_group_sizeFLATBUFFERS_FINAL_CLASS2134 const tflite::gpu::data::Int3 *work_group_size() const {
2135 return GetPointer<const tflite::gpu::data::Int3 *>(VT_WORK_GROUP_SIZE);
2136 }
2137 const flatbuffers::Vector<
2138 flatbuffers::Offset<tflite::gpu::data::CompilerOption>>
compiler_optionsFLATBUFFERS_FINAL_CLASS2139 *compiler_options() const {
2140 return GetPointer<const flatbuffers::Vector<
2141 flatbuffers::Offset<tflite::gpu::data::CompilerOption>> *>(
2142 VT_COMPILER_OPTIONS);
2143 }
tensor_to_gridFLATBUFFERS_FINAL_CLASS2144 tflite::gpu::data::TensorToGrid tensor_to_grid() const {
2145 return static_cast<tflite::gpu::data::TensorToGrid>(
2146 GetField<int8_t>(VT_TENSOR_TO_GRID, 0));
2147 }
elementwiseFLATBUFFERS_FINAL_CLASS2148 bool elementwise() const { return GetField<uint8_t>(VT_ELEMENTWISE, 0) != 0; }
linkableFLATBUFFERS_FINAL_CLASS2149 bool linkable() const { return GetField<uint8_t>(VT_LINKABLE, 0) != 0; }
check_src_channels_sizeFLATBUFFERS_FINAL_CLASS2150 bool check_src_channels_size() const {
2151 return GetField<uint8_t>(VT_CHECK_SRC_CHANNELS_SIZE, 0) != 0;
2152 }
definitionFLATBUFFERS_FINAL_CLASS2153 const tflite::gpu::data::OperationDef *definition() const {
2154 return GetPointer<const tflite::gpu::data::OperationDef *>(VT_DEFINITION);
2155 }
grid_dimensionFLATBUFFERS_FINAL_CLASS2156 int32_t grid_dimension() const {
2157 return GetField<int32_t>(VT_GRID_DIMENSION, 0);
2158 }
work_group_launch_orderFLATBUFFERS_FINAL_CLASS2159 const tflite::gpu::data::Int3 *work_group_launch_order() const {
2160 return GetPointer<const tflite::gpu::data::Int3 *>(
2161 VT_WORK_GROUP_LAUNCH_ORDER);
2162 }
grid_sizeFLATBUFFERS_FINAL_CLASS2163 const tflite::gpu::data::Int3 *grid_size() const {
2164 return GetPointer<const tflite::gpu::data::Int3 *>(VT_GRID_SIZE);
2165 }
2166 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>
src_tensors_namesFLATBUFFERS_FINAL_CLASS2167 *src_tensors_names() const {
2168 return GetPointer<
2169 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
2170 VT_SRC_TENSORS_NAMES);
2171 }
2172 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>
dst_tensors_namesFLATBUFFERS_FINAL_CLASS2173 *dst_tensors_names() const {
2174 return GetPointer<
2175 const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(
2176 VT_DST_TENSORS_NAMES);
2177 }
work_groups_countFLATBUFFERS_FINAL_CLASS2178 const tflite::gpu::data::Int3 *work_groups_count() const {
2179 return GetPointer<const tflite::gpu::data::Int3 *>(VT_WORK_GROUPS_COUNT);
2180 }
linkable_countFLATBUFFERS_FINAL_CLASS2181 int32_t linkable_count() const {
2182 return GetField<int32_t>(VT_LINKABLE_COUNT, 0);
2183 }
elementwise_codeFLATBUFFERS_FINAL_CLASS2184 const flatbuffers::String *elementwise_code() const {
2185 return GetPointer<const flatbuffers::String *>(VT_ELEMENTWISE_CODE);
2186 }
VerifyFLATBUFFERS_FINAL_CLASS2187 bool Verify(flatbuffers::Verifier &verifier) const {
2188 return VerifyTableStart(verifier) && VerifyOffset(verifier, VT_ARGUMENTS) &&
2189 verifier.VerifyTable(arguments()) &&
2190 VerifyOffset(verifier, VT_CODE) && verifier.VerifyString(code()) &&
2191 VerifyOffset(verifier, VT_WORK_GROUP_SIZE) &&
2192 verifier.VerifyTable(work_group_size()) &&
2193 VerifyOffset(verifier, VT_COMPILER_OPTIONS) &&
2194 verifier.VerifyVector(compiler_options()) &&
2195 verifier.VerifyVectorOfTables(compiler_options()) &&
2196 VerifyField<int8_t>(verifier, VT_TENSOR_TO_GRID) &&
2197 VerifyField<uint8_t>(verifier, VT_ELEMENTWISE) &&
2198 VerifyField<uint8_t>(verifier, VT_LINKABLE) &&
2199 VerifyField<uint8_t>(verifier, VT_CHECK_SRC_CHANNELS_SIZE) &&
2200 VerifyOffset(verifier, VT_DEFINITION) &&
2201 verifier.VerifyTable(definition()) &&
2202 VerifyField<int32_t>(verifier, VT_GRID_DIMENSION) &&
2203 VerifyOffset(verifier, VT_WORK_GROUP_LAUNCH_ORDER) &&
2204 verifier.VerifyTable(work_group_launch_order()) &&
2205 VerifyOffset(verifier, VT_GRID_SIZE) &&
2206 verifier.VerifyTable(grid_size()) &&
2207 VerifyOffset(verifier, VT_SRC_TENSORS_NAMES) &&
2208 verifier.VerifyVector(src_tensors_names()) &&
2209 verifier.VerifyVectorOfStrings(src_tensors_names()) &&
2210 VerifyOffset(verifier, VT_DST_TENSORS_NAMES) &&
2211 verifier.VerifyVector(dst_tensors_names()) &&
2212 verifier.VerifyVectorOfStrings(dst_tensors_names()) &&
2213 VerifyOffset(verifier, VT_WORK_GROUPS_COUNT) &&
2214 verifier.VerifyTable(work_groups_count()) &&
2215 VerifyField<int32_t>(verifier, VT_LINKABLE_COUNT) &&
2216 VerifyOffset(verifier, VT_ELEMENTWISE_CODE) &&
2217 verifier.VerifyString(elementwise_code()) && verifier.EndTable();
2218 }
2219 };
2220
2221 struct GPUOperationBuilder {
2222 typedef GPUOperation Table;
2223 flatbuffers::FlatBufferBuilder &fbb_;
2224 flatbuffers::uoffset_t start_;
add_argumentsGPUOperationBuilder2225 void add_arguments(
2226 flatbuffers::Offset<tflite::gpu::data::Arguments> arguments) {
2227 fbb_.AddOffset(GPUOperation::VT_ARGUMENTS, arguments);
2228 }
add_codeGPUOperationBuilder2229 void add_code(flatbuffers::Offset<flatbuffers::String> code) {
2230 fbb_.AddOffset(GPUOperation::VT_CODE, code);
2231 }
add_work_group_sizeGPUOperationBuilder2232 void add_work_group_size(
2233 flatbuffers::Offset<tflite::gpu::data::Int3> work_group_size) {
2234 fbb_.AddOffset(GPUOperation::VT_WORK_GROUP_SIZE, work_group_size);
2235 }
add_compiler_optionsGPUOperationBuilder2236 void add_compiler_options(
2237 flatbuffers::Offset<flatbuffers::Vector<
2238 flatbuffers::Offset<tflite::gpu::data::CompilerOption>>>
2239 compiler_options) {
2240 fbb_.AddOffset(GPUOperation::VT_COMPILER_OPTIONS, compiler_options);
2241 }
add_tensor_to_gridGPUOperationBuilder2242 void add_tensor_to_grid(tflite::gpu::data::TensorToGrid tensor_to_grid) {
2243 fbb_.AddElement<int8_t>(GPUOperation::VT_TENSOR_TO_GRID,
2244 static_cast<int8_t>(tensor_to_grid), 0);
2245 }
add_elementwiseGPUOperationBuilder2246 void add_elementwise(bool elementwise) {
2247 fbb_.AddElement<uint8_t>(GPUOperation::VT_ELEMENTWISE,
2248 static_cast<uint8_t>(elementwise), 0);
2249 }
add_linkableGPUOperationBuilder2250 void add_linkable(bool linkable) {
2251 fbb_.AddElement<uint8_t>(GPUOperation::VT_LINKABLE,
2252 static_cast<uint8_t>(linkable), 0);
2253 }
add_check_src_channels_sizeGPUOperationBuilder2254 void add_check_src_channels_size(bool check_src_channels_size) {
2255 fbb_.AddElement<uint8_t>(GPUOperation::VT_CHECK_SRC_CHANNELS_SIZE,
2256 static_cast<uint8_t>(check_src_channels_size), 0);
2257 }
add_definitionGPUOperationBuilder2258 void add_definition(
2259 flatbuffers::Offset<tflite::gpu::data::OperationDef> definition) {
2260 fbb_.AddOffset(GPUOperation::VT_DEFINITION, definition);
2261 }
add_grid_dimensionGPUOperationBuilder2262 void add_grid_dimension(int32_t grid_dimension) {
2263 fbb_.AddElement<int32_t>(GPUOperation::VT_GRID_DIMENSION, grid_dimension,
2264 0);
2265 }
add_work_group_launch_orderGPUOperationBuilder2266 void add_work_group_launch_order(
2267 flatbuffers::Offset<tflite::gpu::data::Int3> work_group_launch_order) {
2268 fbb_.AddOffset(GPUOperation::VT_WORK_GROUP_LAUNCH_ORDER,
2269 work_group_launch_order);
2270 }
add_grid_sizeGPUOperationBuilder2271 void add_grid_size(flatbuffers::Offset<tflite::gpu::data::Int3> grid_size) {
2272 fbb_.AddOffset(GPUOperation::VT_GRID_SIZE, grid_size);
2273 }
add_src_tensors_namesGPUOperationBuilder2274 void add_src_tensors_names(
2275 flatbuffers::Offset<
2276 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
2277 src_tensors_names) {
2278 fbb_.AddOffset(GPUOperation::VT_SRC_TENSORS_NAMES, src_tensors_names);
2279 }
add_dst_tensors_namesGPUOperationBuilder2280 void add_dst_tensors_names(
2281 flatbuffers::Offset<
2282 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
2283 dst_tensors_names) {
2284 fbb_.AddOffset(GPUOperation::VT_DST_TENSORS_NAMES, dst_tensors_names);
2285 }
add_work_groups_countGPUOperationBuilder2286 void add_work_groups_count(
2287 flatbuffers::Offset<tflite::gpu::data::Int3> work_groups_count) {
2288 fbb_.AddOffset(GPUOperation::VT_WORK_GROUPS_COUNT, work_groups_count);
2289 }
add_linkable_countGPUOperationBuilder2290 void add_linkable_count(int32_t linkable_count) {
2291 fbb_.AddElement<int32_t>(GPUOperation::VT_LINKABLE_COUNT, linkable_count,
2292 0);
2293 }
add_elementwise_codeGPUOperationBuilder2294 void add_elementwise_code(
2295 flatbuffers::Offset<flatbuffers::String> elementwise_code) {
2296 fbb_.AddOffset(GPUOperation::VT_ELEMENTWISE_CODE, elementwise_code);
2297 }
GPUOperationBuilderGPUOperationBuilder2298 explicit GPUOperationBuilder(flatbuffers::FlatBufferBuilder &_fbb)
2299 : fbb_(_fbb) {
2300 start_ = fbb_.StartTable();
2301 }
FinishGPUOperationBuilder2302 flatbuffers::Offset<GPUOperation> Finish() {
2303 const auto end = fbb_.EndTable(start_);
2304 auto o = flatbuffers::Offset<GPUOperation>(end);
2305 return o;
2306 }
2307 };
2308
2309 inline flatbuffers::Offset<GPUOperation> CreateGPUOperation(
2310 flatbuffers::FlatBufferBuilder &_fbb,
2311 flatbuffers::Offset<tflite::gpu::data::Arguments> arguments = 0,
2312 flatbuffers::Offset<flatbuffers::String> code = 0,
2313 flatbuffers::Offset<tflite::gpu::data::Int3> work_group_size = 0,
2314 flatbuffers::Offset<flatbuffers::Vector<
2315 flatbuffers::Offset<tflite::gpu::data::CompilerOption>>>
2316 compiler_options = 0,
2317 tflite::gpu::data::TensorToGrid tensor_to_grid =
2318 tflite::gpu::data::TensorToGrid::CUSTOM,
2319 bool elementwise = false, bool linkable = false,
2320 bool check_src_channels_size = false,
2321 flatbuffers::Offset<tflite::gpu::data::OperationDef> definition = 0,
2322 int32_t grid_dimension = 0,
2323 flatbuffers::Offset<tflite::gpu::data::Int3> work_group_launch_order = 0,
2324 flatbuffers::Offset<tflite::gpu::data::Int3> grid_size = 0,
2325 flatbuffers::Offset<
2326 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
2327 src_tensors_names = 0,
2328 flatbuffers::Offset<
2329 flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>>
2330 dst_tensors_names = 0,
2331 flatbuffers::Offset<tflite::gpu::data::Int3> work_groups_count = 0,
2332 int32_t linkable_count = 0,
2333 flatbuffers::Offset<flatbuffers::String> elementwise_code = 0) {
2334 GPUOperationBuilder builder_(_fbb);
2335 builder_.add_elementwise_code(elementwise_code);
2336 builder_.add_linkable_count(linkable_count);
2337 builder_.add_work_groups_count(work_groups_count);
2338 builder_.add_dst_tensors_names(dst_tensors_names);
2339 builder_.add_src_tensors_names(src_tensors_names);
2340 builder_.add_grid_size(grid_size);
2341 builder_.add_work_group_launch_order(work_group_launch_order);
2342 builder_.add_grid_dimension(grid_dimension);
2343 builder_.add_definition(definition);
2344 builder_.add_compiler_options(compiler_options);
2345 builder_.add_work_group_size(work_group_size);
2346 builder_.add_code(code);
2347 builder_.add_arguments(arguments);
2348 builder_.add_check_src_channels_size(check_src_channels_size);
2349 builder_.add_linkable(linkable);
2350 builder_.add_elementwise(elementwise);
2351 builder_.add_tensor_to_grid(tensor_to_grid);
2352 return builder_.Finish();
2353 }
2354
2355 inline flatbuffers::Offset<GPUOperation> CreateGPUOperationDirect(
2356 flatbuffers::FlatBufferBuilder &_fbb,
2357 flatbuffers::Offset<tflite::gpu::data::Arguments> arguments = 0,
2358 const char *code = nullptr,
2359 flatbuffers::Offset<tflite::gpu::data::Int3> work_group_size = 0,
2360 const std::vector<flatbuffers::Offset<tflite::gpu::data::CompilerOption>>
2361 *compiler_options = nullptr,
2362 tflite::gpu::data::TensorToGrid tensor_to_grid =
2363 tflite::gpu::data::TensorToGrid::CUSTOM,
2364 bool elementwise = false, bool linkable = false,
2365 bool check_src_channels_size = false,
2366 flatbuffers::Offset<tflite::gpu::data::OperationDef> definition = 0,
2367 int32_t grid_dimension = 0,
2368 flatbuffers::Offset<tflite::gpu::data::Int3> work_group_launch_order = 0,
2369 flatbuffers::Offset<tflite::gpu::data::Int3> grid_size = 0,
2370 const std::vector<flatbuffers::Offset<flatbuffers::String>>
2371 *src_tensors_names = nullptr,
2372 const std::vector<flatbuffers::Offset<flatbuffers::String>>
2373 *dst_tensors_names = nullptr,
2374 flatbuffers::Offset<tflite::gpu::data::Int3> work_groups_count = 0,
2375 int32_t linkable_count = 0, const char *elementwise_code = nullptr) {
2376 auto code__ = code ? _fbb.CreateString(code) : 0;
2377 auto compiler_options__ =
2378 compiler_options
2379 ? _fbb.CreateVector<
2380 flatbuffers::Offset<tflite::gpu::data::CompilerOption>>(
2381 *compiler_options)
2382 : 0;
2383 auto src_tensors_names__ =
2384 src_tensors_names
2385 ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(
2386 *src_tensors_names)
2387 : 0;
2388 auto dst_tensors_names__ =
2389 dst_tensors_names
2390 ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(
2391 *dst_tensors_names)
2392 : 0;
2393 auto elementwise_code__ =
2394 elementwise_code ? _fbb.CreateString(elementwise_code) : 0;
2395 return tflite::gpu::data::CreateGPUOperation(
2396 _fbb, arguments, code__, work_group_size, compiler_options__,
2397 tensor_to_grid, elementwise, linkable, check_src_channels_size,
2398 definition, grid_dimension, work_group_launch_order, grid_size,
2399 src_tensors_names__, dst_tensors_names__, work_groups_count,
2400 linkable_count, elementwise_code__);
2401 }
2402
2403 } // namespace data
2404 } // namespace gpu
2405 } // namespace tflite
2406
2407 #endif // FLATBUFFERS_GENERATED_SERIALIZATIONBASE_TFLITE_GPU_DATA_H_
2408