1 // clang-format off 2 // Generated file (from: slice.mod.py). Do not edit 3 // Create the model 4 Model createTestModel() { 5 const std::vector<Operand> operands = { 6 { 7 .type = OperandType::TENSOR_FLOAT32, 8 .dimensions = {4}, 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 = {1}, 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_INT32, 26 .dimensions = {1}, 27 .numberOfConsumers = 1, 28 .scale = 0.0f, 29 .zeroPoint = 0, 30 .lifetime = OperandLifeTime::MODEL_INPUT, 31 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 32 }, 33 { 34 .type = OperandType::TENSOR_FLOAT32, 35 .dimensions = {2}, 36 .numberOfConsumers = 0, 37 .scale = 0.0f, 38 .zeroPoint = 0, 39 .lifetime = OperandLifeTime::MODEL_OUTPUT, 40 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 41 } 42 }; 43 44 const std::vector<Operation> operations = { 45 { 46 .type = OperationType::SLICE, 47 .inputs = {0, 1, 2}, 48 .outputs = {3}, 49 } 50 }; 51 52 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 53 const std::vector<uint32_t> outputIndexes = {3}; 54 std::vector<uint8_t> operandValues = {}; 55 const std::vector<hidl_memory> pools = {}; 56 57 return { 58 .operands = operands, 59 .operations = operations, 60 .inputIndexes = inputIndexes, 61 .outputIndexes = outputIndexes, 62 .operandValues = operandValues, 63 .pools = pools, 64 }; 65 } 66 67 inline bool is_ignored(int i) { 68 static std::set<int> ignore = {}; 69 return ignore.find(i) != ignore.end(); 70 } 71 72 // Create the model 73 Model createTestModel_relaxed() { 74 const std::vector<Operand> operands = { 75 { 76 .type = OperandType::TENSOR_FLOAT32, 77 .dimensions = {4}, 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_INT32, 86 .dimensions = {1}, 87 .numberOfConsumers = 1, 88 .scale = 0.0f, 89 .zeroPoint = 0, 90 .lifetime = OperandLifeTime::MODEL_INPUT, 91 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 92 }, 93 { 94 .type = OperandType::TENSOR_INT32, 95 .dimensions = {1}, 96 .numberOfConsumers = 1, 97 .scale = 0.0f, 98 .zeroPoint = 0, 99 .lifetime = OperandLifeTime::MODEL_INPUT, 100 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 101 }, 102 { 103 .type = OperandType::TENSOR_FLOAT32, 104 .dimensions = {2}, 105 .numberOfConsumers = 0, 106 .scale = 0.0f, 107 .zeroPoint = 0, 108 .lifetime = OperandLifeTime::MODEL_OUTPUT, 109 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 110 } 111 }; 112 113 const std::vector<Operation> operations = { 114 { 115 .type = OperationType::SLICE, 116 .inputs = {0, 1, 2}, 117 .outputs = {3}, 118 } 119 }; 120 121 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 122 const std::vector<uint32_t> outputIndexes = {3}; 123 std::vector<uint8_t> operandValues = {}; 124 const std::vector<hidl_memory> pools = {}; 125 126 return { 127 .operands = operands, 128 .operations = operations, 129 .inputIndexes = inputIndexes, 130 .outputIndexes = outputIndexes, 131 .operandValues = operandValues, 132 .pools = pools, 133 .relaxComputationFloat32toFloat16 = true, 134 }; 135 } 136 137 inline bool is_ignored_relaxed(int i) { 138 static std::set<int> ignore = {}; 139 return ignore.find(i) != ignore.end(); 140 } 141 142 // Create the model 143 Model createTestModel_float16() { 144 const std::vector<Operand> operands = { 145 { 146 .type = OperandType::TENSOR_FLOAT16, 147 .dimensions = {4}, 148 .numberOfConsumers = 1, 149 .scale = 0.0f, 150 .zeroPoint = 0, 151 .lifetime = OperandLifeTime::MODEL_INPUT, 152 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 153 }, 154 { 155 .type = OperandType::TENSOR_INT32, 156 .dimensions = {1}, 157 .numberOfConsumers = 1, 158 .scale = 0.0f, 159 .zeroPoint = 0, 160 .lifetime = OperandLifeTime::MODEL_INPUT, 161 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 162 }, 163 { 164 .type = OperandType::TENSOR_INT32, 165 .dimensions = {1}, 166 .numberOfConsumers = 1, 167 .scale = 0.0f, 168 .zeroPoint = 0, 169 .lifetime = OperandLifeTime::MODEL_INPUT, 170 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 171 }, 172 { 173 .type = OperandType::TENSOR_FLOAT16, 174 .dimensions = {2}, 175 .numberOfConsumers = 0, 176 .scale = 0.0f, 177 .zeroPoint = 0, 178 .lifetime = OperandLifeTime::MODEL_OUTPUT, 179 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 180 } 181 }; 182 183 const std::vector<Operation> operations = { 184 { 185 .type = OperationType::SLICE, 186 .inputs = {0, 1, 2}, 187 .outputs = {3}, 188 } 189 }; 190 191 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 192 const std::vector<uint32_t> outputIndexes = {3}; 193 std::vector<uint8_t> operandValues = {}; 194 const std::vector<hidl_memory> pools = {}; 195 196 return { 197 .operands = operands, 198 .operations = operations, 199 .inputIndexes = inputIndexes, 200 .outputIndexes = outputIndexes, 201 .operandValues = operandValues, 202 .pools = pools, 203 }; 204 } 205 206 inline bool is_ignored_float16(int i) { 207 static std::set<int> ignore = {}; 208 return ignore.find(i) != ignore.end(); 209 } 210 211 // Create the model 212 Model createTestModel_dynamic_output_shape() { 213 const std::vector<Operand> operands = { 214 { 215 .type = OperandType::TENSOR_FLOAT32, 216 .dimensions = {4}, 217 .numberOfConsumers = 1, 218 .scale = 0.0f, 219 .zeroPoint = 0, 220 .lifetime = OperandLifeTime::MODEL_INPUT, 221 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 222 }, 223 { 224 .type = OperandType::TENSOR_INT32, 225 .dimensions = {1}, 226 .numberOfConsumers = 1, 227 .scale = 0.0f, 228 .zeroPoint = 0, 229 .lifetime = OperandLifeTime::MODEL_INPUT, 230 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 231 }, 232 { 233 .type = OperandType::TENSOR_INT32, 234 .dimensions = {1}, 235 .numberOfConsumers = 1, 236 .scale = 0.0f, 237 .zeroPoint = 0, 238 .lifetime = OperandLifeTime::MODEL_INPUT, 239 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 240 }, 241 { 242 .type = OperandType::TENSOR_FLOAT32, 243 .dimensions = {0}, 244 .numberOfConsumers = 0, 245 .scale = 0.0f, 246 .zeroPoint = 0, 247 .lifetime = OperandLifeTime::MODEL_OUTPUT, 248 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 249 } 250 }; 251 252 const std::vector<Operation> operations = { 253 { 254 .type = OperationType::SLICE, 255 .inputs = {0, 1, 2}, 256 .outputs = {3}, 257 } 258 }; 259 260 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 261 const std::vector<uint32_t> outputIndexes = {3}; 262 std::vector<uint8_t> operandValues = {}; 263 const std::vector<hidl_memory> pools = {}; 264 265 return { 266 .operands = operands, 267 .operations = operations, 268 .inputIndexes = inputIndexes, 269 .outputIndexes = outputIndexes, 270 .operandValues = operandValues, 271 .pools = pools, 272 }; 273 } 274 275 inline bool is_ignored_dynamic_output_shape(int i) { 276 static std::set<int> ignore = {}; 277 return ignore.find(i) != ignore.end(); 278 } 279 280 // Create the model 281 Model createTestModel_dynamic_output_shape_relaxed() { 282 const std::vector<Operand> operands = { 283 { 284 .type = OperandType::TENSOR_FLOAT32, 285 .dimensions = {4}, 286 .numberOfConsumers = 1, 287 .scale = 0.0f, 288 .zeroPoint = 0, 289 .lifetime = OperandLifeTime::MODEL_INPUT, 290 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 291 }, 292 { 293 .type = OperandType::TENSOR_INT32, 294 .dimensions = {1}, 295 .numberOfConsumers = 1, 296 .scale = 0.0f, 297 .zeroPoint = 0, 298 .lifetime = OperandLifeTime::MODEL_INPUT, 299 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 300 }, 301 { 302 .type = OperandType::TENSOR_INT32, 303 .dimensions = {1}, 304 .numberOfConsumers = 1, 305 .scale = 0.0f, 306 .zeroPoint = 0, 307 .lifetime = OperandLifeTime::MODEL_INPUT, 308 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 309 }, 310 { 311 .type = OperandType::TENSOR_FLOAT32, 312 .dimensions = {0}, 313 .numberOfConsumers = 0, 314 .scale = 0.0f, 315 .zeroPoint = 0, 316 .lifetime = OperandLifeTime::MODEL_OUTPUT, 317 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 318 } 319 }; 320 321 const std::vector<Operation> operations = { 322 { 323 .type = OperationType::SLICE, 324 .inputs = {0, 1, 2}, 325 .outputs = {3}, 326 } 327 }; 328 329 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 330 const std::vector<uint32_t> outputIndexes = {3}; 331 std::vector<uint8_t> operandValues = {}; 332 const std::vector<hidl_memory> pools = {}; 333 334 return { 335 .operands = operands, 336 .operations = operations, 337 .inputIndexes = inputIndexes, 338 .outputIndexes = outputIndexes, 339 .operandValues = operandValues, 340 .pools = pools, 341 .relaxComputationFloat32toFloat16 = true, 342 }; 343 } 344 345 inline bool is_ignored_dynamic_output_shape_relaxed(int i) { 346 static std::set<int> ignore = {}; 347 return ignore.find(i) != ignore.end(); 348 } 349 350 // Create the model 351 Model createTestModel_dynamic_output_shape_float16() { 352 const std::vector<Operand> operands = { 353 { 354 .type = OperandType::TENSOR_FLOAT16, 355 .dimensions = {4}, 356 .numberOfConsumers = 1, 357 .scale = 0.0f, 358 .zeroPoint = 0, 359 .lifetime = OperandLifeTime::MODEL_INPUT, 360 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 361 }, 362 { 363 .type = OperandType::TENSOR_INT32, 364 .dimensions = {1}, 365 .numberOfConsumers = 1, 366 .scale = 0.0f, 367 .zeroPoint = 0, 368 .lifetime = OperandLifeTime::MODEL_INPUT, 369 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 370 }, 371 { 372 .type = OperandType::TENSOR_INT32, 373 .dimensions = {1}, 374 .numberOfConsumers = 1, 375 .scale = 0.0f, 376 .zeroPoint = 0, 377 .lifetime = OperandLifeTime::MODEL_INPUT, 378 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 379 }, 380 { 381 .type = OperandType::TENSOR_FLOAT16, 382 .dimensions = {0}, 383 .numberOfConsumers = 0, 384 .scale = 0.0f, 385 .zeroPoint = 0, 386 .lifetime = OperandLifeTime::MODEL_OUTPUT, 387 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 388 } 389 }; 390 391 const std::vector<Operation> operations = { 392 { 393 .type = OperationType::SLICE, 394 .inputs = {0, 1, 2}, 395 .outputs = {3}, 396 } 397 }; 398 399 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 400 const std::vector<uint32_t> outputIndexes = {3}; 401 std::vector<uint8_t> operandValues = {}; 402 const std::vector<hidl_memory> pools = {}; 403 404 return { 405 .operands = operands, 406 .operations = operations, 407 .inputIndexes = inputIndexes, 408 .outputIndexes = outputIndexes, 409 .operandValues = operandValues, 410 .pools = pools, 411 }; 412 } 413 414 inline bool is_ignored_dynamic_output_shape_float16(int i) { 415 static std::set<int> ignore = {}; 416 return ignore.find(i) != ignore.end(); 417 } 418 419 // Create the model 420 Model createTestModel_2() { 421 const std::vector<Operand> operands = { 422 { 423 .type = OperandType::TENSOR_FLOAT32, 424 .dimensions = {2, 3}, 425 .numberOfConsumers = 1, 426 .scale = 0.0f, 427 .zeroPoint = 0, 428 .lifetime = OperandLifeTime::MODEL_INPUT, 429 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 430 }, 431 { 432 .type = OperandType::TENSOR_INT32, 433 .dimensions = {2}, 434 .numberOfConsumers = 1, 435 .scale = 0.0f, 436 .zeroPoint = 0, 437 .lifetime = OperandLifeTime::MODEL_INPUT, 438 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 439 }, 440 { 441 .type = OperandType::TENSOR_INT32, 442 .dimensions = {2}, 443 .numberOfConsumers = 1, 444 .scale = 0.0f, 445 .zeroPoint = 0, 446 .lifetime = OperandLifeTime::MODEL_INPUT, 447 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 448 }, 449 { 450 .type = OperandType::TENSOR_FLOAT32, 451 .dimensions = {1, 2}, 452 .numberOfConsumers = 0, 453 .scale = 0.0f, 454 .zeroPoint = 0, 455 .lifetime = OperandLifeTime::MODEL_OUTPUT, 456 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 457 } 458 }; 459 460 const std::vector<Operation> operations = { 461 { 462 .type = OperationType::SLICE, 463 .inputs = {0, 1, 2}, 464 .outputs = {3}, 465 } 466 }; 467 468 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 469 const std::vector<uint32_t> outputIndexes = {3}; 470 std::vector<uint8_t> operandValues = {}; 471 const std::vector<hidl_memory> pools = {}; 472 473 return { 474 .operands = operands, 475 .operations = operations, 476 .inputIndexes = inputIndexes, 477 .outputIndexes = outputIndexes, 478 .operandValues = operandValues, 479 .pools = pools, 480 }; 481 } 482 483 inline bool is_ignored_2(int i) { 484 static std::set<int> ignore = {}; 485 return ignore.find(i) != ignore.end(); 486 } 487 488 // Create the model 489 Model createTestModel_relaxed_2() { 490 const std::vector<Operand> operands = { 491 { 492 .type = OperandType::TENSOR_FLOAT32, 493 .dimensions = {2, 3}, 494 .numberOfConsumers = 1, 495 .scale = 0.0f, 496 .zeroPoint = 0, 497 .lifetime = OperandLifeTime::MODEL_INPUT, 498 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 499 }, 500 { 501 .type = OperandType::TENSOR_INT32, 502 .dimensions = {2}, 503 .numberOfConsumers = 1, 504 .scale = 0.0f, 505 .zeroPoint = 0, 506 .lifetime = OperandLifeTime::MODEL_INPUT, 507 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 508 }, 509 { 510 .type = OperandType::TENSOR_INT32, 511 .dimensions = {2}, 512 .numberOfConsumers = 1, 513 .scale = 0.0f, 514 .zeroPoint = 0, 515 .lifetime = OperandLifeTime::MODEL_INPUT, 516 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 517 }, 518 { 519 .type = OperandType::TENSOR_FLOAT32, 520 .dimensions = {1, 2}, 521 .numberOfConsumers = 0, 522 .scale = 0.0f, 523 .zeroPoint = 0, 524 .lifetime = OperandLifeTime::MODEL_OUTPUT, 525 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 526 } 527 }; 528 529 const std::vector<Operation> operations = { 530 { 531 .type = OperationType::SLICE, 532 .inputs = {0, 1, 2}, 533 .outputs = {3}, 534 } 535 }; 536 537 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 538 const std::vector<uint32_t> outputIndexes = {3}; 539 std::vector<uint8_t> operandValues = {}; 540 const std::vector<hidl_memory> pools = {}; 541 542 return { 543 .operands = operands, 544 .operations = operations, 545 .inputIndexes = inputIndexes, 546 .outputIndexes = outputIndexes, 547 .operandValues = operandValues, 548 .pools = pools, 549 .relaxComputationFloat32toFloat16 = true, 550 }; 551 } 552 553 inline bool is_ignored_relaxed_2(int i) { 554 static std::set<int> ignore = {}; 555 return ignore.find(i) != ignore.end(); 556 } 557 558 // Create the model 559 Model createTestModel_float16_2() { 560 const std::vector<Operand> operands = { 561 { 562 .type = OperandType::TENSOR_FLOAT16, 563 .dimensions = {2, 3}, 564 .numberOfConsumers = 1, 565 .scale = 0.0f, 566 .zeroPoint = 0, 567 .lifetime = OperandLifeTime::MODEL_INPUT, 568 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 569 }, 570 { 571 .type = OperandType::TENSOR_INT32, 572 .dimensions = {2}, 573 .numberOfConsumers = 1, 574 .scale = 0.0f, 575 .zeroPoint = 0, 576 .lifetime = OperandLifeTime::MODEL_INPUT, 577 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 578 }, 579 { 580 .type = OperandType::TENSOR_INT32, 581 .dimensions = {2}, 582 .numberOfConsumers = 1, 583 .scale = 0.0f, 584 .zeroPoint = 0, 585 .lifetime = OperandLifeTime::MODEL_INPUT, 586 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 587 }, 588 { 589 .type = OperandType::TENSOR_FLOAT16, 590 .dimensions = {1, 2}, 591 .numberOfConsumers = 0, 592 .scale = 0.0f, 593 .zeroPoint = 0, 594 .lifetime = OperandLifeTime::MODEL_OUTPUT, 595 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 596 } 597 }; 598 599 const std::vector<Operation> operations = { 600 { 601 .type = OperationType::SLICE, 602 .inputs = {0, 1, 2}, 603 .outputs = {3}, 604 } 605 }; 606 607 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 608 const std::vector<uint32_t> outputIndexes = {3}; 609 std::vector<uint8_t> operandValues = {}; 610 const std::vector<hidl_memory> pools = {}; 611 612 return { 613 .operands = operands, 614 .operations = operations, 615 .inputIndexes = inputIndexes, 616 .outputIndexes = outputIndexes, 617 .operandValues = operandValues, 618 .pools = pools, 619 }; 620 } 621 622 inline bool is_ignored_float16_2(int i) { 623 static std::set<int> ignore = {}; 624 return ignore.find(i) != ignore.end(); 625 } 626 627 // Create the model 628 Model createTestModel_dynamic_output_shape_2() { 629 const std::vector<Operand> operands = { 630 { 631 .type = OperandType::TENSOR_FLOAT32, 632 .dimensions = {2, 3}, 633 .numberOfConsumers = 1, 634 .scale = 0.0f, 635 .zeroPoint = 0, 636 .lifetime = OperandLifeTime::MODEL_INPUT, 637 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 638 }, 639 { 640 .type = OperandType::TENSOR_INT32, 641 .dimensions = {2}, 642 .numberOfConsumers = 1, 643 .scale = 0.0f, 644 .zeroPoint = 0, 645 .lifetime = OperandLifeTime::MODEL_INPUT, 646 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 647 }, 648 { 649 .type = OperandType::TENSOR_INT32, 650 .dimensions = {2}, 651 .numberOfConsumers = 1, 652 .scale = 0.0f, 653 .zeroPoint = 0, 654 .lifetime = OperandLifeTime::MODEL_INPUT, 655 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 656 }, 657 { 658 .type = OperandType::TENSOR_FLOAT32, 659 .dimensions = {0, 0}, 660 .numberOfConsumers = 0, 661 .scale = 0.0f, 662 .zeroPoint = 0, 663 .lifetime = OperandLifeTime::MODEL_OUTPUT, 664 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 665 } 666 }; 667 668 const std::vector<Operation> operations = { 669 { 670 .type = OperationType::SLICE, 671 .inputs = {0, 1, 2}, 672 .outputs = {3}, 673 } 674 }; 675 676 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 677 const std::vector<uint32_t> outputIndexes = {3}; 678 std::vector<uint8_t> operandValues = {}; 679 const std::vector<hidl_memory> pools = {}; 680 681 return { 682 .operands = operands, 683 .operations = operations, 684 .inputIndexes = inputIndexes, 685 .outputIndexes = outputIndexes, 686 .operandValues = operandValues, 687 .pools = pools, 688 }; 689 } 690 691 inline bool is_ignored_dynamic_output_shape_2(int i) { 692 static std::set<int> ignore = {}; 693 return ignore.find(i) != ignore.end(); 694 } 695 696 // Create the model 697 Model createTestModel_dynamic_output_shape_relaxed_2() { 698 const std::vector<Operand> operands = { 699 { 700 .type = OperandType::TENSOR_FLOAT32, 701 .dimensions = {2, 3}, 702 .numberOfConsumers = 1, 703 .scale = 0.0f, 704 .zeroPoint = 0, 705 .lifetime = OperandLifeTime::MODEL_INPUT, 706 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 707 }, 708 { 709 .type = OperandType::TENSOR_INT32, 710 .dimensions = {2}, 711 .numberOfConsumers = 1, 712 .scale = 0.0f, 713 .zeroPoint = 0, 714 .lifetime = OperandLifeTime::MODEL_INPUT, 715 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 716 }, 717 { 718 .type = OperandType::TENSOR_INT32, 719 .dimensions = {2}, 720 .numberOfConsumers = 1, 721 .scale = 0.0f, 722 .zeroPoint = 0, 723 .lifetime = OperandLifeTime::MODEL_INPUT, 724 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 725 }, 726 { 727 .type = OperandType::TENSOR_FLOAT32, 728 .dimensions = {0, 0}, 729 .numberOfConsumers = 0, 730 .scale = 0.0f, 731 .zeroPoint = 0, 732 .lifetime = OperandLifeTime::MODEL_OUTPUT, 733 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 734 } 735 }; 736 737 const std::vector<Operation> operations = { 738 { 739 .type = OperationType::SLICE, 740 .inputs = {0, 1, 2}, 741 .outputs = {3}, 742 } 743 }; 744 745 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 746 const std::vector<uint32_t> outputIndexes = {3}; 747 std::vector<uint8_t> operandValues = {}; 748 const std::vector<hidl_memory> pools = {}; 749 750 return { 751 .operands = operands, 752 .operations = operations, 753 .inputIndexes = inputIndexes, 754 .outputIndexes = outputIndexes, 755 .operandValues = operandValues, 756 .pools = pools, 757 .relaxComputationFloat32toFloat16 = true, 758 }; 759 } 760 761 inline bool is_ignored_dynamic_output_shape_relaxed_2(int i) { 762 static std::set<int> ignore = {}; 763 return ignore.find(i) != ignore.end(); 764 } 765 766 // Create the model 767 Model createTestModel_dynamic_output_shape_float16_2() { 768 const std::vector<Operand> operands = { 769 { 770 .type = OperandType::TENSOR_FLOAT16, 771 .dimensions = {2, 3}, 772 .numberOfConsumers = 1, 773 .scale = 0.0f, 774 .zeroPoint = 0, 775 .lifetime = OperandLifeTime::MODEL_INPUT, 776 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 777 }, 778 { 779 .type = OperandType::TENSOR_INT32, 780 .dimensions = {2}, 781 .numberOfConsumers = 1, 782 .scale = 0.0f, 783 .zeroPoint = 0, 784 .lifetime = OperandLifeTime::MODEL_INPUT, 785 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 786 }, 787 { 788 .type = OperandType::TENSOR_INT32, 789 .dimensions = {2}, 790 .numberOfConsumers = 1, 791 .scale = 0.0f, 792 .zeroPoint = 0, 793 .lifetime = OperandLifeTime::MODEL_INPUT, 794 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 795 }, 796 { 797 .type = OperandType::TENSOR_FLOAT16, 798 .dimensions = {0, 0}, 799 .numberOfConsumers = 0, 800 .scale = 0.0f, 801 .zeroPoint = 0, 802 .lifetime = OperandLifeTime::MODEL_OUTPUT, 803 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 804 } 805 }; 806 807 const std::vector<Operation> operations = { 808 { 809 .type = OperationType::SLICE, 810 .inputs = {0, 1, 2}, 811 .outputs = {3}, 812 } 813 }; 814 815 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 816 const std::vector<uint32_t> outputIndexes = {3}; 817 std::vector<uint8_t> operandValues = {}; 818 const std::vector<hidl_memory> pools = {}; 819 820 return { 821 .operands = operands, 822 .operations = operations, 823 .inputIndexes = inputIndexes, 824 .outputIndexes = outputIndexes, 825 .operandValues = operandValues, 826 .pools = pools, 827 }; 828 } 829 830 inline bool is_ignored_dynamic_output_shape_float16_2(int i) { 831 static std::set<int> ignore = {}; 832 return ignore.find(i) != ignore.end(); 833 } 834 835 // Create the model 836 Model createTestModel_3() { 837 const std::vector<Operand> operands = { 838 { 839 .type = OperandType::TENSOR_FLOAT32, 840 .dimensions = {2, 3, 2}, 841 .numberOfConsumers = 1, 842 .scale = 0.0f, 843 .zeroPoint = 0, 844 .lifetime = OperandLifeTime::MODEL_INPUT, 845 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 846 }, 847 { 848 .type = OperandType::TENSOR_INT32, 849 .dimensions = {3}, 850 .numberOfConsumers = 1, 851 .scale = 0.0f, 852 .zeroPoint = 0, 853 .lifetime = OperandLifeTime::MODEL_INPUT, 854 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 855 }, 856 { 857 .type = OperandType::TENSOR_INT32, 858 .dimensions = {3}, 859 .numberOfConsumers = 1, 860 .scale = 0.0f, 861 .zeroPoint = 0, 862 .lifetime = OperandLifeTime::MODEL_INPUT, 863 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 864 }, 865 { 866 .type = OperandType::TENSOR_FLOAT32, 867 .dimensions = {2, 3, 2}, 868 .numberOfConsumers = 0, 869 .scale = 0.0f, 870 .zeroPoint = 0, 871 .lifetime = OperandLifeTime::MODEL_OUTPUT, 872 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 873 } 874 }; 875 876 const std::vector<Operation> operations = { 877 { 878 .type = OperationType::SLICE, 879 .inputs = {0, 1, 2}, 880 .outputs = {3}, 881 } 882 }; 883 884 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 885 const std::vector<uint32_t> outputIndexes = {3}; 886 std::vector<uint8_t> operandValues = {}; 887 const std::vector<hidl_memory> pools = {}; 888 889 return { 890 .operands = operands, 891 .operations = operations, 892 .inputIndexes = inputIndexes, 893 .outputIndexes = outputIndexes, 894 .operandValues = operandValues, 895 .pools = pools, 896 }; 897 } 898 899 inline bool is_ignored_3(int i) { 900 static std::set<int> ignore = {}; 901 return ignore.find(i) != ignore.end(); 902 } 903 904 // Create the model 905 Model createTestModel_relaxed_3() { 906 const std::vector<Operand> operands = { 907 { 908 .type = OperandType::TENSOR_FLOAT32, 909 .dimensions = {2, 3, 2}, 910 .numberOfConsumers = 1, 911 .scale = 0.0f, 912 .zeroPoint = 0, 913 .lifetime = OperandLifeTime::MODEL_INPUT, 914 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 915 }, 916 { 917 .type = OperandType::TENSOR_INT32, 918 .dimensions = {3}, 919 .numberOfConsumers = 1, 920 .scale = 0.0f, 921 .zeroPoint = 0, 922 .lifetime = OperandLifeTime::MODEL_INPUT, 923 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 924 }, 925 { 926 .type = OperandType::TENSOR_INT32, 927 .dimensions = {3}, 928 .numberOfConsumers = 1, 929 .scale = 0.0f, 930 .zeroPoint = 0, 931 .lifetime = OperandLifeTime::MODEL_INPUT, 932 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 933 }, 934 { 935 .type = OperandType::TENSOR_FLOAT32, 936 .dimensions = {2, 3, 2}, 937 .numberOfConsumers = 0, 938 .scale = 0.0f, 939 .zeroPoint = 0, 940 .lifetime = OperandLifeTime::MODEL_OUTPUT, 941 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 942 } 943 }; 944 945 const std::vector<Operation> operations = { 946 { 947 .type = OperationType::SLICE, 948 .inputs = {0, 1, 2}, 949 .outputs = {3}, 950 } 951 }; 952 953 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 954 const std::vector<uint32_t> outputIndexes = {3}; 955 std::vector<uint8_t> operandValues = {}; 956 const std::vector<hidl_memory> pools = {}; 957 958 return { 959 .operands = operands, 960 .operations = operations, 961 .inputIndexes = inputIndexes, 962 .outputIndexes = outputIndexes, 963 .operandValues = operandValues, 964 .pools = pools, 965 .relaxComputationFloat32toFloat16 = true, 966 }; 967 } 968 969 inline bool is_ignored_relaxed_3(int i) { 970 static std::set<int> ignore = {}; 971 return ignore.find(i) != ignore.end(); 972 } 973 974 // Create the model 975 Model createTestModel_float16_3() { 976 const std::vector<Operand> operands = { 977 { 978 .type = OperandType::TENSOR_FLOAT16, 979 .dimensions = {2, 3, 2}, 980 .numberOfConsumers = 1, 981 .scale = 0.0f, 982 .zeroPoint = 0, 983 .lifetime = OperandLifeTime::MODEL_INPUT, 984 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 985 }, 986 { 987 .type = OperandType::TENSOR_INT32, 988 .dimensions = {3}, 989 .numberOfConsumers = 1, 990 .scale = 0.0f, 991 .zeroPoint = 0, 992 .lifetime = OperandLifeTime::MODEL_INPUT, 993 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 994 }, 995 { 996 .type = OperandType::TENSOR_INT32, 997 .dimensions = {3}, 998 .numberOfConsumers = 1, 999 .scale = 0.0f, 1000 .zeroPoint = 0, 1001 .lifetime = OperandLifeTime::MODEL_INPUT, 1002 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1003 }, 1004 { 1005 .type = OperandType::TENSOR_FLOAT16, 1006 .dimensions = {2, 3, 2}, 1007 .numberOfConsumers = 0, 1008 .scale = 0.0f, 1009 .zeroPoint = 0, 1010 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1011 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1012 } 1013 }; 1014 1015 const std::vector<Operation> operations = { 1016 { 1017 .type = OperationType::SLICE, 1018 .inputs = {0, 1, 2}, 1019 .outputs = {3}, 1020 } 1021 }; 1022 1023 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1024 const std::vector<uint32_t> outputIndexes = {3}; 1025 std::vector<uint8_t> operandValues = {}; 1026 const std::vector<hidl_memory> pools = {}; 1027 1028 return { 1029 .operands = operands, 1030 .operations = operations, 1031 .inputIndexes = inputIndexes, 1032 .outputIndexes = outputIndexes, 1033 .operandValues = operandValues, 1034 .pools = pools, 1035 }; 1036 } 1037 1038 inline bool is_ignored_float16_3(int i) { 1039 static std::set<int> ignore = {}; 1040 return ignore.find(i) != ignore.end(); 1041 } 1042 1043 // Create the model 1044 Model createTestModel_dynamic_output_shape_3() { 1045 const std::vector<Operand> operands = { 1046 { 1047 .type = OperandType::TENSOR_FLOAT32, 1048 .dimensions = {2, 3, 2}, 1049 .numberOfConsumers = 1, 1050 .scale = 0.0f, 1051 .zeroPoint = 0, 1052 .lifetime = OperandLifeTime::MODEL_INPUT, 1053 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1054 }, 1055 { 1056 .type = OperandType::TENSOR_INT32, 1057 .dimensions = {3}, 1058 .numberOfConsumers = 1, 1059 .scale = 0.0f, 1060 .zeroPoint = 0, 1061 .lifetime = OperandLifeTime::MODEL_INPUT, 1062 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1063 }, 1064 { 1065 .type = OperandType::TENSOR_INT32, 1066 .dimensions = {3}, 1067 .numberOfConsumers = 1, 1068 .scale = 0.0f, 1069 .zeroPoint = 0, 1070 .lifetime = OperandLifeTime::MODEL_INPUT, 1071 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1072 }, 1073 { 1074 .type = OperandType::TENSOR_FLOAT32, 1075 .dimensions = {0, 0, 0}, 1076 .numberOfConsumers = 0, 1077 .scale = 0.0f, 1078 .zeroPoint = 0, 1079 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1080 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1081 } 1082 }; 1083 1084 const std::vector<Operation> operations = { 1085 { 1086 .type = OperationType::SLICE, 1087 .inputs = {0, 1, 2}, 1088 .outputs = {3}, 1089 } 1090 }; 1091 1092 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1093 const std::vector<uint32_t> outputIndexes = {3}; 1094 std::vector<uint8_t> operandValues = {}; 1095 const std::vector<hidl_memory> pools = {}; 1096 1097 return { 1098 .operands = operands, 1099 .operations = operations, 1100 .inputIndexes = inputIndexes, 1101 .outputIndexes = outputIndexes, 1102 .operandValues = operandValues, 1103 .pools = pools, 1104 }; 1105 } 1106 1107 inline bool is_ignored_dynamic_output_shape_3(int i) { 1108 static std::set<int> ignore = {}; 1109 return ignore.find(i) != ignore.end(); 1110 } 1111 1112 // Create the model 1113 Model createTestModel_dynamic_output_shape_relaxed_3() { 1114 const std::vector<Operand> operands = { 1115 { 1116 .type = OperandType::TENSOR_FLOAT32, 1117 .dimensions = {2, 3, 2}, 1118 .numberOfConsumers = 1, 1119 .scale = 0.0f, 1120 .zeroPoint = 0, 1121 .lifetime = OperandLifeTime::MODEL_INPUT, 1122 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1123 }, 1124 { 1125 .type = OperandType::TENSOR_INT32, 1126 .dimensions = {3}, 1127 .numberOfConsumers = 1, 1128 .scale = 0.0f, 1129 .zeroPoint = 0, 1130 .lifetime = OperandLifeTime::MODEL_INPUT, 1131 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1132 }, 1133 { 1134 .type = OperandType::TENSOR_INT32, 1135 .dimensions = {3}, 1136 .numberOfConsumers = 1, 1137 .scale = 0.0f, 1138 .zeroPoint = 0, 1139 .lifetime = OperandLifeTime::MODEL_INPUT, 1140 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1141 }, 1142 { 1143 .type = OperandType::TENSOR_FLOAT32, 1144 .dimensions = {0, 0, 0}, 1145 .numberOfConsumers = 0, 1146 .scale = 0.0f, 1147 .zeroPoint = 0, 1148 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1149 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1150 } 1151 }; 1152 1153 const std::vector<Operation> operations = { 1154 { 1155 .type = OperationType::SLICE, 1156 .inputs = {0, 1, 2}, 1157 .outputs = {3}, 1158 } 1159 }; 1160 1161 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1162 const std::vector<uint32_t> outputIndexes = {3}; 1163 std::vector<uint8_t> operandValues = {}; 1164 const std::vector<hidl_memory> pools = {}; 1165 1166 return { 1167 .operands = operands, 1168 .operations = operations, 1169 .inputIndexes = inputIndexes, 1170 .outputIndexes = outputIndexes, 1171 .operandValues = operandValues, 1172 .pools = pools, 1173 .relaxComputationFloat32toFloat16 = true, 1174 }; 1175 } 1176 1177 inline bool is_ignored_dynamic_output_shape_relaxed_3(int i) { 1178 static std::set<int> ignore = {}; 1179 return ignore.find(i) != ignore.end(); 1180 } 1181 1182 // Create the model 1183 Model createTestModel_dynamic_output_shape_float16_3() { 1184 const std::vector<Operand> operands = { 1185 { 1186 .type = OperandType::TENSOR_FLOAT16, 1187 .dimensions = {2, 3, 2}, 1188 .numberOfConsumers = 1, 1189 .scale = 0.0f, 1190 .zeroPoint = 0, 1191 .lifetime = OperandLifeTime::MODEL_INPUT, 1192 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1193 }, 1194 { 1195 .type = OperandType::TENSOR_INT32, 1196 .dimensions = {3}, 1197 .numberOfConsumers = 1, 1198 .scale = 0.0f, 1199 .zeroPoint = 0, 1200 .lifetime = OperandLifeTime::MODEL_INPUT, 1201 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1202 }, 1203 { 1204 .type = OperandType::TENSOR_INT32, 1205 .dimensions = {3}, 1206 .numberOfConsumers = 1, 1207 .scale = 0.0f, 1208 .zeroPoint = 0, 1209 .lifetime = OperandLifeTime::MODEL_INPUT, 1210 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1211 }, 1212 { 1213 .type = OperandType::TENSOR_FLOAT16, 1214 .dimensions = {0, 0, 0}, 1215 .numberOfConsumers = 0, 1216 .scale = 0.0f, 1217 .zeroPoint = 0, 1218 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1219 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1220 } 1221 }; 1222 1223 const std::vector<Operation> operations = { 1224 { 1225 .type = OperationType::SLICE, 1226 .inputs = {0, 1, 2}, 1227 .outputs = {3}, 1228 } 1229 }; 1230 1231 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1232 const std::vector<uint32_t> outputIndexes = {3}; 1233 std::vector<uint8_t> operandValues = {}; 1234 const std::vector<hidl_memory> pools = {}; 1235 1236 return { 1237 .operands = operands, 1238 .operations = operations, 1239 .inputIndexes = inputIndexes, 1240 .outputIndexes = outputIndexes, 1241 .operandValues = operandValues, 1242 .pools = pools, 1243 }; 1244 } 1245 1246 inline bool is_ignored_dynamic_output_shape_float16_3(int i) { 1247 static std::set<int> ignore = {}; 1248 return ignore.find(i) != ignore.end(); 1249 } 1250 1251 // Create the model 1252 Model createTestModel_4() { 1253 const std::vector<Operand> operands = { 1254 { 1255 .type = OperandType::TENSOR_FLOAT32, 1256 .dimensions = {4, 1, 1, 1}, 1257 .numberOfConsumers = 1, 1258 .scale = 0.0f, 1259 .zeroPoint = 0, 1260 .lifetime = OperandLifeTime::MODEL_INPUT, 1261 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1262 }, 1263 { 1264 .type = OperandType::TENSOR_INT32, 1265 .dimensions = {4}, 1266 .numberOfConsumers = 1, 1267 .scale = 0.0f, 1268 .zeroPoint = 0, 1269 .lifetime = OperandLifeTime::MODEL_INPUT, 1270 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1271 }, 1272 { 1273 .type = OperandType::TENSOR_INT32, 1274 .dimensions = {4}, 1275 .numberOfConsumers = 1, 1276 .scale = 0.0f, 1277 .zeroPoint = 0, 1278 .lifetime = OperandLifeTime::MODEL_INPUT, 1279 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1280 }, 1281 { 1282 .type = OperandType::TENSOR_FLOAT32, 1283 .dimensions = {3, 1, 1, 1}, 1284 .numberOfConsumers = 0, 1285 .scale = 0.0f, 1286 .zeroPoint = 0, 1287 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1288 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1289 } 1290 }; 1291 1292 const std::vector<Operation> operations = { 1293 { 1294 .type = OperationType::SLICE, 1295 .inputs = {0, 1, 2}, 1296 .outputs = {3}, 1297 } 1298 }; 1299 1300 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1301 const std::vector<uint32_t> outputIndexes = {3}; 1302 std::vector<uint8_t> operandValues = {}; 1303 const std::vector<hidl_memory> pools = {}; 1304 1305 return { 1306 .operands = operands, 1307 .operations = operations, 1308 .inputIndexes = inputIndexes, 1309 .outputIndexes = outputIndexes, 1310 .operandValues = operandValues, 1311 .pools = pools, 1312 }; 1313 } 1314 1315 inline bool is_ignored_4(int i) { 1316 static std::set<int> ignore = {}; 1317 return ignore.find(i) != ignore.end(); 1318 } 1319 1320 // Create the model 1321 Model createTestModel_relaxed_4() { 1322 const std::vector<Operand> operands = { 1323 { 1324 .type = OperandType::TENSOR_FLOAT32, 1325 .dimensions = {4, 1, 1, 1}, 1326 .numberOfConsumers = 1, 1327 .scale = 0.0f, 1328 .zeroPoint = 0, 1329 .lifetime = OperandLifeTime::MODEL_INPUT, 1330 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1331 }, 1332 { 1333 .type = OperandType::TENSOR_INT32, 1334 .dimensions = {4}, 1335 .numberOfConsumers = 1, 1336 .scale = 0.0f, 1337 .zeroPoint = 0, 1338 .lifetime = OperandLifeTime::MODEL_INPUT, 1339 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1340 }, 1341 { 1342 .type = OperandType::TENSOR_INT32, 1343 .dimensions = {4}, 1344 .numberOfConsumers = 1, 1345 .scale = 0.0f, 1346 .zeroPoint = 0, 1347 .lifetime = OperandLifeTime::MODEL_INPUT, 1348 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1349 }, 1350 { 1351 .type = OperandType::TENSOR_FLOAT32, 1352 .dimensions = {3, 1, 1, 1}, 1353 .numberOfConsumers = 0, 1354 .scale = 0.0f, 1355 .zeroPoint = 0, 1356 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1357 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1358 } 1359 }; 1360 1361 const std::vector<Operation> operations = { 1362 { 1363 .type = OperationType::SLICE, 1364 .inputs = {0, 1, 2}, 1365 .outputs = {3}, 1366 } 1367 }; 1368 1369 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1370 const std::vector<uint32_t> outputIndexes = {3}; 1371 std::vector<uint8_t> operandValues = {}; 1372 const std::vector<hidl_memory> pools = {}; 1373 1374 return { 1375 .operands = operands, 1376 .operations = operations, 1377 .inputIndexes = inputIndexes, 1378 .outputIndexes = outputIndexes, 1379 .operandValues = operandValues, 1380 .pools = pools, 1381 .relaxComputationFloat32toFloat16 = true, 1382 }; 1383 } 1384 1385 inline bool is_ignored_relaxed_4(int i) { 1386 static std::set<int> ignore = {}; 1387 return ignore.find(i) != ignore.end(); 1388 } 1389 1390 // Create the model 1391 Model createTestModel_float16_4() { 1392 const std::vector<Operand> operands = { 1393 { 1394 .type = OperandType::TENSOR_FLOAT16, 1395 .dimensions = {4, 1, 1, 1}, 1396 .numberOfConsumers = 1, 1397 .scale = 0.0f, 1398 .zeroPoint = 0, 1399 .lifetime = OperandLifeTime::MODEL_INPUT, 1400 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1401 }, 1402 { 1403 .type = OperandType::TENSOR_INT32, 1404 .dimensions = {4}, 1405 .numberOfConsumers = 1, 1406 .scale = 0.0f, 1407 .zeroPoint = 0, 1408 .lifetime = OperandLifeTime::MODEL_INPUT, 1409 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1410 }, 1411 { 1412 .type = OperandType::TENSOR_INT32, 1413 .dimensions = {4}, 1414 .numberOfConsumers = 1, 1415 .scale = 0.0f, 1416 .zeroPoint = 0, 1417 .lifetime = OperandLifeTime::MODEL_INPUT, 1418 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1419 }, 1420 { 1421 .type = OperandType::TENSOR_FLOAT16, 1422 .dimensions = {3, 1, 1, 1}, 1423 .numberOfConsumers = 0, 1424 .scale = 0.0f, 1425 .zeroPoint = 0, 1426 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1427 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1428 } 1429 }; 1430 1431 const std::vector<Operation> operations = { 1432 { 1433 .type = OperationType::SLICE, 1434 .inputs = {0, 1, 2}, 1435 .outputs = {3}, 1436 } 1437 }; 1438 1439 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1440 const std::vector<uint32_t> outputIndexes = {3}; 1441 std::vector<uint8_t> operandValues = {}; 1442 const std::vector<hidl_memory> pools = {}; 1443 1444 return { 1445 .operands = operands, 1446 .operations = operations, 1447 .inputIndexes = inputIndexes, 1448 .outputIndexes = outputIndexes, 1449 .operandValues = operandValues, 1450 .pools = pools, 1451 }; 1452 } 1453 1454 inline bool is_ignored_float16_4(int i) { 1455 static std::set<int> ignore = {}; 1456 return ignore.find(i) != ignore.end(); 1457 } 1458 1459 // Create the model 1460 Model createTestModel_dynamic_output_shape_4() { 1461 const std::vector<Operand> operands = { 1462 { 1463 .type = OperandType::TENSOR_FLOAT32, 1464 .dimensions = {4, 1, 1, 1}, 1465 .numberOfConsumers = 1, 1466 .scale = 0.0f, 1467 .zeroPoint = 0, 1468 .lifetime = OperandLifeTime::MODEL_INPUT, 1469 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1470 }, 1471 { 1472 .type = OperandType::TENSOR_INT32, 1473 .dimensions = {4}, 1474 .numberOfConsumers = 1, 1475 .scale = 0.0f, 1476 .zeroPoint = 0, 1477 .lifetime = OperandLifeTime::MODEL_INPUT, 1478 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1479 }, 1480 { 1481 .type = OperandType::TENSOR_INT32, 1482 .dimensions = {4}, 1483 .numberOfConsumers = 1, 1484 .scale = 0.0f, 1485 .zeroPoint = 0, 1486 .lifetime = OperandLifeTime::MODEL_INPUT, 1487 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1488 }, 1489 { 1490 .type = OperandType::TENSOR_FLOAT32, 1491 .dimensions = {0, 0, 0, 0}, 1492 .numberOfConsumers = 0, 1493 .scale = 0.0f, 1494 .zeroPoint = 0, 1495 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1496 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1497 } 1498 }; 1499 1500 const std::vector<Operation> operations = { 1501 { 1502 .type = OperationType::SLICE, 1503 .inputs = {0, 1, 2}, 1504 .outputs = {3}, 1505 } 1506 }; 1507 1508 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1509 const std::vector<uint32_t> outputIndexes = {3}; 1510 std::vector<uint8_t> operandValues = {}; 1511 const std::vector<hidl_memory> pools = {}; 1512 1513 return { 1514 .operands = operands, 1515 .operations = operations, 1516 .inputIndexes = inputIndexes, 1517 .outputIndexes = outputIndexes, 1518 .operandValues = operandValues, 1519 .pools = pools, 1520 }; 1521 } 1522 1523 inline bool is_ignored_dynamic_output_shape_4(int i) { 1524 static std::set<int> ignore = {}; 1525 return ignore.find(i) != ignore.end(); 1526 } 1527 1528 // Create the model 1529 Model createTestModel_dynamic_output_shape_relaxed_4() { 1530 const std::vector<Operand> operands = { 1531 { 1532 .type = OperandType::TENSOR_FLOAT32, 1533 .dimensions = {4, 1, 1, 1}, 1534 .numberOfConsumers = 1, 1535 .scale = 0.0f, 1536 .zeroPoint = 0, 1537 .lifetime = OperandLifeTime::MODEL_INPUT, 1538 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1539 }, 1540 { 1541 .type = OperandType::TENSOR_INT32, 1542 .dimensions = {4}, 1543 .numberOfConsumers = 1, 1544 .scale = 0.0f, 1545 .zeroPoint = 0, 1546 .lifetime = OperandLifeTime::MODEL_INPUT, 1547 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1548 }, 1549 { 1550 .type = OperandType::TENSOR_INT32, 1551 .dimensions = {4}, 1552 .numberOfConsumers = 1, 1553 .scale = 0.0f, 1554 .zeroPoint = 0, 1555 .lifetime = OperandLifeTime::MODEL_INPUT, 1556 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1557 }, 1558 { 1559 .type = OperandType::TENSOR_FLOAT32, 1560 .dimensions = {0, 0, 0, 0}, 1561 .numberOfConsumers = 0, 1562 .scale = 0.0f, 1563 .zeroPoint = 0, 1564 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1565 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1566 } 1567 }; 1568 1569 const std::vector<Operation> operations = { 1570 { 1571 .type = OperationType::SLICE, 1572 .inputs = {0, 1, 2}, 1573 .outputs = {3}, 1574 } 1575 }; 1576 1577 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1578 const std::vector<uint32_t> outputIndexes = {3}; 1579 std::vector<uint8_t> operandValues = {}; 1580 const std::vector<hidl_memory> pools = {}; 1581 1582 return { 1583 .operands = operands, 1584 .operations = operations, 1585 .inputIndexes = inputIndexes, 1586 .outputIndexes = outputIndexes, 1587 .operandValues = operandValues, 1588 .pools = pools, 1589 .relaxComputationFloat32toFloat16 = true, 1590 }; 1591 } 1592 1593 inline bool is_ignored_dynamic_output_shape_relaxed_4(int i) { 1594 static std::set<int> ignore = {}; 1595 return ignore.find(i) != ignore.end(); 1596 } 1597 1598 // Create the model 1599 Model createTestModel_dynamic_output_shape_float16_4() { 1600 const std::vector<Operand> operands = { 1601 { 1602 .type = OperandType::TENSOR_FLOAT16, 1603 .dimensions = {4, 1, 1, 1}, 1604 .numberOfConsumers = 1, 1605 .scale = 0.0f, 1606 .zeroPoint = 0, 1607 .lifetime = OperandLifeTime::MODEL_INPUT, 1608 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1609 }, 1610 { 1611 .type = OperandType::TENSOR_INT32, 1612 .dimensions = {4}, 1613 .numberOfConsumers = 1, 1614 .scale = 0.0f, 1615 .zeroPoint = 0, 1616 .lifetime = OperandLifeTime::MODEL_INPUT, 1617 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1618 }, 1619 { 1620 .type = OperandType::TENSOR_INT32, 1621 .dimensions = {4}, 1622 .numberOfConsumers = 1, 1623 .scale = 0.0f, 1624 .zeroPoint = 0, 1625 .lifetime = OperandLifeTime::MODEL_INPUT, 1626 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1627 }, 1628 { 1629 .type = OperandType::TENSOR_FLOAT16, 1630 .dimensions = {0, 0, 0, 0}, 1631 .numberOfConsumers = 0, 1632 .scale = 0.0f, 1633 .zeroPoint = 0, 1634 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1635 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1636 } 1637 }; 1638 1639 const std::vector<Operation> operations = { 1640 { 1641 .type = OperationType::SLICE, 1642 .inputs = {0, 1, 2}, 1643 .outputs = {3}, 1644 } 1645 }; 1646 1647 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1648 const std::vector<uint32_t> outputIndexes = {3}; 1649 std::vector<uint8_t> operandValues = {}; 1650 const std::vector<hidl_memory> pools = {}; 1651 1652 return { 1653 .operands = operands, 1654 .operations = operations, 1655 .inputIndexes = inputIndexes, 1656 .outputIndexes = outputIndexes, 1657 .operandValues = operandValues, 1658 .pools = pools, 1659 }; 1660 } 1661 1662 inline bool is_ignored_dynamic_output_shape_float16_4(int i) { 1663 static std::set<int> ignore = {}; 1664 return ignore.find(i) != ignore.end(); 1665 } 1666 1667 // Create the model 1668 Model createTestModel_5() { 1669 const std::vector<Operand> operands = { 1670 { 1671 .type = OperandType::TENSOR_INT32, 1672 .dimensions = {3, 2, 3, 1}, 1673 .numberOfConsumers = 1, 1674 .scale = 0.0f, 1675 .zeroPoint = 0, 1676 .lifetime = OperandLifeTime::MODEL_INPUT, 1677 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1678 }, 1679 { 1680 .type = OperandType::TENSOR_INT32, 1681 .dimensions = {4}, 1682 .numberOfConsumers = 1, 1683 .scale = 0.0f, 1684 .zeroPoint = 0, 1685 .lifetime = OperandLifeTime::MODEL_INPUT, 1686 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1687 }, 1688 { 1689 .type = OperandType::TENSOR_INT32, 1690 .dimensions = {4}, 1691 .numberOfConsumers = 1, 1692 .scale = 0.0f, 1693 .zeroPoint = 0, 1694 .lifetime = OperandLifeTime::MODEL_INPUT, 1695 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1696 }, 1697 { 1698 .type = OperandType::TENSOR_INT32, 1699 .dimensions = {1, 1, 3, 1}, 1700 .numberOfConsumers = 0, 1701 .scale = 0.0f, 1702 .zeroPoint = 0, 1703 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1704 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1705 } 1706 }; 1707 1708 const std::vector<Operation> operations = { 1709 { 1710 .type = OperationType::SLICE, 1711 .inputs = {0, 1, 2}, 1712 .outputs = {3}, 1713 } 1714 }; 1715 1716 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1717 const std::vector<uint32_t> outputIndexes = {3}; 1718 std::vector<uint8_t> operandValues = {}; 1719 const std::vector<hidl_memory> pools = {}; 1720 1721 return { 1722 .operands = operands, 1723 .operations = operations, 1724 .inputIndexes = inputIndexes, 1725 .outputIndexes = outputIndexes, 1726 .operandValues = operandValues, 1727 .pools = pools, 1728 }; 1729 } 1730 1731 inline bool is_ignored_5(int i) { 1732 static std::set<int> ignore = {}; 1733 return ignore.find(i) != ignore.end(); 1734 } 1735 1736 // Create the model 1737 Model createTestModel_relaxed_5() { 1738 const std::vector<Operand> operands = { 1739 { 1740 .type = OperandType::TENSOR_INT32, 1741 .dimensions = {3, 2, 3, 1}, 1742 .numberOfConsumers = 1, 1743 .scale = 0.0f, 1744 .zeroPoint = 0, 1745 .lifetime = OperandLifeTime::MODEL_INPUT, 1746 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1747 }, 1748 { 1749 .type = OperandType::TENSOR_INT32, 1750 .dimensions = {4}, 1751 .numberOfConsumers = 1, 1752 .scale = 0.0f, 1753 .zeroPoint = 0, 1754 .lifetime = OperandLifeTime::MODEL_INPUT, 1755 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1756 }, 1757 { 1758 .type = OperandType::TENSOR_INT32, 1759 .dimensions = {4}, 1760 .numberOfConsumers = 1, 1761 .scale = 0.0f, 1762 .zeroPoint = 0, 1763 .lifetime = OperandLifeTime::MODEL_INPUT, 1764 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1765 }, 1766 { 1767 .type = OperandType::TENSOR_INT32, 1768 .dimensions = {1, 1, 3, 1}, 1769 .numberOfConsumers = 0, 1770 .scale = 0.0f, 1771 .zeroPoint = 0, 1772 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1773 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1774 } 1775 }; 1776 1777 const std::vector<Operation> operations = { 1778 { 1779 .type = OperationType::SLICE, 1780 .inputs = {0, 1, 2}, 1781 .outputs = {3}, 1782 } 1783 }; 1784 1785 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1786 const std::vector<uint32_t> outputIndexes = {3}; 1787 std::vector<uint8_t> operandValues = {}; 1788 const std::vector<hidl_memory> pools = {}; 1789 1790 return { 1791 .operands = operands, 1792 .operations = operations, 1793 .inputIndexes = inputIndexes, 1794 .outputIndexes = outputIndexes, 1795 .operandValues = operandValues, 1796 .pools = pools, 1797 .relaxComputationFloat32toFloat16 = true, 1798 }; 1799 } 1800 1801 inline bool is_ignored_relaxed_5(int i) { 1802 static std::set<int> ignore = {}; 1803 return ignore.find(i) != ignore.end(); 1804 } 1805 1806 // Create the model 1807 Model createTestModel_float16_5() { 1808 const std::vector<Operand> operands = { 1809 { 1810 .type = OperandType::TENSOR_INT32, 1811 .dimensions = {3, 2, 3, 1}, 1812 .numberOfConsumers = 1, 1813 .scale = 0.0f, 1814 .zeroPoint = 0, 1815 .lifetime = OperandLifeTime::MODEL_INPUT, 1816 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1817 }, 1818 { 1819 .type = OperandType::TENSOR_INT32, 1820 .dimensions = {4}, 1821 .numberOfConsumers = 1, 1822 .scale = 0.0f, 1823 .zeroPoint = 0, 1824 .lifetime = OperandLifeTime::MODEL_INPUT, 1825 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1826 }, 1827 { 1828 .type = OperandType::TENSOR_INT32, 1829 .dimensions = {4}, 1830 .numberOfConsumers = 1, 1831 .scale = 0.0f, 1832 .zeroPoint = 0, 1833 .lifetime = OperandLifeTime::MODEL_INPUT, 1834 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1835 }, 1836 { 1837 .type = OperandType::TENSOR_INT32, 1838 .dimensions = {1, 1, 3, 1}, 1839 .numberOfConsumers = 0, 1840 .scale = 0.0f, 1841 .zeroPoint = 0, 1842 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1843 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1844 } 1845 }; 1846 1847 const std::vector<Operation> operations = { 1848 { 1849 .type = OperationType::SLICE, 1850 .inputs = {0, 1, 2}, 1851 .outputs = {3}, 1852 } 1853 }; 1854 1855 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1856 const std::vector<uint32_t> outputIndexes = {3}; 1857 std::vector<uint8_t> operandValues = {}; 1858 const std::vector<hidl_memory> pools = {}; 1859 1860 return { 1861 .operands = operands, 1862 .operations = operations, 1863 .inputIndexes = inputIndexes, 1864 .outputIndexes = outputIndexes, 1865 .operandValues = operandValues, 1866 .pools = pools, 1867 }; 1868 } 1869 1870 inline bool is_ignored_float16_5(int i) { 1871 static std::set<int> ignore = {}; 1872 return ignore.find(i) != ignore.end(); 1873 } 1874 1875 // Create the model 1876 Model createTestModel_dynamic_output_shape_5() { 1877 const std::vector<Operand> operands = { 1878 { 1879 .type = OperandType::TENSOR_INT32, 1880 .dimensions = {3, 2, 3, 1}, 1881 .numberOfConsumers = 1, 1882 .scale = 0.0f, 1883 .zeroPoint = 0, 1884 .lifetime = OperandLifeTime::MODEL_INPUT, 1885 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1886 }, 1887 { 1888 .type = OperandType::TENSOR_INT32, 1889 .dimensions = {4}, 1890 .numberOfConsumers = 1, 1891 .scale = 0.0f, 1892 .zeroPoint = 0, 1893 .lifetime = OperandLifeTime::MODEL_INPUT, 1894 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1895 }, 1896 { 1897 .type = OperandType::TENSOR_INT32, 1898 .dimensions = {4}, 1899 .numberOfConsumers = 1, 1900 .scale = 0.0f, 1901 .zeroPoint = 0, 1902 .lifetime = OperandLifeTime::MODEL_INPUT, 1903 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1904 }, 1905 { 1906 .type = OperandType::TENSOR_INT32, 1907 .dimensions = {0, 0, 0, 0}, 1908 .numberOfConsumers = 0, 1909 .scale = 0.0f, 1910 .zeroPoint = 0, 1911 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1912 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1913 } 1914 }; 1915 1916 const std::vector<Operation> operations = { 1917 { 1918 .type = OperationType::SLICE, 1919 .inputs = {0, 1, 2}, 1920 .outputs = {3}, 1921 } 1922 }; 1923 1924 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1925 const std::vector<uint32_t> outputIndexes = {3}; 1926 std::vector<uint8_t> operandValues = {}; 1927 const std::vector<hidl_memory> pools = {}; 1928 1929 return { 1930 .operands = operands, 1931 .operations = operations, 1932 .inputIndexes = inputIndexes, 1933 .outputIndexes = outputIndexes, 1934 .operandValues = operandValues, 1935 .pools = pools, 1936 }; 1937 } 1938 1939 inline bool is_ignored_dynamic_output_shape_5(int i) { 1940 static std::set<int> ignore = {}; 1941 return ignore.find(i) != ignore.end(); 1942 } 1943 1944 // Create the model 1945 Model createTestModel_dynamic_output_shape_relaxed_5() { 1946 const std::vector<Operand> operands = { 1947 { 1948 .type = OperandType::TENSOR_INT32, 1949 .dimensions = {3, 2, 3, 1}, 1950 .numberOfConsumers = 1, 1951 .scale = 0.0f, 1952 .zeroPoint = 0, 1953 .lifetime = OperandLifeTime::MODEL_INPUT, 1954 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1955 }, 1956 { 1957 .type = OperandType::TENSOR_INT32, 1958 .dimensions = {4}, 1959 .numberOfConsumers = 1, 1960 .scale = 0.0f, 1961 .zeroPoint = 0, 1962 .lifetime = OperandLifeTime::MODEL_INPUT, 1963 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1964 }, 1965 { 1966 .type = OperandType::TENSOR_INT32, 1967 .dimensions = {4}, 1968 .numberOfConsumers = 1, 1969 .scale = 0.0f, 1970 .zeroPoint = 0, 1971 .lifetime = OperandLifeTime::MODEL_INPUT, 1972 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1973 }, 1974 { 1975 .type = OperandType::TENSOR_INT32, 1976 .dimensions = {0, 0, 0, 0}, 1977 .numberOfConsumers = 0, 1978 .scale = 0.0f, 1979 .zeroPoint = 0, 1980 .lifetime = OperandLifeTime::MODEL_OUTPUT, 1981 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 1982 } 1983 }; 1984 1985 const std::vector<Operation> operations = { 1986 { 1987 .type = OperationType::SLICE, 1988 .inputs = {0, 1, 2}, 1989 .outputs = {3}, 1990 } 1991 }; 1992 1993 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 1994 const std::vector<uint32_t> outputIndexes = {3}; 1995 std::vector<uint8_t> operandValues = {}; 1996 const std::vector<hidl_memory> pools = {}; 1997 1998 return { 1999 .operands = operands, 2000 .operations = operations, 2001 .inputIndexes = inputIndexes, 2002 .outputIndexes = outputIndexes, 2003 .operandValues = operandValues, 2004 .pools = pools, 2005 .relaxComputationFloat32toFloat16 = true, 2006 }; 2007 } 2008 2009 inline bool is_ignored_dynamic_output_shape_relaxed_5(int i) { 2010 static std::set<int> ignore = {}; 2011 return ignore.find(i) != ignore.end(); 2012 } 2013 2014 // Create the model 2015 Model createTestModel_dynamic_output_shape_float16_5() { 2016 const std::vector<Operand> operands = { 2017 { 2018 .type = OperandType::TENSOR_INT32, 2019 .dimensions = {3, 2, 3, 1}, 2020 .numberOfConsumers = 1, 2021 .scale = 0.0f, 2022 .zeroPoint = 0, 2023 .lifetime = OperandLifeTime::MODEL_INPUT, 2024 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2025 }, 2026 { 2027 .type = OperandType::TENSOR_INT32, 2028 .dimensions = {4}, 2029 .numberOfConsumers = 1, 2030 .scale = 0.0f, 2031 .zeroPoint = 0, 2032 .lifetime = OperandLifeTime::MODEL_INPUT, 2033 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2034 }, 2035 { 2036 .type = OperandType::TENSOR_INT32, 2037 .dimensions = {4}, 2038 .numberOfConsumers = 1, 2039 .scale = 0.0f, 2040 .zeroPoint = 0, 2041 .lifetime = OperandLifeTime::MODEL_INPUT, 2042 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2043 }, 2044 { 2045 .type = OperandType::TENSOR_INT32, 2046 .dimensions = {0, 0, 0, 0}, 2047 .numberOfConsumers = 0, 2048 .scale = 0.0f, 2049 .zeroPoint = 0, 2050 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2051 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2052 } 2053 }; 2054 2055 const std::vector<Operation> operations = { 2056 { 2057 .type = OperationType::SLICE, 2058 .inputs = {0, 1, 2}, 2059 .outputs = {3}, 2060 } 2061 }; 2062 2063 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2064 const std::vector<uint32_t> outputIndexes = {3}; 2065 std::vector<uint8_t> operandValues = {}; 2066 const std::vector<hidl_memory> pools = {}; 2067 2068 return { 2069 .operands = operands, 2070 .operations = operations, 2071 .inputIndexes = inputIndexes, 2072 .outputIndexes = outputIndexes, 2073 .operandValues = operandValues, 2074 .pools = pools, 2075 }; 2076 } 2077 2078 inline bool is_ignored_dynamic_output_shape_float16_5(int i) { 2079 static std::set<int> ignore = {}; 2080 return ignore.find(i) != ignore.end(); 2081 } 2082 2083 // Create the model 2084 Model createTestModel_6() { 2085 const std::vector<Operand> operands = { 2086 { 2087 .type = OperandType::TENSOR_INT32, 2088 .dimensions = {3, 2, 3, 1}, 2089 .numberOfConsumers = 1, 2090 .scale = 0.0f, 2091 .zeroPoint = 0, 2092 .lifetime = OperandLifeTime::MODEL_INPUT, 2093 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2094 }, 2095 { 2096 .type = OperandType::TENSOR_INT32, 2097 .dimensions = {4}, 2098 .numberOfConsumers = 1, 2099 .scale = 0.0f, 2100 .zeroPoint = 0, 2101 .lifetime = OperandLifeTime::MODEL_INPUT, 2102 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2103 }, 2104 { 2105 .type = OperandType::TENSOR_INT32, 2106 .dimensions = {4}, 2107 .numberOfConsumers = 1, 2108 .scale = 0.0f, 2109 .zeroPoint = 0, 2110 .lifetime = OperandLifeTime::MODEL_INPUT, 2111 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2112 }, 2113 { 2114 .type = OperandType::TENSOR_INT32, 2115 .dimensions = {2, 1, 3, 1}, 2116 .numberOfConsumers = 0, 2117 .scale = 0.0f, 2118 .zeroPoint = 0, 2119 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2120 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2121 } 2122 }; 2123 2124 const std::vector<Operation> operations = { 2125 { 2126 .type = OperationType::SLICE, 2127 .inputs = {0, 1, 2}, 2128 .outputs = {3}, 2129 } 2130 }; 2131 2132 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2133 const std::vector<uint32_t> outputIndexes = {3}; 2134 std::vector<uint8_t> operandValues = {}; 2135 const std::vector<hidl_memory> pools = {}; 2136 2137 return { 2138 .operands = operands, 2139 .operations = operations, 2140 .inputIndexes = inputIndexes, 2141 .outputIndexes = outputIndexes, 2142 .operandValues = operandValues, 2143 .pools = pools, 2144 }; 2145 } 2146 2147 inline bool is_ignored_6(int i) { 2148 static std::set<int> ignore = {}; 2149 return ignore.find(i) != ignore.end(); 2150 } 2151 2152 // Create the model 2153 Model createTestModel_relaxed_6() { 2154 const std::vector<Operand> operands = { 2155 { 2156 .type = OperandType::TENSOR_INT32, 2157 .dimensions = {3, 2, 3, 1}, 2158 .numberOfConsumers = 1, 2159 .scale = 0.0f, 2160 .zeroPoint = 0, 2161 .lifetime = OperandLifeTime::MODEL_INPUT, 2162 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2163 }, 2164 { 2165 .type = OperandType::TENSOR_INT32, 2166 .dimensions = {4}, 2167 .numberOfConsumers = 1, 2168 .scale = 0.0f, 2169 .zeroPoint = 0, 2170 .lifetime = OperandLifeTime::MODEL_INPUT, 2171 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2172 }, 2173 { 2174 .type = OperandType::TENSOR_INT32, 2175 .dimensions = {4}, 2176 .numberOfConsumers = 1, 2177 .scale = 0.0f, 2178 .zeroPoint = 0, 2179 .lifetime = OperandLifeTime::MODEL_INPUT, 2180 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2181 }, 2182 { 2183 .type = OperandType::TENSOR_INT32, 2184 .dimensions = {2, 1, 3, 1}, 2185 .numberOfConsumers = 0, 2186 .scale = 0.0f, 2187 .zeroPoint = 0, 2188 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2189 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2190 } 2191 }; 2192 2193 const std::vector<Operation> operations = { 2194 { 2195 .type = OperationType::SLICE, 2196 .inputs = {0, 1, 2}, 2197 .outputs = {3}, 2198 } 2199 }; 2200 2201 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2202 const std::vector<uint32_t> outputIndexes = {3}; 2203 std::vector<uint8_t> operandValues = {}; 2204 const std::vector<hidl_memory> pools = {}; 2205 2206 return { 2207 .operands = operands, 2208 .operations = operations, 2209 .inputIndexes = inputIndexes, 2210 .outputIndexes = outputIndexes, 2211 .operandValues = operandValues, 2212 .pools = pools, 2213 .relaxComputationFloat32toFloat16 = true, 2214 }; 2215 } 2216 2217 inline bool is_ignored_relaxed_6(int i) { 2218 static std::set<int> ignore = {}; 2219 return ignore.find(i) != ignore.end(); 2220 } 2221 2222 // Create the model 2223 Model createTestModel_float16_6() { 2224 const std::vector<Operand> operands = { 2225 { 2226 .type = OperandType::TENSOR_INT32, 2227 .dimensions = {3, 2, 3, 1}, 2228 .numberOfConsumers = 1, 2229 .scale = 0.0f, 2230 .zeroPoint = 0, 2231 .lifetime = OperandLifeTime::MODEL_INPUT, 2232 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2233 }, 2234 { 2235 .type = OperandType::TENSOR_INT32, 2236 .dimensions = {4}, 2237 .numberOfConsumers = 1, 2238 .scale = 0.0f, 2239 .zeroPoint = 0, 2240 .lifetime = OperandLifeTime::MODEL_INPUT, 2241 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2242 }, 2243 { 2244 .type = OperandType::TENSOR_INT32, 2245 .dimensions = {4}, 2246 .numberOfConsumers = 1, 2247 .scale = 0.0f, 2248 .zeroPoint = 0, 2249 .lifetime = OperandLifeTime::MODEL_INPUT, 2250 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2251 }, 2252 { 2253 .type = OperandType::TENSOR_INT32, 2254 .dimensions = {2, 1, 3, 1}, 2255 .numberOfConsumers = 0, 2256 .scale = 0.0f, 2257 .zeroPoint = 0, 2258 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2259 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2260 } 2261 }; 2262 2263 const std::vector<Operation> operations = { 2264 { 2265 .type = OperationType::SLICE, 2266 .inputs = {0, 1, 2}, 2267 .outputs = {3}, 2268 } 2269 }; 2270 2271 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2272 const std::vector<uint32_t> outputIndexes = {3}; 2273 std::vector<uint8_t> operandValues = {}; 2274 const std::vector<hidl_memory> pools = {}; 2275 2276 return { 2277 .operands = operands, 2278 .operations = operations, 2279 .inputIndexes = inputIndexes, 2280 .outputIndexes = outputIndexes, 2281 .operandValues = operandValues, 2282 .pools = pools, 2283 }; 2284 } 2285 2286 inline bool is_ignored_float16_6(int i) { 2287 static std::set<int> ignore = {}; 2288 return ignore.find(i) != ignore.end(); 2289 } 2290 2291 // Create the model 2292 Model createTestModel_dynamic_output_shape_6() { 2293 const std::vector<Operand> operands = { 2294 { 2295 .type = OperandType::TENSOR_INT32, 2296 .dimensions = {3, 2, 3, 1}, 2297 .numberOfConsumers = 1, 2298 .scale = 0.0f, 2299 .zeroPoint = 0, 2300 .lifetime = OperandLifeTime::MODEL_INPUT, 2301 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2302 }, 2303 { 2304 .type = OperandType::TENSOR_INT32, 2305 .dimensions = {4}, 2306 .numberOfConsumers = 1, 2307 .scale = 0.0f, 2308 .zeroPoint = 0, 2309 .lifetime = OperandLifeTime::MODEL_INPUT, 2310 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2311 }, 2312 { 2313 .type = OperandType::TENSOR_INT32, 2314 .dimensions = {4}, 2315 .numberOfConsumers = 1, 2316 .scale = 0.0f, 2317 .zeroPoint = 0, 2318 .lifetime = OperandLifeTime::MODEL_INPUT, 2319 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2320 }, 2321 { 2322 .type = OperandType::TENSOR_INT32, 2323 .dimensions = {0, 0, 0, 0}, 2324 .numberOfConsumers = 0, 2325 .scale = 0.0f, 2326 .zeroPoint = 0, 2327 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2328 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2329 } 2330 }; 2331 2332 const std::vector<Operation> operations = { 2333 { 2334 .type = OperationType::SLICE, 2335 .inputs = {0, 1, 2}, 2336 .outputs = {3}, 2337 } 2338 }; 2339 2340 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2341 const std::vector<uint32_t> outputIndexes = {3}; 2342 std::vector<uint8_t> operandValues = {}; 2343 const std::vector<hidl_memory> pools = {}; 2344 2345 return { 2346 .operands = operands, 2347 .operations = operations, 2348 .inputIndexes = inputIndexes, 2349 .outputIndexes = outputIndexes, 2350 .operandValues = operandValues, 2351 .pools = pools, 2352 }; 2353 } 2354 2355 inline bool is_ignored_dynamic_output_shape_6(int i) { 2356 static std::set<int> ignore = {}; 2357 return ignore.find(i) != ignore.end(); 2358 } 2359 2360 // Create the model 2361 Model createTestModel_dynamic_output_shape_relaxed_6() { 2362 const std::vector<Operand> operands = { 2363 { 2364 .type = OperandType::TENSOR_INT32, 2365 .dimensions = {3, 2, 3, 1}, 2366 .numberOfConsumers = 1, 2367 .scale = 0.0f, 2368 .zeroPoint = 0, 2369 .lifetime = OperandLifeTime::MODEL_INPUT, 2370 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2371 }, 2372 { 2373 .type = OperandType::TENSOR_INT32, 2374 .dimensions = {4}, 2375 .numberOfConsumers = 1, 2376 .scale = 0.0f, 2377 .zeroPoint = 0, 2378 .lifetime = OperandLifeTime::MODEL_INPUT, 2379 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2380 }, 2381 { 2382 .type = OperandType::TENSOR_INT32, 2383 .dimensions = {4}, 2384 .numberOfConsumers = 1, 2385 .scale = 0.0f, 2386 .zeroPoint = 0, 2387 .lifetime = OperandLifeTime::MODEL_INPUT, 2388 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2389 }, 2390 { 2391 .type = OperandType::TENSOR_INT32, 2392 .dimensions = {0, 0, 0, 0}, 2393 .numberOfConsumers = 0, 2394 .scale = 0.0f, 2395 .zeroPoint = 0, 2396 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2397 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2398 } 2399 }; 2400 2401 const std::vector<Operation> operations = { 2402 { 2403 .type = OperationType::SLICE, 2404 .inputs = {0, 1, 2}, 2405 .outputs = {3}, 2406 } 2407 }; 2408 2409 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2410 const std::vector<uint32_t> outputIndexes = {3}; 2411 std::vector<uint8_t> operandValues = {}; 2412 const std::vector<hidl_memory> pools = {}; 2413 2414 return { 2415 .operands = operands, 2416 .operations = operations, 2417 .inputIndexes = inputIndexes, 2418 .outputIndexes = outputIndexes, 2419 .operandValues = operandValues, 2420 .pools = pools, 2421 .relaxComputationFloat32toFloat16 = true, 2422 }; 2423 } 2424 2425 inline bool is_ignored_dynamic_output_shape_relaxed_6(int i) { 2426 static std::set<int> ignore = {}; 2427 return ignore.find(i) != ignore.end(); 2428 } 2429 2430 // Create the model 2431 Model createTestModel_dynamic_output_shape_float16_6() { 2432 const std::vector<Operand> operands = { 2433 { 2434 .type = OperandType::TENSOR_INT32, 2435 .dimensions = {3, 2, 3, 1}, 2436 .numberOfConsumers = 1, 2437 .scale = 0.0f, 2438 .zeroPoint = 0, 2439 .lifetime = OperandLifeTime::MODEL_INPUT, 2440 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2441 }, 2442 { 2443 .type = OperandType::TENSOR_INT32, 2444 .dimensions = {4}, 2445 .numberOfConsumers = 1, 2446 .scale = 0.0f, 2447 .zeroPoint = 0, 2448 .lifetime = OperandLifeTime::MODEL_INPUT, 2449 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2450 }, 2451 { 2452 .type = OperandType::TENSOR_INT32, 2453 .dimensions = {4}, 2454 .numberOfConsumers = 1, 2455 .scale = 0.0f, 2456 .zeroPoint = 0, 2457 .lifetime = OperandLifeTime::MODEL_INPUT, 2458 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2459 }, 2460 { 2461 .type = OperandType::TENSOR_INT32, 2462 .dimensions = {0, 0, 0, 0}, 2463 .numberOfConsumers = 0, 2464 .scale = 0.0f, 2465 .zeroPoint = 0, 2466 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2467 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2468 } 2469 }; 2470 2471 const std::vector<Operation> operations = { 2472 { 2473 .type = OperationType::SLICE, 2474 .inputs = {0, 1, 2}, 2475 .outputs = {3}, 2476 } 2477 }; 2478 2479 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2480 const std::vector<uint32_t> outputIndexes = {3}; 2481 std::vector<uint8_t> operandValues = {}; 2482 const std::vector<hidl_memory> pools = {}; 2483 2484 return { 2485 .operands = operands, 2486 .operations = operations, 2487 .inputIndexes = inputIndexes, 2488 .outputIndexes = outputIndexes, 2489 .operandValues = operandValues, 2490 .pools = pools, 2491 }; 2492 } 2493 2494 inline bool is_ignored_dynamic_output_shape_float16_6(int i) { 2495 static std::set<int> ignore = {}; 2496 return ignore.find(i) != ignore.end(); 2497 } 2498 2499 // Create the model 2500 Model createTestModel_7() { 2501 const std::vector<Operand> operands = { 2502 { 2503 .type = OperandType::TENSOR_QUANT8_ASYMM, 2504 .dimensions = {3, 2, 3, 1}, 2505 .numberOfConsumers = 1, 2506 .scale = 2.0f, 2507 .zeroPoint = 128, 2508 .lifetime = OperandLifeTime::MODEL_INPUT, 2509 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2510 }, 2511 { 2512 .type = OperandType::TENSOR_INT32, 2513 .dimensions = {4}, 2514 .numberOfConsumers = 1, 2515 .scale = 0.0f, 2516 .zeroPoint = 0, 2517 .lifetime = OperandLifeTime::MODEL_INPUT, 2518 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2519 }, 2520 { 2521 .type = OperandType::TENSOR_INT32, 2522 .dimensions = {4}, 2523 .numberOfConsumers = 1, 2524 .scale = 0.0f, 2525 .zeroPoint = 0, 2526 .lifetime = OperandLifeTime::MODEL_INPUT, 2527 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2528 }, 2529 { 2530 .type = OperandType::TENSOR_QUANT8_ASYMM, 2531 .dimensions = {2, 1, 3, 1}, 2532 .numberOfConsumers = 0, 2533 .scale = 2.0f, 2534 .zeroPoint = 128, 2535 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2536 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2537 } 2538 }; 2539 2540 const std::vector<Operation> operations = { 2541 { 2542 .type = OperationType::SLICE, 2543 .inputs = {0, 1, 2}, 2544 .outputs = {3}, 2545 } 2546 }; 2547 2548 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2549 const std::vector<uint32_t> outputIndexes = {3}; 2550 std::vector<uint8_t> operandValues = {}; 2551 const std::vector<hidl_memory> pools = {}; 2552 2553 return { 2554 .operands = operands, 2555 .operations = operations, 2556 .inputIndexes = inputIndexes, 2557 .outputIndexes = outputIndexes, 2558 .operandValues = operandValues, 2559 .pools = pools, 2560 }; 2561 } 2562 2563 inline bool is_ignored_7(int i) { 2564 static std::set<int> ignore = {}; 2565 return ignore.find(i) != ignore.end(); 2566 } 2567 2568 // Create the model 2569 Model createTestModel_relaxed_7() { 2570 const std::vector<Operand> operands = { 2571 { 2572 .type = OperandType::TENSOR_QUANT8_ASYMM, 2573 .dimensions = {3, 2, 3, 1}, 2574 .numberOfConsumers = 1, 2575 .scale = 2.0f, 2576 .zeroPoint = 128, 2577 .lifetime = OperandLifeTime::MODEL_INPUT, 2578 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2579 }, 2580 { 2581 .type = OperandType::TENSOR_INT32, 2582 .dimensions = {4}, 2583 .numberOfConsumers = 1, 2584 .scale = 0.0f, 2585 .zeroPoint = 0, 2586 .lifetime = OperandLifeTime::MODEL_INPUT, 2587 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2588 }, 2589 { 2590 .type = OperandType::TENSOR_INT32, 2591 .dimensions = {4}, 2592 .numberOfConsumers = 1, 2593 .scale = 0.0f, 2594 .zeroPoint = 0, 2595 .lifetime = OperandLifeTime::MODEL_INPUT, 2596 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2597 }, 2598 { 2599 .type = OperandType::TENSOR_QUANT8_ASYMM, 2600 .dimensions = {2, 1, 3, 1}, 2601 .numberOfConsumers = 0, 2602 .scale = 2.0f, 2603 .zeroPoint = 128, 2604 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2605 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2606 } 2607 }; 2608 2609 const std::vector<Operation> operations = { 2610 { 2611 .type = OperationType::SLICE, 2612 .inputs = {0, 1, 2}, 2613 .outputs = {3}, 2614 } 2615 }; 2616 2617 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2618 const std::vector<uint32_t> outputIndexes = {3}; 2619 std::vector<uint8_t> operandValues = {}; 2620 const std::vector<hidl_memory> pools = {}; 2621 2622 return { 2623 .operands = operands, 2624 .operations = operations, 2625 .inputIndexes = inputIndexes, 2626 .outputIndexes = outputIndexes, 2627 .operandValues = operandValues, 2628 .pools = pools, 2629 .relaxComputationFloat32toFloat16 = true, 2630 }; 2631 } 2632 2633 inline bool is_ignored_relaxed_7(int i) { 2634 static std::set<int> ignore = {}; 2635 return ignore.find(i) != ignore.end(); 2636 } 2637 2638 // Create the model 2639 Model createTestModel_float16_7() { 2640 const std::vector<Operand> operands = { 2641 { 2642 .type = OperandType::TENSOR_QUANT8_ASYMM, 2643 .dimensions = {3, 2, 3, 1}, 2644 .numberOfConsumers = 1, 2645 .scale = 2.0f, 2646 .zeroPoint = 128, 2647 .lifetime = OperandLifeTime::MODEL_INPUT, 2648 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2649 }, 2650 { 2651 .type = OperandType::TENSOR_INT32, 2652 .dimensions = {4}, 2653 .numberOfConsumers = 1, 2654 .scale = 0.0f, 2655 .zeroPoint = 0, 2656 .lifetime = OperandLifeTime::MODEL_INPUT, 2657 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2658 }, 2659 { 2660 .type = OperandType::TENSOR_INT32, 2661 .dimensions = {4}, 2662 .numberOfConsumers = 1, 2663 .scale = 0.0f, 2664 .zeroPoint = 0, 2665 .lifetime = OperandLifeTime::MODEL_INPUT, 2666 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2667 }, 2668 { 2669 .type = OperandType::TENSOR_QUANT8_ASYMM, 2670 .dimensions = {2, 1, 3, 1}, 2671 .numberOfConsumers = 0, 2672 .scale = 2.0f, 2673 .zeroPoint = 128, 2674 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2675 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2676 } 2677 }; 2678 2679 const std::vector<Operation> operations = { 2680 { 2681 .type = OperationType::SLICE, 2682 .inputs = {0, 1, 2}, 2683 .outputs = {3}, 2684 } 2685 }; 2686 2687 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2688 const std::vector<uint32_t> outputIndexes = {3}; 2689 std::vector<uint8_t> operandValues = {}; 2690 const std::vector<hidl_memory> pools = {}; 2691 2692 return { 2693 .operands = operands, 2694 .operations = operations, 2695 .inputIndexes = inputIndexes, 2696 .outputIndexes = outputIndexes, 2697 .operandValues = operandValues, 2698 .pools = pools, 2699 }; 2700 } 2701 2702 inline bool is_ignored_float16_7(int i) { 2703 static std::set<int> ignore = {}; 2704 return ignore.find(i) != ignore.end(); 2705 } 2706 2707 // Create the model 2708 Model createTestModel_dynamic_output_shape_7() { 2709 const std::vector<Operand> operands = { 2710 { 2711 .type = OperandType::TENSOR_QUANT8_ASYMM, 2712 .dimensions = {3, 2, 3, 1}, 2713 .numberOfConsumers = 1, 2714 .scale = 2.0f, 2715 .zeroPoint = 128, 2716 .lifetime = OperandLifeTime::MODEL_INPUT, 2717 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2718 }, 2719 { 2720 .type = OperandType::TENSOR_INT32, 2721 .dimensions = {4}, 2722 .numberOfConsumers = 1, 2723 .scale = 0.0f, 2724 .zeroPoint = 0, 2725 .lifetime = OperandLifeTime::MODEL_INPUT, 2726 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2727 }, 2728 { 2729 .type = OperandType::TENSOR_INT32, 2730 .dimensions = {4}, 2731 .numberOfConsumers = 1, 2732 .scale = 0.0f, 2733 .zeroPoint = 0, 2734 .lifetime = OperandLifeTime::MODEL_INPUT, 2735 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2736 }, 2737 { 2738 .type = OperandType::TENSOR_QUANT8_ASYMM, 2739 .dimensions = {0, 0, 0, 0}, 2740 .numberOfConsumers = 0, 2741 .scale = 2.0f, 2742 .zeroPoint = 128, 2743 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2744 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2745 } 2746 }; 2747 2748 const std::vector<Operation> operations = { 2749 { 2750 .type = OperationType::SLICE, 2751 .inputs = {0, 1, 2}, 2752 .outputs = {3}, 2753 } 2754 }; 2755 2756 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2757 const std::vector<uint32_t> outputIndexes = {3}; 2758 std::vector<uint8_t> operandValues = {}; 2759 const std::vector<hidl_memory> pools = {}; 2760 2761 return { 2762 .operands = operands, 2763 .operations = operations, 2764 .inputIndexes = inputIndexes, 2765 .outputIndexes = outputIndexes, 2766 .operandValues = operandValues, 2767 .pools = pools, 2768 }; 2769 } 2770 2771 inline bool is_ignored_dynamic_output_shape_7(int i) { 2772 static std::set<int> ignore = {}; 2773 return ignore.find(i) != ignore.end(); 2774 } 2775 2776 // Create the model 2777 Model createTestModel_dynamic_output_shape_relaxed_7() { 2778 const std::vector<Operand> operands = { 2779 { 2780 .type = OperandType::TENSOR_QUANT8_ASYMM, 2781 .dimensions = {3, 2, 3, 1}, 2782 .numberOfConsumers = 1, 2783 .scale = 2.0f, 2784 .zeroPoint = 128, 2785 .lifetime = OperandLifeTime::MODEL_INPUT, 2786 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2787 }, 2788 { 2789 .type = OperandType::TENSOR_INT32, 2790 .dimensions = {4}, 2791 .numberOfConsumers = 1, 2792 .scale = 0.0f, 2793 .zeroPoint = 0, 2794 .lifetime = OperandLifeTime::MODEL_INPUT, 2795 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2796 }, 2797 { 2798 .type = OperandType::TENSOR_INT32, 2799 .dimensions = {4}, 2800 .numberOfConsumers = 1, 2801 .scale = 0.0f, 2802 .zeroPoint = 0, 2803 .lifetime = OperandLifeTime::MODEL_INPUT, 2804 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2805 }, 2806 { 2807 .type = OperandType::TENSOR_QUANT8_ASYMM, 2808 .dimensions = {0, 0, 0, 0}, 2809 .numberOfConsumers = 0, 2810 .scale = 2.0f, 2811 .zeroPoint = 128, 2812 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2813 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2814 } 2815 }; 2816 2817 const std::vector<Operation> operations = { 2818 { 2819 .type = OperationType::SLICE, 2820 .inputs = {0, 1, 2}, 2821 .outputs = {3}, 2822 } 2823 }; 2824 2825 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2826 const std::vector<uint32_t> outputIndexes = {3}; 2827 std::vector<uint8_t> operandValues = {}; 2828 const std::vector<hidl_memory> pools = {}; 2829 2830 return { 2831 .operands = operands, 2832 .operations = operations, 2833 .inputIndexes = inputIndexes, 2834 .outputIndexes = outputIndexes, 2835 .operandValues = operandValues, 2836 .pools = pools, 2837 .relaxComputationFloat32toFloat16 = true, 2838 }; 2839 } 2840 2841 inline bool is_ignored_dynamic_output_shape_relaxed_7(int i) { 2842 static std::set<int> ignore = {}; 2843 return ignore.find(i) != ignore.end(); 2844 } 2845 2846 // Create the model 2847 Model createTestModel_dynamic_output_shape_float16_7() { 2848 const std::vector<Operand> operands = { 2849 { 2850 .type = OperandType::TENSOR_QUANT8_ASYMM, 2851 .dimensions = {3, 2, 3, 1}, 2852 .numberOfConsumers = 1, 2853 .scale = 2.0f, 2854 .zeroPoint = 128, 2855 .lifetime = OperandLifeTime::MODEL_INPUT, 2856 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2857 }, 2858 { 2859 .type = OperandType::TENSOR_INT32, 2860 .dimensions = {4}, 2861 .numberOfConsumers = 1, 2862 .scale = 0.0f, 2863 .zeroPoint = 0, 2864 .lifetime = OperandLifeTime::MODEL_INPUT, 2865 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2866 }, 2867 { 2868 .type = OperandType::TENSOR_INT32, 2869 .dimensions = {4}, 2870 .numberOfConsumers = 1, 2871 .scale = 0.0f, 2872 .zeroPoint = 0, 2873 .lifetime = OperandLifeTime::MODEL_INPUT, 2874 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2875 }, 2876 { 2877 .type = OperandType::TENSOR_QUANT8_ASYMM, 2878 .dimensions = {0, 0, 0, 0}, 2879 .numberOfConsumers = 0, 2880 .scale = 2.0f, 2881 .zeroPoint = 128, 2882 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2883 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2884 } 2885 }; 2886 2887 const std::vector<Operation> operations = { 2888 { 2889 .type = OperationType::SLICE, 2890 .inputs = {0, 1, 2}, 2891 .outputs = {3}, 2892 } 2893 }; 2894 2895 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2896 const std::vector<uint32_t> outputIndexes = {3}; 2897 std::vector<uint8_t> operandValues = {}; 2898 const std::vector<hidl_memory> pools = {}; 2899 2900 return { 2901 .operands = operands, 2902 .operations = operations, 2903 .inputIndexes = inputIndexes, 2904 .outputIndexes = outputIndexes, 2905 .operandValues = operandValues, 2906 .pools = pools, 2907 }; 2908 } 2909 2910 inline bool is_ignored_dynamic_output_shape_float16_7(int i) { 2911 static std::set<int> ignore = {}; 2912 return ignore.find(i) != ignore.end(); 2913 } 2914 2915 // Create the model 2916 Model createTestModel_8() { 2917 const std::vector<Operand> operands = { 2918 { 2919 .type = OperandType::TENSOR_INT32, 2920 .dimensions = {3, 2, 3, 1}, 2921 .numberOfConsumers = 1, 2922 .scale = 0.0f, 2923 .zeroPoint = 0, 2924 .lifetime = OperandLifeTime::MODEL_INPUT, 2925 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2926 }, 2927 { 2928 .type = OperandType::TENSOR_INT32, 2929 .dimensions = {4}, 2930 .numberOfConsumers = 1, 2931 .scale = 0.0f, 2932 .zeroPoint = 0, 2933 .lifetime = OperandLifeTime::MODEL_INPUT, 2934 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2935 }, 2936 { 2937 .type = OperandType::TENSOR_INT32, 2938 .dimensions = {4}, 2939 .numberOfConsumers = 1, 2940 .scale = 0.0f, 2941 .zeroPoint = 0, 2942 .lifetime = OperandLifeTime::MODEL_INPUT, 2943 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2944 }, 2945 { 2946 .type = OperandType::TENSOR_INT32, 2947 .dimensions = {2, 1, 3, 1}, 2948 .numberOfConsumers = 0, 2949 .scale = 0.0f, 2950 .zeroPoint = 0, 2951 .lifetime = OperandLifeTime::MODEL_OUTPUT, 2952 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2953 } 2954 }; 2955 2956 const std::vector<Operation> operations = { 2957 { 2958 .type = OperationType::SLICE, 2959 .inputs = {0, 1, 2}, 2960 .outputs = {3}, 2961 } 2962 }; 2963 2964 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 2965 const std::vector<uint32_t> outputIndexes = {3}; 2966 std::vector<uint8_t> operandValues = {}; 2967 const std::vector<hidl_memory> pools = {}; 2968 2969 return { 2970 .operands = operands, 2971 .operations = operations, 2972 .inputIndexes = inputIndexes, 2973 .outputIndexes = outputIndexes, 2974 .operandValues = operandValues, 2975 .pools = pools, 2976 }; 2977 } 2978 2979 inline bool is_ignored_8(int i) { 2980 static std::set<int> ignore = {}; 2981 return ignore.find(i) != ignore.end(); 2982 } 2983 2984 // Create the model 2985 Model createTestModel_relaxed_8() { 2986 const std::vector<Operand> operands = { 2987 { 2988 .type = OperandType::TENSOR_INT32, 2989 .dimensions = {3, 2, 3, 1}, 2990 .numberOfConsumers = 1, 2991 .scale = 0.0f, 2992 .zeroPoint = 0, 2993 .lifetime = OperandLifeTime::MODEL_INPUT, 2994 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 2995 }, 2996 { 2997 .type = OperandType::TENSOR_INT32, 2998 .dimensions = {4}, 2999 .numberOfConsumers = 1, 3000 .scale = 0.0f, 3001 .zeroPoint = 0, 3002 .lifetime = OperandLifeTime::MODEL_INPUT, 3003 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3004 }, 3005 { 3006 .type = OperandType::TENSOR_INT32, 3007 .dimensions = {4}, 3008 .numberOfConsumers = 1, 3009 .scale = 0.0f, 3010 .zeroPoint = 0, 3011 .lifetime = OperandLifeTime::MODEL_INPUT, 3012 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3013 }, 3014 { 3015 .type = OperandType::TENSOR_INT32, 3016 .dimensions = {2, 1, 3, 1}, 3017 .numberOfConsumers = 0, 3018 .scale = 0.0f, 3019 .zeroPoint = 0, 3020 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3021 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3022 } 3023 }; 3024 3025 const std::vector<Operation> operations = { 3026 { 3027 .type = OperationType::SLICE, 3028 .inputs = {0, 1, 2}, 3029 .outputs = {3}, 3030 } 3031 }; 3032 3033 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 3034 const std::vector<uint32_t> outputIndexes = {3}; 3035 std::vector<uint8_t> operandValues = {}; 3036 const std::vector<hidl_memory> pools = {}; 3037 3038 return { 3039 .operands = operands, 3040 .operations = operations, 3041 .inputIndexes = inputIndexes, 3042 .outputIndexes = outputIndexes, 3043 .operandValues = operandValues, 3044 .pools = pools, 3045 .relaxComputationFloat32toFloat16 = true, 3046 }; 3047 } 3048 3049 inline bool is_ignored_relaxed_8(int i) { 3050 static std::set<int> ignore = {}; 3051 return ignore.find(i) != ignore.end(); 3052 } 3053 3054 // Create the model 3055 Model createTestModel_float16_8() { 3056 const std::vector<Operand> operands = { 3057 { 3058 .type = OperandType::TENSOR_INT32, 3059 .dimensions = {3, 2, 3, 1}, 3060 .numberOfConsumers = 1, 3061 .scale = 0.0f, 3062 .zeroPoint = 0, 3063 .lifetime = OperandLifeTime::MODEL_INPUT, 3064 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3065 }, 3066 { 3067 .type = OperandType::TENSOR_INT32, 3068 .dimensions = {4}, 3069 .numberOfConsumers = 1, 3070 .scale = 0.0f, 3071 .zeroPoint = 0, 3072 .lifetime = OperandLifeTime::MODEL_INPUT, 3073 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3074 }, 3075 { 3076 .type = OperandType::TENSOR_INT32, 3077 .dimensions = {4}, 3078 .numberOfConsumers = 1, 3079 .scale = 0.0f, 3080 .zeroPoint = 0, 3081 .lifetime = OperandLifeTime::MODEL_INPUT, 3082 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3083 }, 3084 { 3085 .type = OperandType::TENSOR_INT32, 3086 .dimensions = {2, 1, 3, 1}, 3087 .numberOfConsumers = 0, 3088 .scale = 0.0f, 3089 .zeroPoint = 0, 3090 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3091 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3092 } 3093 }; 3094 3095 const std::vector<Operation> operations = { 3096 { 3097 .type = OperationType::SLICE, 3098 .inputs = {0, 1, 2}, 3099 .outputs = {3}, 3100 } 3101 }; 3102 3103 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 3104 const std::vector<uint32_t> outputIndexes = {3}; 3105 std::vector<uint8_t> operandValues = {}; 3106 const std::vector<hidl_memory> pools = {}; 3107 3108 return { 3109 .operands = operands, 3110 .operations = operations, 3111 .inputIndexes = inputIndexes, 3112 .outputIndexes = outputIndexes, 3113 .operandValues = operandValues, 3114 .pools = pools, 3115 }; 3116 } 3117 3118 inline bool is_ignored_float16_8(int i) { 3119 static std::set<int> ignore = {}; 3120 return ignore.find(i) != ignore.end(); 3121 } 3122 3123 // Create the model 3124 Model createTestModel_dynamic_output_shape_8() { 3125 const std::vector<Operand> operands = { 3126 { 3127 .type = OperandType::TENSOR_INT32, 3128 .dimensions = {3, 2, 3, 1}, 3129 .numberOfConsumers = 1, 3130 .scale = 0.0f, 3131 .zeroPoint = 0, 3132 .lifetime = OperandLifeTime::MODEL_INPUT, 3133 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3134 }, 3135 { 3136 .type = OperandType::TENSOR_INT32, 3137 .dimensions = {4}, 3138 .numberOfConsumers = 1, 3139 .scale = 0.0f, 3140 .zeroPoint = 0, 3141 .lifetime = OperandLifeTime::MODEL_INPUT, 3142 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3143 }, 3144 { 3145 .type = OperandType::TENSOR_INT32, 3146 .dimensions = {4}, 3147 .numberOfConsumers = 1, 3148 .scale = 0.0f, 3149 .zeroPoint = 0, 3150 .lifetime = OperandLifeTime::MODEL_INPUT, 3151 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3152 }, 3153 { 3154 .type = OperandType::TENSOR_INT32, 3155 .dimensions = {0, 0, 0, 0}, 3156 .numberOfConsumers = 0, 3157 .scale = 0.0f, 3158 .zeroPoint = 0, 3159 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3160 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3161 } 3162 }; 3163 3164 const std::vector<Operation> operations = { 3165 { 3166 .type = OperationType::SLICE, 3167 .inputs = {0, 1, 2}, 3168 .outputs = {3}, 3169 } 3170 }; 3171 3172 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 3173 const std::vector<uint32_t> outputIndexes = {3}; 3174 std::vector<uint8_t> operandValues = {}; 3175 const std::vector<hidl_memory> pools = {}; 3176 3177 return { 3178 .operands = operands, 3179 .operations = operations, 3180 .inputIndexes = inputIndexes, 3181 .outputIndexes = outputIndexes, 3182 .operandValues = operandValues, 3183 .pools = pools, 3184 }; 3185 } 3186 3187 inline bool is_ignored_dynamic_output_shape_8(int i) { 3188 static std::set<int> ignore = {}; 3189 return ignore.find(i) != ignore.end(); 3190 } 3191 3192 // Create the model 3193 Model createTestModel_dynamic_output_shape_relaxed_8() { 3194 const std::vector<Operand> operands = { 3195 { 3196 .type = OperandType::TENSOR_INT32, 3197 .dimensions = {3, 2, 3, 1}, 3198 .numberOfConsumers = 1, 3199 .scale = 0.0f, 3200 .zeroPoint = 0, 3201 .lifetime = OperandLifeTime::MODEL_INPUT, 3202 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3203 }, 3204 { 3205 .type = OperandType::TENSOR_INT32, 3206 .dimensions = {4}, 3207 .numberOfConsumers = 1, 3208 .scale = 0.0f, 3209 .zeroPoint = 0, 3210 .lifetime = OperandLifeTime::MODEL_INPUT, 3211 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3212 }, 3213 { 3214 .type = OperandType::TENSOR_INT32, 3215 .dimensions = {4}, 3216 .numberOfConsumers = 1, 3217 .scale = 0.0f, 3218 .zeroPoint = 0, 3219 .lifetime = OperandLifeTime::MODEL_INPUT, 3220 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3221 }, 3222 { 3223 .type = OperandType::TENSOR_INT32, 3224 .dimensions = {0, 0, 0, 0}, 3225 .numberOfConsumers = 0, 3226 .scale = 0.0f, 3227 .zeroPoint = 0, 3228 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3229 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3230 } 3231 }; 3232 3233 const std::vector<Operation> operations = { 3234 { 3235 .type = OperationType::SLICE, 3236 .inputs = {0, 1, 2}, 3237 .outputs = {3}, 3238 } 3239 }; 3240 3241 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 3242 const std::vector<uint32_t> outputIndexes = {3}; 3243 std::vector<uint8_t> operandValues = {}; 3244 const std::vector<hidl_memory> pools = {}; 3245 3246 return { 3247 .operands = operands, 3248 .operations = operations, 3249 .inputIndexes = inputIndexes, 3250 .outputIndexes = outputIndexes, 3251 .operandValues = operandValues, 3252 .pools = pools, 3253 .relaxComputationFloat32toFloat16 = true, 3254 }; 3255 } 3256 3257 inline bool is_ignored_dynamic_output_shape_relaxed_8(int i) { 3258 static std::set<int> ignore = {}; 3259 return ignore.find(i) != ignore.end(); 3260 } 3261 3262 // Create the model 3263 Model createTestModel_dynamic_output_shape_float16_8() { 3264 const std::vector<Operand> operands = { 3265 { 3266 .type = OperandType::TENSOR_INT32, 3267 .dimensions = {3, 2, 3, 1}, 3268 .numberOfConsumers = 1, 3269 .scale = 0.0f, 3270 .zeroPoint = 0, 3271 .lifetime = OperandLifeTime::MODEL_INPUT, 3272 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3273 }, 3274 { 3275 .type = OperandType::TENSOR_INT32, 3276 .dimensions = {4}, 3277 .numberOfConsumers = 1, 3278 .scale = 0.0f, 3279 .zeroPoint = 0, 3280 .lifetime = OperandLifeTime::MODEL_INPUT, 3281 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3282 }, 3283 { 3284 .type = OperandType::TENSOR_INT32, 3285 .dimensions = {4}, 3286 .numberOfConsumers = 1, 3287 .scale = 0.0f, 3288 .zeroPoint = 0, 3289 .lifetime = OperandLifeTime::MODEL_INPUT, 3290 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3291 }, 3292 { 3293 .type = OperandType::TENSOR_INT32, 3294 .dimensions = {0, 0, 0, 0}, 3295 .numberOfConsumers = 0, 3296 .scale = 0.0f, 3297 .zeroPoint = 0, 3298 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3299 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3300 } 3301 }; 3302 3303 const std::vector<Operation> operations = { 3304 { 3305 .type = OperationType::SLICE, 3306 .inputs = {0, 1, 2}, 3307 .outputs = {3}, 3308 } 3309 }; 3310 3311 const std::vector<uint32_t> inputIndexes = {0, 1, 2}; 3312 const std::vector<uint32_t> outputIndexes = {3}; 3313 std::vector<uint8_t> operandValues = {}; 3314 const std::vector<hidl_memory> pools = {}; 3315 3316 return { 3317 .operands = operands, 3318 .operations = operations, 3319 .inputIndexes = inputIndexes, 3320 .outputIndexes = outputIndexes, 3321 .operandValues = operandValues, 3322 .pools = pools, 3323 }; 3324 } 3325 3326 inline bool is_ignored_dynamic_output_shape_float16_8(int i) { 3327 static std::set<int> ignore = {}; 3328 return ignore.find(i) != ignore.end(); 3329 } 3330 3331 // Create the model 3332 Model createTestModel_zero_sized() { 3333 const std::vector<Operand> operands = { 3334 { 3335 .type = OperandType::TENSOR_FLOAT32, 3336 .dimensions = {1, 2}, 3337 .numberOfConsumers = 1, 3338 .scale = 0.0f, 3339 .zeroPoint = 0, 3340 .lifetime = OperandLifeTime::CONSTANT_COPY, 3341 .location = {.poolIndex = 0, .offset = 0, .length = 8}, 3342 }, 3343 { 3344 .type = OperandType::TENSOR_FLOAT32, 3345 .dimensions = {1, 8}, 3346 .numberOfConsumers = 1, 3347 .scale = 0.0f, 3348 .zeroPoint = 0, 3349 .lifetime = OperandLifeTime::CONSTANT_COPY, 3350 .location = {.poolIndex = 0, .offset = 8, .length = 32}, 3351 }, 3352 { 3353 .type = OperandType::TENSOR_INT32, 3354 .dimensions = {1}, 3355 .numberOfConsumers = 1, 3356 .scale = 0.0f, 3357 .zeroPoint = 0, 3358 .lifetime = OperandLifeTime::CONSTANT_COPY, 3359 .location = {.poolIndex = 0, .offset = 40, .length = 4}, 3360 }, 3361 { 3362 .type = OperandType::FLOAT32, 3363 .dimensions = {}, 3364 .numberOfConsumers = 1, 3365 .scale = 0.0f, 3366 .zeroPoint = 0, 3367 .lifetime = OperandLifeTime::CONSTANT_COPY, 3368 .location = {.poolIndex = 0, .offset = 44, .length = 4}, 3369 }, 3370 { 3371 .type = OperandType::INT32, 3372 .dimensions = {}, 3373 .numberOfConsumers = 1, 3374 .scale = 0.0f, 3375 .zeroPoint = 0, 3376 .lifetime = OperandLifeTime::CONSTANT_COPY, 3377 .location = {.poolIndex = 0, .offset = 48, .length = 4}, 3378 }, 3379 { 3380 .type = OperandType::INT32, 3381 .dimensions = {}, 3382 .numberOfConsumers = 1, 3383 .scale = 0.0f, 3384 .zeroPoint = 0, 3385 .lifetime = OperandLifeTime::CONSTANT_COPY, 3386 .location = {.poolIndex = 0, .offset = 52, .length = 4}, 3387 }, 3388 { 3389 .type = OperandType::FLOAT32, 3390 .dimensions = {}, 3391 .numberOfConsumers = 1, 3392 .scale = 0.0f, 3393 .zeroPoint = 0, 3394 .lifetime = OperandLifeTime::CONSTANT_COPY, 3395 .location = {.poolIndex = 0, .offset = 56, .length = 4}, 3396 }, 3397 { 3398 .type = OperandType::FLOAT32, 3399 .dimensions = {}, 3400 .numberOfConsumers = 1, 3401 .scale = 0.0f, 3402 .zeroPoint = 0, 3403 .lifetime = OperandLifeTime::CONSTANT_COPY, 3404 .location = {.poolIndex = 0, .offset = 60, .length = 4}, 3405 }, 3406 { 3407 .type = OperandType::FLOAT32, 3408 .dimensions = {}, 3409 .numberOfConsumers = 1, 3410 .scale = 0.0f, 3411 .zeroPoint = 0, 3412 .lifetime = OperandLifeTime::CONSTANT_COPY, 3413 .location = {.poolIndex = 0, .offset = 64, .length = 4}, 3414 }, 3415 { 3416 .type = OperandType::TENSOR_FLOAT32, 3417 .dimensions = {0}, 3418 .numberOfConsumers = 0, 3419 .scale = 0.0f, 3420 .zeroPoint = 0, 3421 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3422 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3423 }, 3424 { 3425 .type = OperandType::TENSOR_FLOAT32, 3426 .dimensions = {0, 4}, 3427 .numberOfConsumers = 1, 3428 .scale = 0.0f, 3429 .zeroPoint = 0, 3430 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 3431 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3432 }, 3433 { 3434 .type = OperandType::TENSOR_INT32, 3435 .dimensions = {0}, 3436 .numberOfConsumers = 0, 3437 .scale = 0.0f, 3438 .zeroPoint = 0, 3439 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3440 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3441 }, 3442 { 3443 .type = OperandType::TENSOR_INT32, 3444 .dimensions = {0}, 3445 .numberOfConsumers = 1, 3446 .scale = 0.0f, 3447 .zeroPoint = 0, 3448 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 3449 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3450 }, 3451 { 3452 .type = OperandType::TENSOR_FLOAT32, 3453 .dimensions = {1, 1, 1, 1}, 3454 .numberOfConsumers = 1, 3455 .scale = 0.0f, 3456 .zeroPoint = 0, 3457 .lifetime = OperandLifeTime::MODEL_INPUT, 3458 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3459 }, 3460 { 3461 .type = OperandType::INT32, 3462 .dimensions = {}, 3463 .numberOfConsumers = 1, 3464 .scale = 0.0f, 3465 .zeroPoint = 0, 3466 .lifetime = OperandLifeTime::CONSTANT_COPY, 3467 .location = {.poolIndex = 0, .offset = 68, .length = 4}, 3468 }, 3469 { 3470 .type = OperandType::INT32, 3471 .dimensions = {}, 3472 .numberOfConsumers = 1, 3473 .scale = 0.0f, 3474 .zeroPoint = 0, 3475 .lifetime = OperandLifeTime::CONSTANT_COPY, 3476 .location = {.poolIndex = 0, .offset = 72, .length = 4}, 3477 }, 3478 { 3479 .type = OperandType::FLOAT32, 3480 .dimensions = {}, 3481 .numberOfConsumers = 1, 3482 .scale = 0.0f, 3483 .zeroPoint = 0, 3484 .lifetime = OperandLifeTime::CONSTANT_COPY, 3485 .location = {.poolIndex = 0, .offset = 76, .length = 4}, 3486 }, 3487 { 3488 .type = OperandType::FLOAT32, 3489 .dimensions = {}, 3490 .numberOfConsumers = 1, 3491 .scale = 0.0f, 3492 .zeroPoint = 0, 3493 .lifetime = OperandLifeTime::CONSTANT_COPY, 3494 .location = {.poolIndex = 0, .offset = 80, .length = 4}, 3495 }, 3496 { 3497 .type = OperandType::INT32, 3498 .dimensions = {}, 3499 .numberOfConsumers = 1, 3500 .scale = 0.0f, 3501 .zeroPoint = 0, 3502 .lifetime = OperandLifeTime::CONSTANT_COPY, 3503 .location = {.poolIndex = 0, .offset = 84, .length = 4}, 3504 }, 3505 { 3506 .type = OperandType::INT32, 3507 .dimensions = {}, 3508 .numberOfConsumers = 1, 3509 .scale = 0.0f, 3510 .zeroPoint = 0, 3511 .lifetime = OperandLifeTime::CONSTANT_COPY, 3512 .location = {.poolIndex = 0, .offset = 88, .length = 4}, 3513 }, 3514 { 3515 .type = OperandType::BOOL, 3516 .dimensions = {}, 3517 .numberOfConsumers = 1, 3518 .scale = 0.0f, 3519 .zeroPoint = 0, 3520 .lifetime = OperandLifeTime::CONSTANT_COPY, 3521 .location = {.poolIndex = 0, .offset = 92, .length = 1}, 3522 }, 3523 { 3524 .type = OperandType::TENSOR_FLOAT32, 3525 .dimensions = {0, 2, 2, 1}, 3526 .numberOfConsumers = 1, 3527 .scale = 0.0f, 3528 .zeroPoint = 0, 3529 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 3530 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3531 }, 3532 { 3533 .type = OperandType::TENSOR_INT32, 3534 .dimensions = {4}, 3535 .numberOfConsumers = 1, 3536 .scale = 0.0f, 3537 .zeroPoint = 0, 3538 .lifetime = OperandLifeTime::CONSTANT_COPY, 3539 .location = {.poolIndex = 0, .offset = 93, .length = 16}, 3540 }, 3541 { 3542 .type = OperandType::TENSOR_INT32, 3543 .dimensions = {4}, 3544 .numberOfConsumers = 1, 3545 .scale = 0.0f, 3546 .zeroPoint = 0, 3547 .lifetime = OperandLifeTime::CONSTANT_COPY, 3548 .location = {.poolIndex = 0, .offset = 109, .length = 16}, 3549 }, 3550 { 3551 .type = OperandType::TENSOR_FLOAT32, 3552 .dimensions = {0, 1, 1, 1}, 3553 .numberOfConsumers = 0, 3554 .scale = 0.0f, 3555 .zeroPoint = 0, 3556 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3557 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3558 } 3559 }; 3560 3561 const std::vector<Operation> operations = { 3562 { 3563 .type = OperationType::BOX_WITH_NMS_LIMIT, 3564 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8}, 3565 .outputs = {9, 10, 11, 12}, 3566 }, 3567 { 3568 .type = OperationType::ROI_ALIGN, 3569 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20}, 3570 .outputs = {21}, 3571 }, 3572 { 3573 .type = OperationType::SLICE, 3574 .inputs = {21, 22, 23}, 3575 .outputs = {24}, 3576 } 3577 }; 3578 3579 const std::vector<uint32_t> inputIndexes = {13}; 3580 const std::vector<uint32_t> outputIndexes = {9, 11, 24}; 3581 std::vector<uint8_t> operandValues = { 3582 102, 102, 102, 63, 205, 204, 204, 61, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 32, 65, 0, 0, 32, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 65, 0, 0, 32, 65, 0, 0, 0, 0, 154, 153, 153, 62, 255, 255, 255, 255, 0, 0, 0, 0, 205, 204, 204, 62, 0, 0, 128, 63, 154, 153, 153, 62, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 64, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0 3583 }; 3584 const std::vector<hidl_memory> pools = {}; 3585 3586 return { 3587 .operands = operands, 3588 .operations = operations, 3589 .inputIndexes = inputIndexes, 3590 .outputIndexes = outputIndexes, 3591 .operandValues = operandValues, 3592 .pools = pools, 3593 }; 3594 } 3595 3596 inline bool is_ignored_zero_sized(int i) { 3597 static std::set<int> ignore = {}; 3598 return ignore.find(i) != ignore.end(); 3599 } 3600 3601 // Create the model 3602 Model createTestModel_zero_sized_relaxed() { 3603 const std::vector<Operand> operands = { 3604 { 3605 .type = OperandType::TENSOR_FLOAT32, 3606 .dimensions = {1, 2}, 3607 .numberOfConsumers = 1, 3608 .scale = 0.0f, 3609 .zeroPoint = 0, 3610 .lifetime = OperandLifeTime::CONSTANT_COPY, 3611 .location = {.poolIndex = 0, .offset = 0, .length = 8}, 3612 }, 3613 { 3614 .type = OperandType::TENSOR_FLOAT32, 3615 .dimensions = {1, 8}, 3616 .numberOfConsumers = 1, 3617 .scale = 0.0f, 3618 .zeroPoint = 0, 3619 .lifetime = OperandLifeTime::CONSTANT_COPY, 3620 .location = {.poolIndex = 0, .offset = 8, .length = 32}, 3621 }, 3622 { 3623 .type = OperandType::TENSOR_INT32, 3624 .dimensions = {1}, 3625 .numberOfConsumers = 1, 3626 .scale = 0.0f, 3627 .zeroPoint = 0, 3628 .lifetime = OperandLifeTime::CONSTANT_COPY, 3629 .location = {.poolIndex = 0, .offset = 40, .length = 4}, 3630 }, 3631 { 3632 .type = OperandType::FLOAT32, 3633 .dimensions = {}, 3634 .numberOfConsumers = 1, 3635 .scale = 0.0f, 3636 .zeroPoint = 0, 3637 .lifetime = OperandLifeTime::CONSTANT_COPY, 3638 .location = {.poolIndex = 0, .offset = 44, .length = 4}, 3639 }, 3640 { 3641 .type = OperandType::INT32, 3642 .dimensions = {}, 3643 .numberOfConsumers = 1, 3644 .scale = 0.0f, 3645 .zeroPoint = 0, 3646 .lifetime = OperandLifeTime::CONSTANT_COPY, 3647 .location = {.poolIndex = 0, .offset = 48, .length = 4}, 3648 }, 3649 { 3650 .type = OperandType::INT32, 3651 .dimensions = {}, 3652 .numberOfConsumers = 1, 3653 .scale = 0.0f, 3654 .zeroPoint = 0, 3655 .lifetime = OperandLifeTime::CONSTANT_COPY, 3656 .location = {.poolIndex = 0, .offset = 52, .length = 4}, 3657 }, 3658 { 3659 .type = OperandType::FLOAT32, 3660 .dimensions = {}, 3661 .numberOfConsumers = 1, 3662 .scale = 0.0f, 3663 .zeroPoint = 0, 3664 .lifetime = OperandLifeTime::CONSTANT_COPY, 3665 .location = {.poolIndex = 0, .offset = 56, .length = 4}, 3666 }, 3667 { 3668 .type = OperandType::FLOAT32, 3669 .dimensions = {}, 3670 .numberOfConsumers = 1, 3671 .scale = 0.0f, 3672 .zeroPoint = 0, 3673 .lifetime = OperandLifeTime::CONSTANT_COPY, 3674 .location = {.poolIndex = 0, .offset = 60, .length = 4}, 3675 }, 3676 { 3677 .type = OperandType::FLOAT32, 3678 .dimensions = {}, 3679 .numberOfConsumers = 1, 3680 .scale = 0.0f, 3681 .zeroPoint = 0, 3682 .lifetime = OperandLifeTime::CONSTANT_COPY, 3683 .location = {.poolIndex = 0, .offset = 64, .length = 4}, 3684 }, 3685 { 3686 .type = OperandType::TENSOR_FLOAT32, 3687 .dimensions = {0}, 3688 .numberOfConsumers = 0, 3689 .scale = 0.0f, 3690 .zeroPoint = 0, 3691 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3692 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3693 }, 3694 { 3695 .type = OperandType::TENSOR_FLOAT32, 3696 .dimensions = {0, 4}, 3697 .numberOfConsumers = 1, 3698 .scale = 0.0f, 3699 .zeroPoint = 0, 3700 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 3701 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3702 }, 3703 { 3704 .type = OperandType::TENSOR_INT32, 3705 .dimensions = {0}, 3706 .numberOfConsumers = 0, 3707 .scale = 0.0f, 3708 .zeroPoint = 0, 3709 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3710 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3711 }, 3712 { 3713 .type = OperandType::TENSOR_INT32, 3714 .dimensions = {0}, 3715 .numberOfConsumers = 1, 3716 .scale = 0.0f, 3717 .zeroPoint = 0, 3718 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 3719 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3720 }, 3721 { 3722 .type = OperandType::TENSOR_FLOAT32, 3723 .dimensions = {1, 1, 1, 1}, 3724 .numberOfConsumers = 1, 3725 .scale = 0.0f, 3726 .zeroPoint = 0, 3727 .lifetime = OperandLifeTime::MODEL_INPUT, 3728 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3729 }, 3730 { 3731 .type = OperandType::INT32, 3732 .dimensions = {}, 3733 .numberOfConsumers = 1, 3734 .scale = 0.0f, 3735 .zeroPoint = 0, 3736 .lifetime = OperandLifeTime::CONSTANT_COPY, 3737 .location = {.poolIndex = 0, .offset = 68, .length = 4}, 3738 }, 3739 { 3740 .type = OperandType::INT32, 3741 .dimensions = {}, 3742 .numberOfConsumers = 1, 3743 .scale = 0.0f, 3744 .zeroPoint = 0, 3745 .lifetime = OperandLifeTime::CONSTANT_COPY, 3746 .location = {.poolIndex = 0, .offset = 72, .length = 4}, 3747 }, 3748 { 3749 .type = OperandType::FLOAT32, 3750 .dimensions = {}, 3751 .numberOfConsumers = 1, 3752 .scale = 0.0f, 3753 .zeroPoint = 0, 3754 .lifetime = OperandLifeTime::CONSTANT_COPY, 3755 .location = {.poolIndex = 0, .offset = 76, .length = 4}, 3756 }, 3757 { 3758 .type = OperandType::FLOAT32, 3759 .dimensions = {}, 3760 .numberOfConsumers = 1, 3761 .scale = 0.0f, 3762 .zeroPoint = 0, 3763 .lifetime = OperandLifeTime::CONSTANT_COPY, 3764 .location = {.poolIndex = 0, .offset = 80, .length = 4}, 3765 }, 3766 { 3767 .type = OperandType::INT32, 3768 .dimensions = {}, 3769 .numberOfConsumers = 1, 3770 .scale = 0.0f, 3771 .zeroPoint = 0, 3772 .lifetime = OperandLifeTime::CONSTANT_COPY, 3773 .location = {.poolIndex = 0, .offset = 84, .length = 4}, 3774 }, 3775 { 3776 .type = OperandType::INT32, 3777 .dimensions = {}, 3778 .numberOfConsumers = 1, 3779 .scale = 0.0f, 3780 .zeroPoint = 0, 3781 .lifetime = OperandLifeTime::CONSTANT_COPY, 3782 .location = {.poolIndex = 0, .offset = 88, .length = 4}, 3783 }, 3784 { 3785 .type = OperandType::BOOL, 3786 .dimensions = {}, 3787 .numberOfConsumers = 1, 3788 .scale = 0.0f, 3789 .zeroPoint = 0, 3790 .lifetime = OperandLifeTime::CONSTANT_COPY, 3791 .location = {.poolIndex = 0, .offset = 92, .length = 1}, 3792 }, 3793 { 3794 .type = OperandType::TENSOR_FLOAT32, 3795 .dimensions = {0, 2, 2, 1}, 3796 .numberOfConsumers = 1, 3797 .scale = 0.0f, 3798 .zeroPoint = 0, 3799 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 3800 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3801 }, 3802 { 3803 .type = OperandType::TENSOR_INT32, 3804 .dimensions = {4}, 3805 .numberOfConsumers = 1, 3806 .scale = 0.0f, 3807 .zeroPoint = 0, 3808 .lifetime = OperandLifeTime::CONSTANT_COPY, 3809 .location = {.poolIndex = 0, .offset = 93, .length = 16}, 3810 }, 3811 { 3812 .type = OperandType::TENSOR_INT32, 3813 .dimensions = {4}, 3814 .numberOfConsumers = 1, 3815 .scale = 0.0f, 3816 .zeroPoint = 0, 3817 .lifetime = OperandLifeTime::CONSTANT_COPY, 3818 .location = {.poolIndex = 0, .offset = 109, .length = 16}, 3819 }, 3820 { 3821 .type = OperandType::TENSOR_FLOAT32, 3822 .dimensions = {0, 1, 1, 1}, 3823 .numberOfConsumers = 0, 3824 .scale = 0.0f, 3825 .zeroPoint = 0, 3826 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3827 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3828 } 3829 }; 3830 3831 const std::vector<Operation> operations = { 3832 { 3833 .type = OperationType::BOX_WITH_NMS_LIMIT, 3834 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8}, 3835 .outputs = {9, 10, 11, 12}, 3836 }, 3837 { 3838 .type = OperationType::ROI_ALIGN, 3839 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20}, 3840 .outputs = {21}, 3841 }, 3842 { 3843 .type = OperationType::SLICE, 3844 .inputs = {21, 22, 23}, 3845 .outputs = {24}, 3846 } 3847 }; 3848 3849 const std::vector<uint32_t> inputIndexes = {13}; 3850 const std::vector<uint32_t> outputIndexes = {9, 11, 24}; 3851 std::vector<uint8_t> operandValues = { 3852 102, 102, 102, 63, 205, 204, 204, 61, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 32, 65, 0, 0, 32, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 65, 0, 0, 32, 65, 0, 0, 0, 0, 154, 153, 153, 62, 255, 255, 255, 255, 0, 0, 0, 0, 205, 204, 204, 62, 0, 0, 128, 63, 154, 153, 153, 62, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 64, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0 3853 }; 3854 const std::vector<hidl_memory> pools = {}; 3855 3856 return { 3857 .operands = operands, 3858 .operations = operations, 3859 .inputIndexes = inputIndexes, 3860 .outputIndexes = outputIndexes, 3861 .operandValues = operandValues, 3862 .pools = pools, 3863 .relaxComputationFloat32toFloat16 = true, 3864 }; 3865 } 3866 3867 inline bool is_ignored_zero_sized_relaxed(int i) { 3868 static std::set<int> ignore = {}; 3869 return ignore.find(i) != ignore.end(); 3870 } 3871 3872 // Create the model 3873 Model createTestModel_zero_sized_quant8() { 3874 const std::vector<Operand> operands = { 3875 { 3876 .type = OperandType::TENSOR_QUANT8_ASYMM, 3877 .dimensions = {1, 2}, 3878 .numberOfConsumers = 1, 3879 .scale = 0.1f, 3880 .zeroPoint = 128, 3881 .lifetime = OperandLifeTime::CONSTANT_COPY, 3882 .location = {.poolIndex = 0, .offset = 0, .length = 2}, 3883 }, 3884 { 3885 .type = OperandType::TENSOR_QUANT16_ASYMM, 3886 .dimensions = {1, 8}, 3887 .numberOfConsumers = 1, 3888 .scale = 0.125f, 3889 .zeroPoint = 0, 3890 .lifetime = OperandLifeTime::CONSTANT_COPY, 3891 .location = {.poolIndex = 0, .offset = 2, .length = 16}, 3892 }, 3893 { 3894 .type = OperandType::TENSOR_INT32, 3895 .dimensions = {1}, 3896 .numberOfConsumers = 1, 3897 .scale = 0.0f, 3898 .zeroPoint = 0, 3899 .lifetime = OperandLifeTime::CONSTANT_COPY, 3900 .location = {.poolIndex = 0, .offset = 18, .length = 4}, 3901 }, 3902 { 3903 .type = OperandType::FLOAT32, 3904 .dimensions = {}, 3905 .numberOfConsumers = 1, 3906 .scale = 0.0f, 3907 .zeroPoint = 0, 3908 .lifetime = OperandLifeTime::CONSTANT_COPY, 3909 .location = {.poolIndex = 0, .offset = 22, .length = 4}, 3910 }, 3911 { 3912 .type = OperandType::INT32, 3913 .dimensions = {}, 3914 .numberOfConsumers = 1, 3915 .scale = 0.0f, 3916 .zeroPoint = 0, 3917 .lifetime = OperandLifeTime::CONSTANT_COPY, 3918 .location = {.poolIndex = 0, .offset = 26, .length = 4}, 3919 }, 3920 { 3921 .type = OperandType::INT32, 3922 .dimensions = {}, 3923 .numberOfConsumers = 1, 3924 .scale = 0.0f, 3925 .zeroPoint = 0, 3926 .lifetime = OperandLifeTime::CONSTANT_COPY, 3927 .location = {.poolIndex = 0, .offset = 30, .length = 4}, 3928 }, 3929 { 3930 .type = OperandType::FLOAT32, 3931 .dimensions = {}, 3932 .numberOfConsumers = 1, 3933 .scale = 0.0f, 3934 .zeroPoint = 0, 3935 .lifetime = OperandLifeTime::CONSTANT_COPY, 3936 .location = {.poolIndex = 0, .offset = 34, .length = 4}, 3937 }, 3938 { 3939 .type = OperandType::FLOAT32, 3940 .dimensions = {}, 3941 .numberOfConsumers = 1, 3942 .scale = 0.0f, 3943 .zeroPoint = 0, 3944 .lifetime = OperandLifeTime::CONSTANT_COPY, 3945 .location = {.poolIndex = 0, .offset = 38, .length = 4}, 3946 }, 3947 { 3948 .type = OperandType::FLOAT32, 3949 .dimensions = {}, 3950 .numberOfConsumers = 1, 3951 .scale = 0.0f, 3952 .zeroPoint = 0, 3953 .lifetime = OperandLifeTime::CONSTANT_COPY, 3954 .location = {.poolIndex = 0, .offset = 42, .length = 4}, 3955 }, 3956 { 3957 .type = OperandType::TENSOR_QUANT8_ASYMM, 3958 .dimensions = {0}, 3959 .numberOfConsumers = 0, 3960 .scale = 0.1f, 3961 .zeroPoint = 128, 3962 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3963 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3964 }, 3965 { 3966 .type = OperandType::TENSOR_QUANT16_ASYMM, 3967 .dimensions = {0, 4}, 3968 .numberOfConsumers = 1, 3969 .scale = 0.125f, 3970 .zeroPoint = 0, 3971 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 3972 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3973 }, 3974 { 3975 .type = OperandType::TENSOR_INT32, 3976 .dimensions = {0}, 3977 .numberOfConsumers = 0, 3978 .scale = 0.0f, 3979 .zeroPoint = 0, 3980 .lifetime = OperandLifeTime::MODEL_OUTPUT, 3981 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3982 }, 3983 { 3984 .type = OperandType::TENSOR_INT32, 3985 .dimensions = {0}, 3986 .numberOfConsumers = 1, 3987 .scale = 0.0f, 3988 .zeroPoint = 0, 3989 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 3990 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 3991 }, 3992 { 3993 .type = OperandType::TENSOR_QUANT8_ASYMM, 3994 .dimensions = {1, 1, 1, 1}, 3995 .numberOfConsumers = 1, 3996 .scale = 0.1f, 3997 .zeroPoint = 128, 3998 .lifetime = OperandLifeTime::MODEL_INPUT, 3999 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4000 }, 4001 { 4002 .type = OperandType::INT32, 4003 .dimensions = {}, 4004 .numberOfConsumers = 1, 4005 .scale = 0.0f, 4006 .zeroPoint = 0, 4007 .lifetime = OperandLifeTime::CONSTANT_COPY, 4008 .location = {.poolIndex = 0, .offset = 46, .length = 4}, 4009 }, 4010 { 4011 .type = OperandType::INT32, 4012 .dimensions = {}, 4013 .numberOfConsumers = 1, 4014 .scale = 0.0f, 4015 .zeroPoint = 0, 4016 .lifetime = OperandLifeTime::CONSTANT_COPY, 4017 .location = {.poolIndex = 0, .offset = 50, .length = 4}, 4018 }, 4019 { 4020 .type = OperandType::FLOAT32, 4021 .dimensions = {}, 4022 .numberOfConsumers = 1, 4023 .scale = 0.0f, 4024 .zeroPoint = 0, 4025 .lifetime = OperandLifeTime::CONSTANT_COPY, 4026 .location = {.poolIndex = 0, .offset = 54, .length = 4}, 4027 }, 4028 { 4029 .type = OperandType::FLOAT32, 4030 .dimensions = {}, 4031 .numberOfConsumers = 1, 4032 .scale = 0.0f, 4033 .zeroPoint = 0, 4034 .lifetime = OperandLifeTime::CONSTANT_COPY, 4035 .location = {.poolIndex = 0, .offset = 58, .length = 4}, 4036 }, 4037 { 4038 .type = OperandType::INT32, 4039 .dimensions = {}, 4040 .numberOfConsumers = 1, 4041 .scale = 0.0f, 4042 .zeroPoint = 0, 4043 .lifetime = OperandLifeTime::CONSTANT_COPY, 4044 .location = {.poolIndex = 0, .offset = 62, .length = 4}, 4045 }, 4046 { 4047 .type = OperandType::INT32, 4048 .dimensions = {}, 4049 .numberOfConsumers = 1, 4050 .scale = 0.0f, 4051 .zeroPoint = 0, 4052 .lifetime = OperandLifeTime::CONSTANT_COPY, 4053 .location = {.poolIndex = 0, .offset = 66, .length = 4}, 4054 }, 4055 { 4056 .type = OperandType::BOOL, 4057 .dimensions = {}, 4058 .numberOfConsumers = 1, 4059 .scale = 0.0f, 4060 .zeroPoint = 0, 4061 .lifetime = OperandLifeTime::CONSTANT_COPY, 4062 .location = {.poolIndex = 0, .offset = 70, .length = 1}, 4063 }, 4064 { 4065 .type = OperandType::TENSOR_QUANT8_ASYMM, 4066 .dimensions = {0, 2, 2, 1}, 4067 .numberOfConsumers = 1, 4068 .scale = 0.1f, 4069 .zeroPoint = 128, 4070 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4071 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4072 }, 4073 { 4074 .type = OperandType::TENSOR_INT32, 4075 .dimensions = {4}, 4076 .numberOfConsumers = 1, 4077 .scale = 0.0f, 4078 .zeroPoint = 0, 4079 .lifetime = OperandLifeTime::CONSTANT_COPY, 4080 .location = {.poolIndex = 0, .offset = 71, .length = 16}, 4081 }, 4082 { 4083 .type = OperandType::TENSOR_INT32, 4084 .dimensions = {4}, 4085 .numberOfConsumers = 1, 4086 .scale = 0.0f, 4087 .zeroPoint = 0, 4088 .lifetime = OperandLifeTime::CONSTANT_COPY, 4089 .location = {.poolIndex = 0, .offset = 87, .length = 16}, 4090 }, 4091 { 4092 .type = OperandType::TENSOR_QUANT8_ASYMM, 4093 .dimensions = {0, 1, 1, 1}, 4094 .numberOfConsumers = 0, 4095 .scale = 0.1f, 4096 .zeroPoint = 128, 4097 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4098 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4099 } 4100 }; 4101 4102 const std::vector<Operation> operations = { 4103 { 4104 .type = OperationType::BOX_WITH_NMS_LIMIT, 4105 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8}, 4106 .outputs = {9, 10, 11, 12}, 4107 }, 4108 { 4109 .type = OperationType::ROI_ALIGN, 4110 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20}, 4111 .outputs = {21}, 4112 }, 4113 { 4114 .type = OperationType::SLICE, 4115 .inputs = {21, 22, 23}, 4116 .outputs = {24}, 4117 } 4118 }; 4119 4120 const std::vector<uint32_t> inputIndexes = {13}; 4121 const std::vector<uint32_t> outputIndexes = {9, 11, 24}; 4122 std::vector<uint8_t> operandValues = { 4123 137, 129, 8, 0, 8, 0, 80, 0, 80, 0, 0, 0, 0, 0, 80, 0, 80, 0, 0, 0, 0, 0, 154, 153, 153, 62, 255, 255, 255, 255, 0, 0, 0, 0, 205, 204, 204, 62, 0, 0, 128, 63, 154, 153, 153, 62, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 64, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0 4124 }; 4125 const std::vector<hidl_memory> pools = {}; 4126 4127 return { 4128 .operands = operands, 4129 .operations = operations, 4130 .inputIndexes = inputIndexes, 4131 .outputIndexes = outputIndexes, 4132 .operandValues = operandValues, 4133 .pools = pools, 4134 }; 4135 } 4136 4137 inline bool is_ignored_zero_sized_quant8(int i) { 4138 static std::set<int> ignore = {}; 4139 return ignore.find(i) != ignore.end(); 4140 } 4141 4142 // Create the model 4143 Model createTestModel_zero_sized_float16() { 4144 const std::vector<Operand> operands = { 4145 { 4146 .type = OperandType::TENSOR_FLOAT16, 4147 .dimensions = {1, 2}, 4148 .numberOfConsumers = 1, 4149 .scale = 0.0f, 4150 .zeroPoint = 0, 4151 .lifetime = OperandLifeTime::CONSTANT_COPY, 4152 .location = {.poolIndex = 0, .offset = 0, .length = 4}, 4153 }, 4154 { 4155 .type = OperandType::TENSOR_FLOAT16, 4156 .dimensions = {1, 8}, 4157 .numberOfConsumers = 1, 4158 .scale = 0.0f, 4159 .zeroPoint = 0, 4160 .lifetime = OperandLifeTime::CONSTANT_COPY, 4161 .location = {.poolIndex = 0, .offset = 4, .length = 16}, 4162 }, 4163 { 4164 .type = OperandType::TENSOR_INT32, 4165 .dimensions = {1}, 4166 .numberOfConsumers = 1, 4167 .scale = 0.0f, 4168 .zeroPoint = 0, 4169 .lifetime = OperandLifeTime::CONSTANT_COPY, 4170 .location = {.poolIndex = 0, .offset = 20, .length = 4}, 4171 }, 4172 { 4173 .type = OperandType::FLOAT16, 4174 .dimensions = {}, 4175 .numberOfConsumers = 1, 4176 .scale = 0.0f, 4177 .zeroPoint = 0, 4178 .lifetime = OperandLifeTime::CONSTANT_COPY, 4179 .location = {.poolIndex = 0, .offset = 24, .length = 2}, 4180 }, 4181 { 4182 .type = OperandType::INT32, 4183 .dimensions = {}, 4184 .numberOfConsumers = 1, 4185 .scale = 0.0f, 4186 .zeroPoint = 0, 4187 .lifetime = OperandLifeTime::CONSTANT_COPY, 4188 .location = {.poolIndex = 0, .offset = 26, .length = 4}, 4189 }, 4190 { 4191 .type = OperandType::INT32, 4192 .dimensions = {}, 4193 .numberOfConsumers = 1, 4194 .scale = 0.0f, 4195 .zeroPoint = 0, 4196 .lifetime = OperandLifeTime::CONSTANT_COPY, 4197 .location = {.poolIndex = 0, .offset = 30, .length = 4}, 4198 }, 4199 { 4200 .type = OperandType::FLOAT16, 4201 .dimensions = {}, 4202 .numberOfConsumers = 1, 4203 .scale = 0.0f, 4204 .zeroPoint = 0, 4205 .lifetime = OperandLifeTime::CONSTANT_COPY, 4206 .location = {.poolIndex = 0, .offset = 34, .length = 2}, 4207 }, 4208 { 4209 .type = OperandType::FLOAT16, 4210 .dimensions = {}, 4211 .numberOfConsumers = 1, 4212 .scale = 0.0f, 4213 .zeroPoint = 0, 4214 .lifetime = OperandLifeTime::CONSTANT_COPY, 4215 .location = {.poolIndex = 0, .offset = 36, .length = 2}, 4216 }, 4217 { 4218 .type = OperandType::FLOAT16, 4219 .dimensions = {}, 4220 .numberOfConsumers = 1, 4221 .scale = 0.0f, 4222 .zeroPoint = 0, 4223 .lifetime = OperandLifeTime::CONSTANT_COPY, 4224 .location = {.poolIndex = 0, .offset = 38, .length = 2}, 4225 }, 4226 { 4227 .type = OperandType::TENSOR_FLOAT16, 4228 .dimensions = {0}, 4229 .numberOfConsumers = 0, 4230 .scale = 0.0f, 4231 .zeroPoint = 0, 4232 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4233 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4234 }, 4235 { 4236 .type = OperandType::TENSOR_FLOAT16, 4237 .dimensions = {0, 4}, 4238 .numberOfConsumers = 1, 4239 .scale = 0.0f, 4240 .zeroPoint = 0, 4241 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4242 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4243 }, 4244 { 4245 .type = OperandType::TENSOR_INT32, 4246 .dimensions = {0}, 4247 .numberOfConsumers = 0, 4248 .scale = 0.0f, 4249 .zeroPoint = 0, 4250 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4251 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4252 }, 4253 { 4254 .type = OperandType::TENSOR_INT32, 4255 .dimensions = {0}, 4256 .numberOfConsumers = 1, 4257 .scale = 0.0f, 4258 .zeroPoint = 0, 4259 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4260 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4261 }, 4262 { 4263 .type = OperandType::TENSOR_FLOAT16, 4264 .dimensions = {1, 1, 1, 1}, 4265 .numberOfConsumers = 1, 4266 .scale = 0.0f, 4267 .zeroPoint = 0, 4268 .lifetime = OperandLifeTime::MODEL_INPUT, 4269 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4270 }, 4271 { 4272 .type = OperandType::INT32, 4273 .dimensions = {}, 4274 .numberOfConsumers = 1, 4275 .scale = 0.0f, 4276 .zeroPoint = 0, 4277 .lifetime = OperandLifeTime::CONSTANT_COPY, 4278 .location = {.poolIndex = 0, .offset = 40, .length = 4}, 4279 }, 4280 { 4281 .type = OperandType::INT32, 4282 .dimensions = {}, 4283 .numberOfConsumers = 1, 4284 .scale = 0.0f, 4285 .zeroPoint = 0, 4286 .lifetime = OperandLifeTime::CONSTANT_COPY, 4287 .location = {.poolIndex = 0, .offset = 44, .length = 4}, 4288 }, 4289 { 4290 .type = OperandType::FLOAT16, 4291 .dimensions = {}, 4292 .numberOfConsumers = 1, 4293 .scale = 0.0f, 4294 .zeroPoint = 0, 4295 .lifetime = OperandLifeTime::CONSTANT_COPY, 4296 .location = {.poolIndex = 0, .offset = 48, .length = 2}, 4297 }, 4298 { 4299 .type = OperandType::FLOAT16, 4300 .dimensions = {}, 4301 .numberOfConsumers = 1, 4302 .scale = 0.0f, 4303 .zeroPoint = 0, 4304 .lifetime = OperandLifeTime::CONSTANT_COPY, 4305 .location = {.poolIndex = 0, .offset = 50, .length = 2}, 4306 }, 4307 { 4308 .type = OperandType::INT32, 4309 .dimensions = {}, 4310 .numberOfConsumers = 1, 4311 .scale = 0.0f, 4312 .zeroPoint = 0, 4313 .lifetime = OperandLifeTime::CONSTANT_COPY, 4314 .location = {.poolIndex = 0, .offset = 52, .length = 4}, 4315 }, 4316 { 4317 .type = OperandType::INT32, 4318 .dimensions = {}, 4319 .numberOfConsumers = 1, 4320 .scale = 0.0f, 4321 .zeroPoint = 0, 4322 .lifetime = OperandLifeTime::CONSTANT_COPY, 4323 .location = {.poolIndex = 0, .offset = 56, .length = 4}, 4324 }, 4325 { 4326 .type = OperandType::BOOL, 4327 .dimensions = {}, 4328 .numberOfConsumers = 1, 4329 .scale = 0.0f, 4330 .zeroPoint = 0, 4331 .lifetime = OperandLifeTime::CONSTANT_COPY, 4332 .location = {.poolIndex = 0, .offset = 60, .length = 1}, 4333 }, 4334 { 4335 .type = OperandType::TENSOR_FLOAT16, 4336 .dimensions = {0, 2, 2, 1}, 4337 .numberOfConsumers = 1, 4338 .scale = 0.0f, 4339 .zeroPoint = 0, 4340 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4341 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4342 }, 4343 { 4344 .type = OperandType::TENSOR_INT32, 4345 .dimensions = {4}, 4346 .numberOfConsumers = 1, 4347 .scale = 0.0f, 4348 .zeroPoint = 0, 4349 .lifetime = OperandLifeTime::CONSTANT_COPY, 4350 .location = {.poolIndex = 0, .offset = 61, .length = 16}, 4351 }, 4352 { 4353 .type = OperandType::TENSOR_INT32, 4354 .dimensions = {4}, 4355 .numberOfConsumers = 1, 4356 .scale = 0.0f, 4357 .zeroPoint = 0, 4358 .lifetime = OperandLifeTime::CONSTANT_COPY, 4359 .location = {.poolIndex = 0, .offset = 77, .length = 16}, 4360 }, 4361 { 4362 .type = OperandType::TENSOR_FLOAT16, 4363 .dimensions = {0, 1, 1, 1}, 4364 .numberOfConsumers = 0, 4365 .scale = 0.0f, 4366 .zeroPoint = 0, 4367 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4368 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4369 } 4370 }; 4371 4372 const std::vector<Operation> operations = { 4373 { 4374 .type = OperationType::BOX_WITH_NMS_LIMIT, 4375 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8}, 4376 .outputs = {9, 10, 11, 12}, 4377 }, 4378 { 4379 .type = OperationType::ROI_ALIGN, 4380 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20}, 4381 .outputs = {21}, 4382 }, 4383 { 4384 .type = OperationType::SLICE, 4385 .inputs = {21, 22, 23}, 4386 .outputs = {24}, 4387 } 4388 }; 4389 4390 const std::vector<uint32_t> inputIndexes = {13}; 4391 const std::vector<uint32_t> outputIndexes = {9, 11, 24}; 4392 std::vector<uint8_t> operandValues = { 4393 51, 59, 102, 46, 0, 60, 0, 60, 0, 73, 0, 73, 0, 0, 0, 0, 0, 73, 0, 73, 0, 0, 0, 0, 205, 52, 255, 255, 255, 255, 0, 0, 0, 0, 102, 54, 0, 60, 205, 52, 2, 0, 0, 0, 2, 0, 0, 0, 0, 64, 0, 64, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0 4394 }; 4395 const std::vector<hidl_memory> pools = {}; 4396 4397 return { 4398 .operands = operands, 4399 .operations = operations, 4400 .inputIndexes = inputIndexes, 4401 .outputIndexes = outputIndexes, 4402 .operandValues = operandValues, 4403 .pools = pools, 4404 }; 4405 } 4406 4407 inline bool is_ignored_zero_sized_float16(int i) { 4408 static std::set<int> ignore = {}; 4409 return ignore.find(i) != ignore.end(); 4410 } 4411 4412 // Create the model 4413 Model createTestModel_zero_sized_dynamic_output_shape() { 4414 const std::vector<Operand> operands = { 4415 { 4416 .type = OperandType::TENSOR_FLOAT32, 4417 .dimensions = {1, 2}, 4418 .numberOfConsumers = 1, 4419 .scale = 0.0f, 4420 .zeroPoint = 0, 4421 .lifetime = OperandLifeTime::CONSTANT_COPY, 4422 .location = {.poolIndex = 0, .offset = 0, .length = 8}, 4423 }, 4424 { 4425 .type = OperandType::TENSOR_FLOAT32, 4426 .dimensions = {1, 8}, 4427 .numberOfConsumers = 1, 4428 .scale = 0.0f, 4429 .zeroPoint = 0, 4430 .lifetime = OperandLifeTime::CONSTANT_COPY, 4431 .location = {.poolIndex = 0, .offset = 8, .length = 32}, 4432 }, 4433 { 4434 .type = OperandType::TENSOR_INT32, 4435 .dimensions = {1}, 4436 .numberOfConsumers = 1, 4437 .scale = 0.0f, 4438 .zeroPoint = 0, 4439 .lifetime = OperandLifeTime::CONSTANT_COPY, 4440 .location = {.poolIndex = 0, .offset = 40, .length = 4}, 4441 }, 4442 { 4443 .type = OperandType::FLOAT32, 4444 .dimensions = {}, 4445 .numberOfConsumers = 1, 4446 .scale = 0.0f, 4447 .zeroPoint = 0, 4448 .lifetime = OperandLifeTime::CONSTANT_COPY, 4449 .location = {.poolIndex = 0, .offset = 44, .length = 4}, 4450 }, 4451 { 4452 .type = OperandType::INT32, 4453 .dimensions = {}, 4454 .numberOfConsumers = 1, 4455 .scale = 0.0f, 4456 .zeroPoint = 0, 4457 .lifetime = OperandLifeTime::CONSTANT_COPY, 4458 .location = {.poolIndex = 0, .offset = 48, .length = 4}, 4459 }, 4460 { 4461 .type = OperandType::INT32, 4462 .dimensions = {}, 4463 .numberOfConsumers = 1, 4464 .scale = 0.0f, 4465 .zeroPoint = 0, 4466 .lifetime = OperandLifeTime::CONSTANT_COPY, 4467 .location = {.poolIndex = 0, .offset = 52, .length = 4}, 4468 }, 4469 { 4470 .type = OperandType::FLOAT32, 4471 .dimensions = {}, 4472 .numberOfConsumers = 1, 4473 .scale = 0.0f, 4474 .zeroPoint = 0, 4475 .lifetime = OperandLifeTime::CONSTANT_COPY, 4476 .location = {.poolIndex = 0, .offset = 56, .length = 4}, 4477 }, 4478 { 4479 .type = OperandType::FLOAT32, 4480 .dimensions = {}, 4481 .numberOfConsumers = 1, 4482 .scale = 0.0f, 4483 .zeroPoint = 0, 4484 .lifetime = OperandLifeTime::CONSTANT_COPY, 4485 .location = {.poolIndex = 0, .offset = 60, .length = 4}, 4486 }, 4487 { 4488 .type = OperandType::FLOAT32, 4489 .dimensions = {}, 4490 .numberOfConsumers = 1, 4491 .scale = 0.0f, 4492 .zeroPoint = 0, 4493 .lifetime = OperandLifeTime::CONSTANT_COPY, 4494 .location = {.poolIndex = 0, .offset = 64, .length = 4}, 4495 }, 4496 { 4497 .type = OperandType::TENSOR_FLOAT32, 4498 .dimensions = {0}, 4499 .numberOfConsumers = 0, 4500 .scale = 0.0f, 4501 .zeroPoint = 0, 4502 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4503 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4504 }, 4505 { 4506 .type = OperandType::TENSOR_FLOAT32, 4507 .dimensions = {0, 4}, 4508 .numberOfConsumers = 1, 4509 .scale = 0.0f, 4510 .zeroPoint = 0, 4511 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4512 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4513 }, 4514 { 4515 .type = OperandType::TENSOR_INT32, 4516 .dimensions = {0}, 4517 .numberOfConsumers = 0, 4518 .scale = 0.0f, 4519 .zeroPoint = 0, 4520 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4521 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4522 }, 4523 { 4524 .type = OperandType::TENSOR_INT32, 4525 .dimensions = {0}, 4526 .numberOfConsumers = 1, 4527 .scale = 0.0f, 4528 .zeroPoint = 0, 4529 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4530 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4531 }, 4532 { 4533 .type = OperandType::TENSOR_FLOAT32, 4534 .dimensions = {1, 1, 1, 1}, 4535 .numberOfConsumers = 1, 4536 .scale = 0.0f, 4537 .zeroPoint = 0, 4538 .lifetime = OperandLifeTime::MODEL_INPUT, 4539 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4540 }, 4541 { 4542 .type = OperandType::INT32, 4543 .dimensions = {}, 4544 .numberOfConsumers = 1, 4545 .scale = 0.0f, 4546 .zeroPoint = 0, 4547 .lifetime = OperandLifeTime::CONSTANT_COPY, 4548 .location = {.poolIndex = 0, .offset = 68, .length = 4}, 4549 }, 4550 { 4551 .type = OperandType::INT32, 4552 .dimensions = {}, 4553 .numberOfConsumers = 1, 4554 .scale = 0.0f, 4555 .zeroPoint = 0, 4556 .lifetime = OperandLifeTime::CONSTANT_COPY, 4557 .location = {.poolIndex = 0, .offset = 72, .length = 4}, 4558 }, 4559 { 4560 .type = OperandType::FLOAT32, 4561 .dimensions = {}, 4562 .numberOfConsumers = 1, 4563 .scale = 0.0f, 4564 .zeroPoint = 0, 4565 .lifetime = OperandLifeTime::CONSTANT_COPY, 4566 .location = {.poolIndex = 0, .offset = 76, .length = 4}, 4567 }, 4568 { 4569 .type = OperandType::FLOAT32, 4570 .dimensions = {}, 4571 .numberOfConsumers = 1, 4572 .scale = 0.0f, 4573 .zeroPoint = 0, 4574 .lifetime = OperandLifeTime::CONSTANT_COPY, 4575 .location = {.poolIndex = 0, .offset = 80, .length = 4}, 4576 }, 4577 { 4578 .type = OperandType::INT32, 4579 .dimensions = {}, 4580 .numberOfConsumers = 1, 4581 .scale = 0.0f, 4582 .zeroPoint = 0, 4583 .lifetime = OperandLifeTime::CONSTANT_COPY, 4584 .location = {.poolIndex = 0, .offset = 84, .length = 4}, 4585 }, 4586 { 4587 .type = OperandType::INT32, 4588 .dimensions = {}, 4589 .numberOfConsumers = 1, 4590 .scale = 0.0f, 4591 .zeroPoint = 0, 4592 .lifetime = OperandLifeTime::CONSTANT_COPY, 4593 .location = {.poolIndex = 0, .offset = 88, .length = 4}, 4594 }, 4595 { 4596 .type = OperandType::BOOL, 4597 .dimensions = {}, 4598 .numberOfConsumers = 1, 4599 .scale = 0.0f, 4600 .zeroPoint = 0, 4601 .lifetime = OperandLifeTime::CONSTANT_COPY, 4602 .location = {.poolIndex = 0, .offset = 92, .length = 1}, 4603 }, 4604 { 4605 .type = OperandType::TENSOR_FLOAT32, 4606 .dimensions = {0, 2, 2, 1}, 4607 .numberOfConsumers = 1, 4608 .scale = 0.0f, 4609 .zeroPoint = 0, 4610 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4611 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4612 }, 4613 { 4614 .type = OperandType::TENSOR_INT32, 4615 .dimensions = {4}, 4616 .numberOfConsumers = 1, 4617 .scale = 0.0f, 4618 .zeroPoint = 0, 4619 .lifetime = OperandLifeTime::CONSTANT_COPY, 4620 .location = {.poolIndex = 0, .offset = 93, .length = 16}, 4621 }, 4622 { 4623 .type = OperandType::TENSOR_INT32, 4624 .dimensions = {4}, 4625 .numberOfConsumers = 1, 4626 .scale = 0.0f, 4627 .zeroPoint = 0, 4628 .lifetime = OperandLifeTime::CONSTANT_COPY, 4629 .location = {.poolIndex = 0, .offset = 109, .length = 16}, 4630 }, 4631 { 4632 .type = OperandType::TENSOR_FLOAT32, 4633 .dimensions = {0, 0, 0, 0}, 4634 .numberOfConsumers = 0, 4635 .scale = 0.0f, 4636 .zeroPoint = 0, 4637 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4638 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4639 } 4640 }; 4641 4642 const std::vector<Operation> operations = { 4643 { 4644 .type = OperationType::BOX_WITH_NMS_LIMIT, 4645 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8}, 4646 .outputs = {9, 10, 11, 12}, 4647 }, 4648 { 4649 .type = OperationType::ROI_ALIGN, 4650 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20}, 4651 .outputs = {21}, 4652 }, 4653 { 4654 .type = OperationType::SLICE, 4655 .inputs = {21, 22, 23}, 4656 .outputs = {24}, 4657 } 4658 }; 4659 4660 const std::vector<uint32_t> inputIndexes = {13}; 4661 const std::vector<uint32_t> outputIndexes = {9, 11, 24}; 4662 std::vector<uint8_t> operandValues = { 4663 102, 102, 102, 63, 205, 204, 204, 61, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 32, 65, 0, 0, 32, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 65, 0, 0, 32, 65, 0, 0, 0, 0, 154, 153, 153, 62, 255, 255, 255, 255, 0, 0, 0, 0, 205, 204, 204, 62, 0, 0, 128, 63, 154, 153, 153, 62, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 64, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0 4664 }; 4665 const std::vector<hidl_memory> pools = {}; 4666 4667 return { 4668 .operands = operands, 4669 .operations = operations, 4670 .inputIndexes = inputIndexes, 4671 .outputIndexes = outputIndexes, 4672 .operandValues = operandValues, 4673 .pools = pools, 4674 }; 4675 } 4676 4677 inline bool is_ignored_zero_sized_dynamic_output_shape(int i) { 4678 static std::set<int> ignore = {}; 4679 return ignore.find(i) != ignore.end(); 4680 } 4681 4682 // Create the model 4683 Model createTestModel_zero_sized_dynamic_output_shape_relaxed() { 4684 const std::vector<Operand> operands = { 4685 { 4686 .type = OperandType::TENSOR_FLOAT32, 4687 .dimensions = {1, 2}, 4688 .numberOfConsumers = 1, 4689 .scale = 0.0f, 4690 .zeroPoint = 0, 4691 .lifetime = OperandLifeTime::CONSTANT_COPY, 4692 .location = {.poolIndex = 0, .offset = 0, .length = 8}, 4693 }, 4694 { 4695 .type = OperandType::TENSOR_FLOAT32, 4696 .dimensions = {1, 8}, 4697 .numberOfConsumers = 1, 4698 .scale = 0.0f, 4699 .zeroPoint = 0, 4700 .lifetime = OperandLifeTime::CONSTANT_COPY, 4701 .location = {.poolIndex = 0, .offset = 8, .length = 32}, 4702 }, 4703 { 4704 .type = OperandType::TENSOR_INT32, 4705 .dimensions = {1}, 4706 .numberOfConsumers = 1, 4707 .scale = 0.0f, 4708 .zeroPoint = 0, 4709 .lifetime = OperandLifeTime::CONSTANT_COPY, 4710 .location = {.poolIndex = 0, .offset = 40, .length = 4}, 4711 }, 4712 { 4713 .type = OperandType::FLOAT32, 4714 .dimensions = {}, 4715 .numberOfConsumers = 1, 4716 .scale = 0.0f, 4717 .zeroPoint = 0, 4718 .lifetime = OperandLifeTime::CONSTANT_COPY, 4719 .location = {.poolIndex = 0, .offset = 44, .length = 4}, 4720 }, 4721 { 4722 .type = OperandType::INT32, 4723 .dimensions = {}, 4724 .numberOfConsumers = 1, 4725 .scale = 0.0f, 4726 .zeroPoint = 0, 4727 .lifetime = OperandLifeTime::CONSTANT_COPY, 4728 .location = {.poolIndex = 0, .offset = 48, .length = 4}, 4729 }, 4730 { 4731 .type = OperandType::INT32, 4732 .dimensions = {}, 4733 .numberOfConsumers = 1, 4734 .scale = 0.0f, 4735 .zeroPoint = 0, 4736 .lifetime = OperandLifeTime::CONSTANT_COPY, 4737 .location = {.poolIndex = 0, .offset = 52, .length = 4}, 4738 }, 4739 { 4740 .type = OperandType::FLOAT32, 4741 .dimensions = {}, 4742 .numberOfConsumers = 1, 4743 .scale = 0.0f, 4744 .zeroPoint = 0, 4745 .lifetime = OperandLifeTime::CONSTANT_COPY, 4746 .location = {.poolIndex = 0, .offset = 56, .length = 4}, 4747 }, 4748 { 4749 .type = OperandType::FLOAT32, 4750 .dimensions = {}, 4751 .numberOfConsumers = 1, 4752 .scale = 0.0f, 4753 .zeroPoint = 0, 4754 .lifetime = OperandLifeTime::CONSTANT_COPY, 4755 .location = {.poolIndex = 0, .offset = 60, .length = 4}, 4756 }, 4757 { 4758 .type = OperandType::FLOAT32, 4759 .dimensions = {}, 4760 .numberOfConsumers = 1, 4761 .scale = 0.0f, 4762 .zeroPoint = 0, 4763 .lifetime = OperandLifeTime::CONSTANT_COPY, 4764 .location = {.poolIndex = 0, .offset = 64, .length = 4}, 4765 }, 4766 { 4767 .type = OperandType::TENSOR_FLOAT32, 4768 .dimensions = {0}, 4769 .numberOfConsumers = 0, 4770 .scale = 0.0f, 4771 .zeroPoint = 0, 4772 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4773 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4774 }, 4775 { 4776 .type = OperandType::TENSOR_FLOAT32, 4777 .dimensions = {0, 4}, 4778 .numberOfConsumers = 1, 4779 .scale = 0.0f, 4780 .zeroPoint = 0, 4781 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4782 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4783 }, 4784 { 4785 .type = OperandType::TENSOR_INT32, 4786 .dimensions = {0}, 4787 .numberOfConsumers = 0, 4788 .scale = 0.0f, 4789 .zeroPoint = 0, 4790 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4791 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4792 }, 4793 { 4794 .type = OperandType::TENSOR_INT32, 4795 .dimensions = {0}, 4796 .numberOfConsumers = 1, 4797 .scale = 0.0f, 4798 .zeroPoint = 0, 4799 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4800 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4801 }, 4802 { 4803 .type = OperandType::TENSOR_FLOAT32, 4804 .dimensions = {1, 1, 1, 1}, 4805 .numberOfConsumers = 1, 4806 .scale = 0.0f, 4807 .zeroPoint = 0, 4808 .lifetime = OperandLifeTime::MODEL_INPUT, 4809 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4810 }, 4811 { 4812 .type = OperandType::INT32, 4813 .dimensions = {}, 4814 .numberOfConsumers = 1, 4815 .scale = 0.0f, 4816 .zeroPoint = 0, 4817 .lifetime = OperandLifeTime::CONSTANT_COPY, 4818 .location = {.poolIndex = 0, .offset = 68, .length = 4}, 4819 }, 4820 { 4821 .type = OperandType::INT32, 4822 .dimensions = {}, 4823 .numberOfConsumers = 1, 4824 .scale = 0.0f, 4825 .zeroPoint = 0, 4826 .lifetime = OperandLifeTime::CONSTANT_COPY, 4827 .location = {.poolIndex = 0, .offset = 72, .length = 4}, 4828 }, 4829 { 4830 .type = OperandType::FLOAT32, 4831 .dimensions = {}, 4832 .numberOfConsumers = 1, 4833 .scale = 0.0f, 4834 .zeroPoint = 0, 4835 .lifetime = OperandLifeTime::CONSTANT_COPY, 4836 .location = {.poolIndex = 0, .offset = 76, .length = 4}, 4837 }, 4838 { 4839 .type = OperandType::FLOAT32, 4840 .dimensions = {}, 4841 .numberOfConsumers = 1, 4842 .scale = 0.0f, 4843 .zeroPoint = 0, 4844 .lifetime = OperandLifeTime::CONSTANT_COPY, 4845 .location = {.poolIndex = 0, .offset = 80, .length = 4}, 4846 }, 4847 { 4848 .type = OperandType::INT32, 4849 .dimensions = {}, 4850 .numberOfConsumers = 1, 4851 .scale = 0.0f, 4852 .zeroPoint = 0, 4853 .lifetime = OperandLifeTime::CONSTANT_COPY, 4854 .location = {.poolIndex = 0, .offset = 84, .length = 4}, 4855 }, 4856 { 4857 .type = OperandType::INT32, 4858 .dimensions = {}, 4859 .numberOfConsumers = 1, 4860 .scale = 0.0f, 4861 .zeroPoint = 0, 4862 .lifetime = OperandLifeTime::CONSTANT_COPY, 4863 .location = {.poolIndex = 0, .offset = 88, .length = 4}, 4864 }, 4865 { 4866 .type = OperandType::BOOL, 4867 .dimensions = {}, 4868 .numberOfConsumers = 1, 4869 .scale = 0.0f, 4870 .zeroPoint = 0, 4871 .lifetime = OperandLifeTime::CONSTANT_COPY, 4872 .location = {.poolIndex = 0, .offset = 92, .length = 1}, 4873 }, 4874 { 4875 .type = OperandType::TENSOR_FLOAT32, 4876 .dimensions = {0, 2, 2, 1}, 4877 .numberOfConsumers = 1, 4878 .scale = 0.0f, 4879 .zeroPoint = 0, 4880 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 4881 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4882 }, 4883 { 4884 .type = OperandType::TENSOR_INT32, 4885 .dimensions = {4}, 4886 .numberOfConsumers = 1, 4887 .scale = 0.0f, 4888 .zeroPoint = 0, 4889 .lifetime = OperandLifeTime::CONSTANT_COPY, 4890 .location = {.poolIndex = 0, .offset = 93, .length = 16}, 4891 }, 4892 { 4893 .type = OperandType::TENSOR_INT32, 4894 .dimensions = {4}, 4895 .numberOfConsumers = 1, 4896 .scale = 0.0f, 4897 .zeroPoint = 0, 4898 .lifetime = OperandLifeTime::CONSTANT_COPY, 4899 .location = {.poolIndex = 0, .offset = 109, .length = 16}, 4900 }, 4901 { 4902 .type = OperandType::TENSOR_FLOAT32, 4903 .dimensions = {0, 0, 0, 0}, 4904 .numberOfConsumers = 0, 4905 .scale = 0.0f, 4906 .zeroPoint = 0, 4907 .lifetime = OperandLifeTime::MODEL_OUTPUT, 4908 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 4909 } 4910 }; 4911 4912 const std::vector<Operation> operations = { 4913 { 4914 .type = OperationType::BOX_WITH_NMS_LIMIT, 4915 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8}, 4916 .outputs = {9, 10, 11, 12}, 4917 }, 4918 { 4919 .type = OperationType::ROI_ALIGN, 4920 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20}, 4921 .outputs = {21}, 4922 }, 4923 { 4924 .type = OperationType::SLICE, 4925 .inputs = {21, 22, 23}, 4926 .outputs = {24}, 4927 } 4928 }; 4929 4930 const std::vector<uint32_t> inputIndexes = {13}; 4931 const std::vector<uint32_t> outputIndexes = {9, 11, 24}; 4932 std::vector<uint8_t> operandValues = { 4933 102, 102, 102, 63, 205, 204, 204, 61, 0, 0, 128, 63, 0, 0, 128, 63, 0, 0, 32, 65, 0, 0, 32, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 32, 65, 0, 0, 32, 65, 0, 0, 0, 0, 154, 153, 153, 62, 255, 255, 255, 255, 0, 0, 0, 0, 205, 204, 204, 62, 0, 0, 128, 63, 154, 153, 153, 62, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 64, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0 4934 }; 4935 const std::vector<hidl_memory> pools = {}; 4936 4937 return { 4938 .operands = operands, 4939 .operations = operations, 4940 .inputIndexes = inputIndexes, 4941 .outputIndexes = outputIndexes, 4942 .operandValues = operandValues, 4943 .pools = pools, 4944 .relaxComputationFloat32toFloat16 = true, 4945 }; 4946 } 4947 4948 inline bool is_ignored_zero_sized_dynamic_output_shape_relaxed(int i) { 4949 static std::set<int> ignore = {}; 4950 return ignore.find(i) != ignore.end(); 4951 } 4952 4953 // Create the model 4954 Model createTestModel_zero_sized_dynamic_output_shape_quant8() { 4955 const std::vector<Operand> operands = { 4956 { 4957 .type = OperandType::TENSOR_QUANT8_ASYMM, 4958 .dimensions = {1, 2}, 4959 .numberOfConsumers = 1, 4960 .scale = 0.1f, 4961 .zeroPoint = 128, 4962 .lifetime = OperandLifeTime::CONSTANT_COPY, 4963 .location = {.poolIndex = 0, .offset = 0, .length = 2}, 4964 }, 4965 { 4966 .type = OperandType::TENSOR_QUANT16_ASYMM, 4967 .dimensions = {1, 8}, 4968 .numberOfConsumers = 1, 4969 .scale = 0.125f, 4970 .zeroPoint = 0, 4971 .lifetime = OperandLifeTime::CONSTANT_COPY, 4972 .location = {.poolIndex = 0, .offset = 2, .length = 16}, 4973 }, 4974 { 4975 .type = OperandType::TENSOR_INT32, 4976 .dimensions = {1}, 4977 .numberOfConsumers = 1, 4978 .scale = 0.0f, 4979 .zeroPoint = 0, 4980 .lifetime = OperandLifeTime::CONSTANT_COPY, 4981 .location = {.poolIndex = 0, .offset = 18, .length = 4}, 4982 }, 4983 { 4984 .type = OperandType::FLOAT32, 4985 .dimensions = {}, 4986 .numberOfConsumers = 1, 4987 .scale = 0.0f, 4988 .zeroPoint = 0, 4989 .lifetime = OperandLifeTime::CONSTANT_COPY, 4990 .location = {.poolIndex = 0, .offset = 22, .length = 4}, 4991 }, 4992 { 4993 .type = OperandType::INT32, 4994 .dimensions = {}, 4995 .numberOfConsumers = 1, 4996 .scale = 0.0f, 4997 .zeroPoint = 0, 4998 .lifetime = OperandLifeTime::CONSTANT_COPY, 4999 .location = {.poolIndex = 0, .offset = 26, .length = 4}, 5000 }, 5001 { 5002 .type = OperandType::INT32, 5003 .dimensions = {}, 5004 .numberOfConsumers = 1, 5005 .scale = 0.0f, 5006 .zeroPoint = 0, 5007 .lifetime = OperandLifeTime::CONSTANT_COPY, 5008 .location = {.poolIndex = 0, .offset = 30, .length = 4}, 5009 }, 5010 { 5011 .type = OperandType::FLOAT32, 5012 .dimensions = {}, 5013 .numberOfConsumers = 1, 5014 .scale = 0.0f, 5015 .zeroPoint = 0, 5016 .lifetime = OperandLifeTime::CONSTANT_COPY, 5017 .location = {.poolIndex = 0, .offset = 34, .length = 4}, 5018 }, 5019 { 5020 .type = OperandType::FLOAT32, 5021 .dimensions = {}, 5022 .numberOfConsumers = 1, 5023 .scale = 0.0f, 5024 .zeroPoint = 0, 5025 .lifetime = OperandLifeTime::CONSTANT_COPY, 5026 .location = {.poolIndex = 0, .offset = 38, .length = 4}, 5027 }, 5028 { 5029 .type = OperandType::FLOAT32, 5030 .dimensions = {}, 5031 .numberOfConsumers = 1, 5032 .scale = 0.0f, 5033 .zeroPoint = 0, 5034 .lifetime = OperandLifeTime::CONSTANT_COPY, 5035 .location = {.poolIndex = 0, .offset = 42, .length = 4}, 5036 }, 5037 { 5038 .type = OperandType::TENSOR_QUANT8_ASYMM, 5039 .dimensions = {0}, 5040 .numberOfConsumers = 0, 5041 .scale = 0.1f, 5042 .zeroPoint = 128, 5043 .lifetime = OperandLifeTime::MODEL_OUTPUT, 5044 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5045 }, 5046 { 5047 .type = OperandType::TENSOR_QUANT16_ASYMM, 5048 .dimensions = {0, 4}, 5049 .numberOfConsumers = 1, 5050 .scale = 0.125f, 5051 .zeroPoint = 0, 5052 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 5053 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5054 }, 5055 { 5056 .type = OperandType::TENSOR_INT32, 5057 .dimensions = {0}, 5058 .numberOfConsumers = 0, 5059 .scale = 0.0f, 5060 .zeroPoint = 0, 5061 .lifetime = OperandLifeTime::MODEL_OUTPUT, 5062 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5063 }, 5064 { 5065 .type = OperandType::TENSOR_INT32, 5066 .dimensions = {0}, 5067 .numberOfConsumers = 1, 5068 .scale = 0.0f, 5069 .zeroPoint = 0, 5070 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 5071 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5072 }, 5073 { 5074 .type = OperandType::TENSOR_QUANT8_ASYMM, 5075 .dimensions = {1, 1, 1, 1}, 5076 .numberOfConsumers = 1, 5077 .scale = 0.1f, 5078 .zeroPoint = 128, 5079 .lifetime = OperandLifeTime::MODEL_INPUT, 5080 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5081 }, 5082 { 5083 .type = OperandType::INT32, 5084 .dimensions = {}, 5085 .numberOfConsumers = 1, 5086 .scale = 0.0f, 5087 .zeroPoint = 0, 5088 .lifetime = OperandLifeTime::CONSTANT_COPY, 5089 .location = {.poolIndex = 0, .offset = 46, .length = 4}, 5090 }, 5091 { 5092 .type = OperandType::INT32, 5093 .dimensions = {}, 5094 .numberOfConsumers = 1, 5095 .scale = 0.0f, 5096 .zeroPoint = 0, 5097 .lifetime = OperandLifeTime::CONSTANT_COPY, 5098 .location = {.poolIndex = 0, .offset = 50, .length = 4}, 5099 }, 5100 { 5101 .type = OperandType::FLOAT32, 5102 .dimensions = {}, 5103 .numberOfConsumers = 1, 5104 .scale = 0.0f, 5105 .zeroPoint = 0, 5106 .lifetime = OperandLifeTime::CONSTANT_COPY, 5107 .location = {.poolIndex = 0, .offset = 54, .length = 4}, 5108 }, 5109 { 5110 .type = OperandType::FLOAT32, 5111 .dimensions = {}, 5112 .numberOfConsumers = 1, 5113 .scale = 0.0f, 5114 .zeroPoint = 0, 5115 .lifetime = OperandLifeTime::CONSTANT_COPY, 5116 .location = {.poolIndex = 0, .offset = 58, .length = 4}, 5117 }, 5118 { 5119 .type = OperandType::INT32, 5120 .dimensions = {}, 5121 .numberOfConsumers = 1, 5122 .scale = 0.0f, 5123 .zeroPoint = 0, 5124 .lifetime = OperandLifeTime::CONSTANT_COPY, 5125 .location = {.poolIndex = 0, .offset = 62, .length = 4}, 5126 }, 5127 { 5128 .type = OperandType::INT32, 5129 .dimensions = {}, 5130 .numberOfConsumers = 1, 5131 .scale = 0.0f, 5132 .zeroPoint = 0, 5133 .lifetime = OperandLifeTime::CONSTANT_COPY, 5134 .location = {.poolIndex = 0, .offset = 66, .length = 4}, 5135 }, 5136 { 5137 .type = OperandType::BOOL, 5138 .dimensions = {}, 5139 .numberOfConsumers = 1, 5140 .scale = 0.0f, 5141 .zeroPoint = 0, 5142 .lifetime = OperandLifeTime::CONSTANT_COPY, 5143 .location = {.poolIndex = 0, .offset = 70, .length = 1}, 5144 }, 5145 { 5146 .type = OperandType::TENSOR_QUANT8_ASYMM, 5147 .dimensions = {0, 2, 2, 1}, 5148 .numberOfConsumers = 1, 5149 .scale = 0.1f, 5150 .zeroPoint = 128, 5151 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 5152 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5153 }, 5154 { 5155 .type = OperandType::TENSOR_INT32, 5156 .dimensions = {4}, 5157 .numberOfConsumers = 1, 5158 .scale = 0.0f, 5159 .zeroPoint = 0, 5160 .lifetime = OperandLifeTime::CONSTANT_COPY, 5161 .location = {.poolIndex = 0, .offset = 71, .length = 16}, 5162 }, 5163 { 5164 .type = OperandType::TENSOR_INT32, 5165 .dimensions = {4}, 5166 .numberOfConsumers = 1, 5167 .scale = 0.0f, 5168 .zeroPoint = 0, 5169 .lifetime = OperandLifeTime::CONSTANT_COPY, 5170 .location = {.poolIndex = 0, .offset = 87, .length = 16}, 5171 }, 5172 { 5173 .type = OperandType::TENSOR_QUANT8_ASYMM, 5174 .dimensions = {0, 0, 0, 0}, 5175 .numberOfConsumers = 0, 5176 .scale = 0.1f, 5177 .zeroPoint = 128, 5178 .lifetime = OperandLifeTime::MODEL_OUTPUT, 5179 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5180 } 5181 }; 5182 5183 const std::vector<Operation> operations = { 5184 { 5185 .type = OperationType::BOX_WITH_NMS_LIMIT, 5186 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8}, 5187 .outputs = {9, 10, 11, 12}, 5188 }, 5189 { 5190 .type = OperationType::ROI_ALIGN, 5191 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20}, 5192 .outputs = {21}, 5193 }, 5194 { 5195 .type = OperationType::SLICE, 5196 .inputs = {21, 22, 23}, 5197 .outputs = {24}, 5198 } 5199 }; 5200 5201 const std::vector<uint32_t> inputIndexes = {13}; 5202 const std::vector<uint32_t> outputIndexes = {9, 11, 24}; 5203 std::vector<uint8_t> operandValues = { 5204 137, 129, 8, 0, 8, 0, 80, 0, 80, 0, 0, 0, 0, 0, 80, 0, 80, 0, 0, 0, 0, 0, 154, 153, 153, 62, 255, 255, 255, 255, 0, 0, 0, 0, 205, 204, 204, 62, 0, 0, 128, 63, 154, 153, 153, 62, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 64, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0 5205 }; 5206 const std::vector<hidl_memory> pools = {}; 5207 5208 return { 5209 .operands = operands, 5210 .operations = operations, 5211 .inputIndexes = inputIndexes, 5212 .outputIndexes = outputIndexes, 5213 .operandValues = operandValues, 5214 .pools = pools, 5215 }; 5216 } 5217 5218 inline bool is_ignored_zero_sized_dynamic_output_shape_quant8(int i) { 5219 static std::set<int> ignore = {}; 5220 return ignore.find(i) != ignore.end(); 5221 } 5222 5223 // Create the model 5224 Model createTestModel_zero_sized_dynamic_output_shape_float16() { 5225 const std::vector<Operand> operands = { 5226 { 5227 .type = OperandType::TENSOR_FLOAT16, 5228 .dimensions = {1, 2}, 5229 .numberOfConsumers = 1, 5230 .scale = 0.0f, 5231 .zeroPoint = 0, 5232 .lifetime = OperandLifeTime::CONSTANT_COPY, 5233 .location = {.poolIndex = 0, .offset = 0, .length = 4}, 5234 }, 5235 { 5236 .type = OperandType::TENSOR_FLOAT16, 5237 .dimensions = {1, 8}, 5238 .numberOfConsumers = 1, 5239 .scale = 0.0f, 5240 .zeroPoint = 0, 5241 .lifetime = OperandLifeTime::CONSTANT_COPY, 5242 .location = {.poolIndex = 0, .offset = 4, .length = 16}, 5243 }, 5244 { 5245 .type = OperandType::TENSOR_INT32, 5246 .dimensions = {1}, 5247 .numberOfConsumers = 1, 5248 .scale = 0.0f, 5249 .zeroPoint = 0, 5250 .lifetime = OperandLifeTime::CONSTANT_COPY, 5251 .location = {.poolIndex = 0, .offset = 20, .length = 4}, 5252 }, 5253 { 5254 .type = OperandType::FLOAT16, 5255 .dimensions = {}, 5256 .numberOfConsumers = 1, 5257 .scale = 0.0f, 5258 .zeroPoint = 0, 5259 .lifetime = OperandLifeTime::CONSTANT_COPY, 5260 .location = {.poolIndex = 0, .offset = 24, .length = 2}, 5261 }, 5262 { 5263 .type = OperandType::INT32, 5264 .dimensions = {}, 5265 .numberOfConsumers = 1, 5266 .scale = 0.0f, 5267 .zeroPoint = 0, 5268 .lifetime = OperandLifeTime::CONSTANT_COPY, 5269 .location = {.poolIndex = 0, .offset = 26, .length = 4}, 5270 }, 5271 { 5272 .type = OperandType::INT32, 5273 .dimensions = {}, 5274 .numberOfConsumers = 1, 5275 .scale = 0.0f, 5276 .zeroPoint = 0, 5277 .lifetime = OperandLifeTime::CONSTANT_COPY, 5278 .location = {.poolIndex = 0, .offset = 30, .length = 4}, 5279 }, 5280 { 5281 .type = OperandType::FLOAT16, 5282 .dimensions = {}, 5283 .numberOfConsumers = 1, 5284 .scale = 0.0f, 5285 .zeroPoint = 0, 5286 .lifetime = OperandLifeTime::CONSTANT_COPY, 5287 .location = {.poolIndex = 0, .offset = 34, .length = 2}, 5288 }, 5289 { 5290 .type = OperandType::FLOAT16, 5291 .dimensions = {}, 5292 .numberOfConsumers = 1, 5293 .scale = 0.0f, 5294 .zeroPoint = 0, 5295 .lifetime = OperandLifeTime::CONSTANT_COPY, 5296 .location = {.poolIndex = 0, .offset = 36, .length = 2}, 5297 }, 5298 { 5299 .type = OperandType::FLOAT16, 5300 .dimensions = {}, 5301 .numberOfConsumers = 1, 5302 .scale = 0.0f, 5303 .zeroPoint = 0, 5304 .lifetime = OperandLifeTime::CONSTANT_COPY, 5305 .location = {.poolIndex = 0, .offset = 38, .length = 2}, 5306 }, 5307 { 5308 .type = OperandType::TENSOR_FLOAT16, 5309 .dimensions = {0}, 5310 .numberOfConsumers = 0, 5311 .scale = 0.0f, 5312 .zeroPoint = 0, 5313 .lifetime = OperandLifeTime::MODEL_OUTPUT, 5314 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5315 }, 5316 { 5317 .type = OperandType::TENSOR_FLOAT16, 5318 .dimensions = {0, 4}, 5319 .numberOfConsumers = 1, 5320 .scale = 0.0f, 5321 .zeroPoint = 0, 5322 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 5323 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5324 }, 5325 { 5326 .type = OperandType::TENSOR_INT32, 5327 .dimensions = {0}, 5328 .numberOfConsumers = 0, 5329 .scale = 0.0f, 5330 .zeroPoint = 0, 5331 .lifetime = OperandLifeTime::MODEL_OUTPUT, 5332 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5333 }, 5334 { 5335 .type = OperandType::TENSOR_INT32, 5336 .dimensions = {0}, 5337 .numberOfConsumers = 1, 5338 .scale = 0.0f, 5339 .zeroPoint = 0, 5340 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 5341 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5342 }, 5343 { 5344 .type = OperandType::TENSOR_FLOAT16, 5345 .dimensions = {1, 1, 1, 1}, 5346 .numberOfConsumers = 1, 5347 .scale = 0.0f, 5348 .zeroPoint = 0, 5349 .lifetime = OperandLifeTime::MODEL_INPUT, 5350 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5351 }, 5352 { 5353 .type = OperandType::INT32, 5354 .dimensions = {}, 5355 .numberOfConsumers = 1, 5356 .scale = 0.0f, 5357 .zeroPoint = 0, 5358 .lifetime = OperandLifeTime::CONSTANT_COPY, 5359 .location = {.poolIndex = 0, .offset = 40, .length = 4}, 5360 }, 5361 { 5362 .type = OperandType::INT32, 5363 .dimensions = {}, 5364 .numberOfConsumers = 1, 5365 .scale = 0.0f, 5366 .zeroPoint = 0, 5367 .lifetime = OperandLifeTime::CONSTANT_COPY, 5368 .location = {.poolIndex = 0, .offset = 44, .length = 4}, 5369 }, 5370 { 5371 .type = OperandType::FLOAT16, 5372 .dimensions = {}, 5373 .numberOfConsumers = 1, 5374 .scale = 0.0f, 5375 .zeroPoint = 0, 5376 .lifetime = OperandLifeTime::CONSTANT_COPY, 5377 .location = {.poolIndex = 0, .offset = 48, .length = 2}, 5378 }, 5379 { 5380 .type = OperandType::FLOAT16, 5381 .dimensions = {}, 5382 .numberOfConsumers = 1, 5383 .scale = 0.0f, 5384 .zeroPoint = 0, 5385 .lifetime = OperandLifeTime::CONSTANT_COPY, 5386 .location = {.poolIndex = 0, .offset = 50, .length = 2}, 5387 }, 5388 { 5389 .type = OperandType::INT32, 5390 .dimensions = {}, 5391 .numberOfConsumers = 1, 5392 .scale = 0.0f, 5393 .zeroPoint = 0, 5394 .lifetime = OperandLifeTime::CONSTANT_COPY, 5395 .location = {.poolIndex = 0, .offset = 52, .length = 4}, 5396 }, 5397 { 5398 .type = OperandType::INT32, 5399 .dimensions = {}, 5400 .numberOfConsumers = 1, 5401 .scale = 0.0f, 5402 .zeroPoint = 0, 5403 .lifetime = OperandLifeTime::CONSTANT_COPY, 5404 .location = {.poolIndex = 0, .offset = 56, .length = 4}, 5405 }, 5406 { 5407 .type = OperandType::BOOL, 5408 .dimensions = {}, 5409 .numberOfConsumers = 1, 5410 .scale = 0.0f, 5411 .zeroPoint = 0, 5412 .lifetime = OperandLifeTime::CONSTANT_COPY, 5413 .location = {.poolIndex = 0, .offset = 60, .length = 1}, 5414 }, 5415 { 5416 .type = OperandType::TENSOR_FLOAT16, 5417 .dimensions = {0, 2, 2, 1}, 5418 .numberOfConsumers = 1, 5419 .scale = 0.0f, 5420 .zeroPoint = 0, 5421 .lifetime = OperandLifeTime::TEMPORARY_VARIABLE, 5422 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5423 }, 5424 { 5425 .type = OperandType::TENSOR_INT32, 5426 .dimensions = {4}, 5427 .numberOfConsumers = 1, 5428 .scale = 0.0f, 5429 .zeroPoint = 0, 5430 .lifetime = OperandLifeTime::CONSTANT_COPY, 5431 .location = {.poolIndex = 0, .offset = 61, .length = 16}, 5432 }, 5433 { 5434 .type = OperandType::TENSOR_INT32, 5435 .dimensions = {4}, 5436 .numberOfConsumers = 1, 5437 .scale = 0.0f, 5438 .zeroPoint = 0, 5439 .lifetime = OperandLifeTime::CONSTANT_COPY, 5440 .location = {.poolIndex = 0, .offset = 77, .length = 16}, 5441 }, 5442 { 5443 .type = OperandType::TENSOR_FLOAT16, 5444 .dimensions = {0, 0, 0, 0}, 5445 .numberOfConsumers = 0, 5446 .scale = 0.0f, 5447 .zeroPoint = 0, 5448 .lifetime = OperandLifeTime::MODEL_OUTPUT, 5449 .location = {.poolIndex = 0, .offset = 0, .length = 0}, 5450 } 5451 }; 5452 5453 const std::vector<Operation> operations = { 5454 { 5455 .type = OperationType::BOX_WITH_NMS_LIMIT, 5456 .inputs = {0, 1, 2, 3, 4, 5, 6, 7, 8}, 5457 .outputs = {9, 10, 11, 12}, 5458 }, 5459 { 5460 .type = OperationType::ROI_ALIGN, 5461 .inputs = {13, 10, 12, 14, 15, 16, 17, 18, 19, 20}, 5462 .outputs = {21}, 5463 }, 5464 { 5465 .type = OperationType::SLICE, 5466 .inputs = {21, 22, 23}, 5467 .outputs = {24}, 5468 } 5469 }; 5470 5471 const std::vector<uint32_t> inputIndexes = {13}; 5472 const std::vector<uint32_t> outputIndexes = {9, 11, 24}; 5473 std::vector<uint8_t> operandValues = { 5474 51, 59, 102, 46, 0, 60, 0, 60, 0, 73, 0, 73, 0, 0, 0, 0, 0, 73, 0, 73, 0, 0, 0, 0, 205, 52, 255, 255, 255, 255, 0, 0, 0, 0, 102, 54, 0, 60, 205, 52, 2, 0, 0, 0, 2, 0, 0, 0, 0, 64, 0, 64, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0, 255, 255, 255, 255, 1, 0, 0, 0 5475 }; 5476 const std::vector<hidl_memory> pools = {}; 5477 5478 return { 5479 .operands = operands, 5480 .operations = operations, 5481 .inputIndexes = inputIndexes, 5482 .outputIndexes = outputIndexes, 5483 .operandValues = operandValues, 5484 .pools = pools, 5485 }; 5486 } 5487 5488 inline bool is_ignored_zero_sized_dynamic_output_shape_float16(int i) { 5489 static std::set<int> ignore = {}; 5490 return ignore.find(i) != ignore.end(); 5491 } 5492 5493
