1 // clang-format off
2 // Generated file (from: tile_3.mod.py). Do not edit
3 // Create the model
createTestModel()4 Model createTestModel() {
5 const std::vector<Operand> operands = {
6 {
7 .type = OperandType::TENSOR_FLOAT32,
8 .dimensions = {1, 2, 3},
9 .numberOfConsumers = 1,
10 .scale = 0.0f,
11 .zeroPoint = 0,
12 .lifetime = OperandLifeTime::MODEL_INPUT,
13 .location = {.poolIndex = 0, .offset = 0, .length = 0},
14 },
15 {
16 .type = OperandType::TENSOR_INT32,
17 .dimensions = {3},
18 .numberOfConsumers = 1,
19 .scale = 0.0f,
20 .zeroPoint = 0,
21 .lifetime = OperandLifeTime::MODEL_INPUT,
22 .location = {.poolIndex = 0, .offset = 0, .length = 0},
23 },
24 {
25 .type = OperandType::TENSOR_FLOAT32,
26 .dimensions = {2, 6, 3},
27 .numberOfConsumers = 0,
28 .scale = 0.0f,
29 .zeroPoint = 0,
30 .lifetime = OperandLifeTime::MODEL_OUTPUT,
31 .location = {.poolIndex = 0, .offset = 0, .length = 0},
32 }
33 };
34
35 const std::vector<Operation> operations = {
36 {
37 .type = OperationType::TILE,
38 .inputs = {0, 1},
39 .outputs = {2},
40 }
41 };
42
43 const std::vector<uint32_t> inputIndexes = {0, 1};
44 const std::vector<uint32_t> outputIndexes = {2};
45 std::vector<uint8_t> operandValues = {};
46 const std::vector<hidl_memory> pools = {};
47
48 return {
49 .operands = operands,
50 .operations = operations,
51 .inputIndexes = inputIndexes,
52 .outputIndexes = outputIndexes,
53 .operandValues = operandValues,
54 .pools = pools,
55 };
56 }
57
is_ignored(int i)58 inline bool is_ignored(int i) {
59 static std::set<int> ignore = {};
60 return ignore.find(i) != ignore.end();
61 }
62
63 // Create the model
createTestModel_relaxed()64 Model createTestModel_relaxed() {
65 const std::vector<Operand> operands = {
66 {
67 .type = OperandType::TENSOR_FLOAT32,
68 .dimensions = {1, 2, 3},
69 .numberOfConsumers = 1,
70 .scale = 0.0f,
71 .zeroPoint = 0,
72 .lifetime = OperandLifeTime::MODEL_INPUT,
73 .location = {.poolIndex = 0, .offset = 0, .length = 0},
74 },
75 {
76 .type = OperandType::TENSOR_INT32,
77 .dimensions = {3},
78 .numberOfConsumers = 1,
79 .scale = 0.0f,
80 .zeroPoint = 0,
81 .lifetime = OperandLifeTime::MODEL_INPUT,
82 .location = {.poolIndex = 0, .offset = 0, .length = 0},
83 },
84 {
85 .type = OperandType::TENSOR_FLOAT32,
86 .dimensions = {2, 6, 3},
87 .numberOfConsumers = 0,
88 .scale = 0.0f,
89 .zeroPoint = 0,
90 .lifetime = OperandLifeTime::MODEL_OUTPUT,
91 .location = {.poolIndex = 0, .offset = 0, .length = 0},
92 }
93 };
94
95 const std::vector<Operation> operations = {
96 {
97 .type = OperationType::TILE,
98 .inputs = {0, 1},
99 .outputs = {2},
100 }
101 };
102
103 const std::vector<uint32_t> inputIndexes = {0, 1};
104 const std::vector<uint32_t> outputIndexes = {2};
105 std::vector<uint8_t> operandValues = {};
106 const std::vector<hidl_memory> pools = {};
107
108 return {
109 .operands = operands,
110 .operations = operations,
111 .inputIndexes = inputIndexes,
112 .outputIndexes = outputIndexes,
113 .operandValues = operandValues,
114 .pools = pools,
115 .relaxComputationFloat32toFloat16 = true,
116 };
117 }
118
is_ignored_relaxed(int i)119 inline bool is_ignored_relaxed(int i) {
120 static std::set<int> ignore = {};
121 return ignore.find(i) != ignore.end();
122 }
123
124 // Create the model
createTestModel_float16()125 Model createTestModel_float16() {
126 const std::vector<Operand> operands = {
127 {
128 .type = OperandType::TENSOR_FLOAT16,
129 .dimensions = {1, 2, 3},
130 .numberOfConsumers = 1,
131 .scale = 0.0f,
132 .zeroPoint = 0,
133 .lifetime = OperandLifeTime::MODEL_INPUT,
134 .location = {.poolIndex = 0, .offset = 0, .length = 0},
135 },
136 {
137 .type = OperandType::TENSOR_INT32,
138 .dimensions = {3},
139 .numberOfConsumers = 1,
140 .scale = 0.0f,
141 .zeroPoint = 0,
142 .lifetime = OperandLifeTime::MODEL_INPUT,
143 .location = {.poolIndex = 0, .offset = 0, .length = 0},
144 },
145 {
146 .type = OperandType::TENSOR_FLOAT16,
147 .dimensions = {2, 6, 3},
148 .numberOfConsumers = 0,
149 .scale = 0.0f,
150 .zeroPoint = 0,
151 .lifetime = OperandLifeTime::MODEL_OUTPUT,
152 .location = {.poolIndex = 0, .offset = 0, .length = 0},
153 }
154 };
155
156 const std::vector<Operation> operations = {
157 {
158 .type = OperationType::TILE,
159 .inputs = {0, 1},
160 .outputs = {2},
161 }
162 };
163
164 const std::vector<uint32_t> inputIndexes = {0, 1};
165 const std::vector<uint32_t> outputIndexes = {2};
166 std::vector<uint8_t> operandValues = {};
167 const std::vector<hidl_memory> pools = {};
168
169 return {
170 .operands = operands,
171 .operations = operations,
172 .inputIndexes = inputIndexes,
173 .outputIndexes = outputIndexes,
174 .operandValues = operandValues,
175 .pools = pools,
176 };
177 }
178
is_ignored_float16(int i)179 inline bool is_ignored_float16(int i) {
180 static std::set<int> ignore = {};
181 return ignore.find(i) != ignore.end();
182 }
183
184 // Create the model
createTestModel_quant8()185 Model createTestModel_quant8() {
186 const std::vector<Operand> operands = {
187 {
188 .type = OperandType::TENSOR_QUANT8_ASYMM,
189 .dimensions = {1, 2, 3},
190 .numberOfConsumers = 1,
191 .scale = 0.5f,
192 .zeroPoint = 127,
193 .lifetime = OperandLifeTime::MODEL_INPUT,
194 .location = {.poolIndex = 0, .offset = 0, .length = 0},
195 },
196 {
197 .type = OperandType::TENSOR_INT32,
198 .dimensions = {3},
199 .numberOfConsumers = 1,
200 .scale = 0.0f,
201 .zeroPoint = 0,
202 .lifetime = OperandLifeTime::MODEL_INPUT,
203 .location = {.poolIndex = 0, .offset = 0, .length = 0},
204 },
205 {
206 .type = OperandType::TENSOR_QUANT8_ASYMM,
207 .dimensions = {2, 6, 3},
208 .numberOfConsumers = 0,
209 .scale = 0.5f,
210 .zeroPoint = 127,
211 .lifetime = OperandLifeTime::MODEL_OUTPUT,
212 .location = {.poolIndex = 0, .offset = 0, .length = 0},
213 }
214 };
215
216 const std::vector<Operation> operations = {
217 {
218 .type = OperationType::TILE,
219 .inputs = {0, 1},
220 .outputs = {2},
221 }
222 };
223
224 const std::vector<uint32_t> inputIndexes = {0, 1};
225 const std::vector<uint32_t> outputIndexes = {2};
226 std::vector<uint8_t> operandValues = {};
227 const std::vector<hidl_memory> pools = {};
228
229 return {
230 .operands = operands,
231 .operations = operations,
232 .inputIndexes = inputIndexes,
233 .outputIndexes = outputIndexes,
234 .operandValues = operandValues,
235 .pools = pools,
236 };
237 }
238
is_ignored_quant8(int i)239 inline bool is_ignored_quant8(int i) {
240 static std::set<int> ignore = {};
241 return ignore.find(i) != ignore.end();
242 }
243
244 // Create the model
createTestModel_int32()245 Model createTestModel_int32() {
246 const std::vector<Operand> operands = {
247 {
248 .type = OperandType::TENSOR_INT32,
249 .dimensions = {1, 2, 3},
250 .numberOfConsumers = 1,
251 .scale = 0.0f,
252 .zeroPoint = 0,
253 .lifetime = OperandLifeTime::MODEL_INPUT,
254 .location = {.poolIndex = 0, .offset = 0, .length = 0},
255 },
256 {
257 .type = OperandType::TENSOR_INT32,
258 .dimensions = {3},
259 .numberOfConsumers = 1,
260 .scale = 0.0f,
261 .zeroPoint = 0,
262 .lifetime = OperandLifeTime::MODEL_INPUT,
263 .location = {.poolIndex = 0, .offset = 0, .length = 0},
264 },
265 {
266 .type = OperandType::TENSOR_INT32,
267 .dimensions = {2, 6, 3},
268 .numberOfConsumers = 0,
269 .scale = 0.0f,
270 .zeroPoint = 0,
271 .lifetime = OperandLifeTime::MODEL_OUTPUT,
272 .location = {.poolIndex = 0, .offset = 0, .length = 0},
273 }
274 };
275
276 const std::vector<Operation> operations = {
277 {
278 .type = OperationType::TILE,
279 .inputs = {0, 1},
280 .outputs = {2},
281 }
282 };
283
284 const std::vector<uint32_t> inputIndexes = {0, 1};
285 const std::vector<uint32_t> outputIndexes = {2};
286 std::vector<uint8_t> operandValues = {};
287 const std::vector<hidl_memory> pools = {};
288
289 return {
290 .operands = operands,
291 .operations = operations,
292 .inputIndexes = inputIndexes,
293 .outputIndexes = outputIndexes,
294 .operandValues = operandValues,
295 .pools = pools,
296 };
297 }
298
is_ignored_int32(int i)299 inline bool is_ignored_int32(int i) {
300 static std::set<int> ignore = {};
301 return ignore.find(i) != ignore.end();
302 }
303
304 // Create the model
createTestModel_dynamic_output_shape()305 Model createTestModel_dynamic_output_shape() {
306 const std::vector<Operand> operands = {
307 {
308 .type = OperandType::TENSOR_FLOAT32,
309 .dimensions = {1, 2, 3},
310 .numberOfConsumers = 1,
311 .scale = 0.0f,
312 .zeroPoint = 0,
313 .lifetime = OperandLifeTime::MODEL_INPUT,
314 .location = {.poolIndex = 0, .offset = 0, .length = 0},
315 },
316 {
317 .type = OperandType::TENSOR_INT32,
318 .dimensions = {3},
319 .numberOfConsumers = 1,
320 .scale = 0.0f,
321 .zeroPoint = 0,
322 .lifetime = OperandLifeTime::MODEL_INPUT,
323 .location = {.poolIndex = 0, .offset = 0, .length = 0},
324 },
325 {
326 .type = OperandType::TENSOR_FLOAT32,
327 .dimensions = {0, 0, 0},
328 .numberOfConsumers = 0,
329 .scale = 0.0f,
330 .zeroPoint = 0,
331 .lifetime = OperandLifeTime::MODEL_OUTPUT,
332 .location = {.poolIndex = 0, .offset = 0, .length = 0},
333 }
334 };
335
336 const std::vector<Operation> operations = {
337 {
338 .type = OperationType::TILE,
339 .inputs = {0, 1},
340 .outputs = {2},
341 }
342 };
343
344 const std::vector<uint32_t> inputIndexes = {0, 1};
345 const std::vector<uint32_t> outputIndexes = {2};
346 std::vector<uint8_t> operandValues = {};
347 const std::vector<hidl_memory> pools = {};
348
349 return {
350 .operands = operands,
351 .operations = operations,
352 .inputIndexes = inputIndexes,
353 .outputIndexes = outputIndexes,
354 .operandValues = operandValues,
355 .pools = pools,
356 };
357 }
358
is_ignored_dynamic_output_shape(int i)359 inline bool is_ignored_dynamic_output_shape(int i) {
360 static std::set<int> ignore = {};
361 return ignore.find(i) != ignore.end();
362 }
363
364 // Create the model
createTestModel_dynamic_output_shape_relaxed()365 Model createTestModel_dynamic_output_shape_relaxed() {
366 const std::vector<Operand> operands = {
367 {
368 .type = OperandType::TENSOR_FLOAT32,
369 .dimensions = {1, 2, 3},
370 .numberOfConsumers = 1,
371 .scale = 0.0f,
372 .zeroPoint = 0,
373 .lifetime = OperandLifeTime::MODEL_INPUT,
374 .location = {.poolIndex = 0, .offset = 0, .length = 0},
375 },
376 {
377 .type = OperandType::TENSOR_INT32,
378 .dimensions = {3},
379 .numberOfConsumers = 1,
380 .scale = 0.0f,
381 .zeroPoint = 0,
382 .lifetime = OperandLifeTime::MODEL_INPUT,
383 .location = {.poolIndex = 0, .offset = 0, .length = 0},
384 },
385 {
386 .type = OperandType::TENSOR_FLOAT32,
387 .dimensions = {0, 0, 0},
388 .numberOfConsumers = 0,
389 .scale = 0.0f,
390 .zeroPoint = 0,
391 .lifetime = OperandLifeTime::MODEL_OUTPUT,
392 .location = {.poolIndex = 0, .offset = 0, .length = 0},
393 }
394 };
395
396 const std::vector<Operation> operations = {
397 {
398 .type = OperationType::TILE,
399 .inputs = {0, 1},
400 .outputs = {2},
401 }
402 };
403
404 const std::vector<uint32_t> inputIndexes = {0, 1};
405 const std::vector<uint32_t> outputIndexes = {2};
406 std::vector<uint8_t> operandValues = {};
407 const std::vector<hidl_memory> pools = {};
408
409 return {
410 .operands = operands,
411 .operations = operations,
412 .inputIndexes = inputIndexes,
413 .outputIndexes = outputIndexes,
414 .operandValues = operandValues,
415 .pools = pools,
416 .relaxComputationFloat32toFloat16 = true,
417 };
418 }
419
is_ignored_dynamic_output_shape_relaxed(int i)420 inline bool is_ignored_dynamic_output_shape_relaxed(int i) {
421 static std::set<int> ignore = {};
422 return ignore.find(i) != ignore.end();
423 }
424
425 // Create the model
createTestModel_dynamic_output_shape_float16()426 Model createTestModel_dynamic_output_shape_float16() {
427 const std::vector<Operand> operands = {
428 {
429 .type = OperandType::TENSOR_FLOAT16,
430 .dimensions = {1, 2, 3},
431 .numberOfConsumers = 1,
432 .scale = 0.0f,
433 .zeroPoint = 0,
434 .lifetime = OperandLifeTime::MODEL_INPUT,
435 .location = {.poolIndex = 0, .offset = 0, .length = 0},
436 },
437 {
438 .type = OperandType::TENSOR_INT32,
439 .dimensions = {3},
440 .numberOfConsumers = 1,
441 .scale = 0.0f,
442 .zeroPoint = 0,
443 .lifetime = OperandLifeTime::MODEL_INPUT,
444 .location = {.poolIndex = 0, .offset = 0, .length = 0},
445 },
446 {
447 .type = OperandType::TENSOR_FLOAT16,
448 .dimensions = {0, 0, 0},
449 .numberOfConsumers = 0,
450 .scale = 0.0f,
451 .zeroPoint = 0,
452 .lifetime = OperandLifeTime::MODEL_OUTPUT,
453 .location = {.poolIndex = 0, .offset = 0, .length = 0},
454 }
455 };
456
457 const std::vector<Operation> operations = {
458 {
459 .type = OperationType::TILE,
460 .inputs = {0, 1},
461 .outputs = {2},
462 }
463 };
464
465 const std::vector<uint32_t> inputIndexes = {0, 1};
466 const std::vector<uint32_t> outputIndexes = {2};
467 std::vector<uint8_t> operandValues = {};
468 const std::vector<hidl_memory> pools = {};
469
470 return {
471 .operands = operands,
472 .operations = operations,
473 .inputIndexes = inputIndexes,
474 .outputIndexes = outputIndexes,
475 .operandValues = operandValues,
476 .pools = pools,
477 };
478 }
479
is_ignored_dynamic_output_shape_float16(int i)480 inline bool is_ignored_dynamic_output_shape_float16(int i) {
481 static std::set<int> ignore = {};
482 return ignore.find(i) != ignore.end();
483 }
484
485 // Create the model
createTestModel_dynamic_output_shape_quant8()486 Model createTestModel_dynamic_output_shape_quant8() {
487 const std::vector<Operand> operands = {
488 {
489 .type = OperandType::TENSOR_QUANT8_ASYMM,
490 .dimensions = {1, 2, 3},
491 .numberOfConsumers = 1,
492 .scale = 0.5f,
493 .zeroPoint = 127,
494 .lifetime = OperandLifeTime::MODEL_INPUT,
495 .location = {.poolIndex = 0, .offset = 0, .length = 0},
496 },
497 {
498 .type = OperandType::TENSOR_INT32,
499 .dimensions = {3},
500 .numberOfConsumers = 1,
501 .scale = 0.0f,
502 .zeroPoint = 0,
503 .lifetime = OperandLifeTime::MODEL_INPUT,
504 .location = {.poolIndex = 0, .offset = 0, .length = 0},
505 },
506 {
507 .type = OperandType::TENSOR_QUANT8_ASYMM,
508 .dimensions = {0, 0, 0},
509 .numberOfConsumers = 0,
510 .scale = 0.5f,
511 .zeroPoint = 127,
512 .lifetime = OperandLifeTime::MODEL_OUTPUT,
513 .location = {.poolIndex = 0, .offset = 0, .length = 0},
514 }
515 };
516
517 const std::vector<Operation> operations = {
518 {
519 .type = OperationType::TILE,
520 .inputs = {0, 1},
521 .outputs = {2},
522 }
523 };
524
525 const std::vector<uint32_t> inputIndexes = {0, 1};
526 const std::vector<uint32_t> outputIndexes = {2};
527 std::vector<uint8_t> operandValues = {};
528 const std::vector<hidl_memory> pools = {};
529
530 return {
531 .operands = operands,
532 .operations = operations,
533 .inputIndexes = inputIndexes,
534 .outputIndexes = outputIndexes,
535 .operandValues = operandValues,
536 .pools = pools,
537 };
538 }
539
is_ignored_dynamic_output_shape_quant8(int i)540 inline bool is_ignored_dynamic_output_shape_quant8(int i) {
541 static std::set<int> ignore = {};
542 return ignore.find(i) != ignore.end();
543 }
544
545 // Create the model
createTestModel_dynamic_output_shape_int32()546 Model createTestModel_dynamic_output_shape_int32() {
547 const std::vector<Operand> operands = {
548 {
549 .type = OperandType::TENSOR_INT32,
550 .dimensions = {1, 2, 3},
551 .numberOfConsumers = 1,
552 .scale = 0.0f,
553 .zeroPoint = 0,
554 .lifetime = OperandLifeTime::MODEL_INPUT,
555 .location = {.poolIndex = 0, .offset = 0, .length = 0},
556 },
557 {
558 .type = OperandType::TENSOR_INT32,
559 .dimensions = {3},
560 .numberOfConsumers = 1,
561 .scale = 0.0f,
562 .zeroPoint = 0,
563 .lifetime = OperandLifeTime::MODEL_INPUT,
564 .location = {.poolIndex = 0, .offset = 0, .length = 0},
565 },
566 {
567 .type = OperandType::TENSOR_INT32,
568 .dimensions = {0, 0, 0},
569 .numberOfConsumers = 0,
570 .scale = 0.0f,
571 .zeroPoint = 0,
572 .lifetime = OperandLifeTime::MODEL_OUTPUT,
573 .location = {.poolIndex = 0, .offset = 0, .length = 0},
574 }
575 };
576
577 const std::vector<Operation> operations = {
578 {
579 .type = OperationType::TILE,
580 .inputs = {0, 1},
581 .outputs = {2},
582 }
583 };
584
585 const std::vector<uint32_t> inputIndexes = {0, 1};
586 const std::vector<uint32_t> outputIndexes = {2};
587 std::vector<uint8_t> operandValues = {};
588 const std::vector<hidl_memory> pools = {};
589
590 return {
591 .operands = operands,
592 .operations = operations,
593 .inputIndexes = inputIndexes,
594 .outputIndexes = outputIndexes,
595 .operandValues = operandValues,
596 .pools = pools,
597 };
598 }
599
is_ignored_dynamic_output_shape_int32(int i)600 inline bool is_ignored_dynamic_output_shape_int32(int i) {
601 static std::set<int> ignore = {};
602 return ignore.find(i) != ignore.end();
603 }
604
605