diff options
| author | Eric Kunze <eric.kunze@arm.com> | 2020-10-13 16:11:07 -0700 |
|---|---|---|
| committer | Kevin Cheng <kevin.cheng@arm.com> | 2020-10-14 11:11:43 -0700 |
| commit | e5e2676409a936431f87d31fb74d825257b20804 (patch) | |
| tree | 304d93d993ef6417b02a515025f9030367682774 | |
| parent | 88b7860f180f91b5b66764c61cfd97d8bc53cece (diff) | |
| download | reference_model-e5e2676409a936431f87d31fb74d825257b20804.tar.gz | |
Initial checkin of TOSA reference_model and tests
Change-Id: I2f8e7fa63e2ae40203e57d2cc8814bde3b312cb6
Signed-off-by: Eric Kunze <eric.kunze@arm.com>
138 files changed, 26656 insertions, 0 deletions
diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..9a6276e --- /dev/null +++ b/.gitmodules @@ -0,0 +1,6 @@ +[submodule "thirdparty/eigen"] + path = thirdparty/eigen + url = https://gitlab.com/libeigen/eigen.git +[submodule "thirdparty/flatbuffers"] + path = thirdparty/flatbuffers + url = https://github.com/google/flatbuffers diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..19c5824 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,17 @@ +cmake_minimum_required (VERSION 3.4) + +set(CMAKE_INSTALL_PREFIX ".") +project(tosa_tools LANGUAGES CXX) + +option(TOSA_TOOLS_BUILD_SERIALIZATION "Enable building of Tosa Serialization Library" ON) +option(TOSA_TOOLS_BUILD_REFERENCE_MODEL "Enable building of Tosa Reference Model" ON) + +add_subdirectory(thirdparty) + +if(TOSA_TOOLS_BUILD_SERIALIZATION) + add_subdirectory(serialization) +endif() + +if(TOSA_TOOLS_BUILD_REFERENCE_MODEL) + add_subdirectory(reference_model) +endif() @@ -0,0 +1,204 @@ +Copyright (c) 2020 ARM Limited. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md new file mode 100644 index 0000000..47901e5 --- /dev/null +++ b/README.md @@ -0,0 +1,202 @@ +TOSA Reference Model +============= + +# Introduction + +The *Tensor Operator Set Architecture (TOSA) Specification +<https://git.mlplatform.org/tosa/specification.git/>* is a set of operators +with defined accuracy and compatibility constraints that Arm expects +to be implemented on its Neural Processing Units (NPUs). Most +operators from the common ML frameworks (TensorFlow, PyTorch, etc) +should be expressible in TOSA. TOSA is focused on inference, leaving +training to the original frameworks. + +The *TOSA Reference Model* package provides a reference implementation +and testing infrastructure for TOSA. The reference model consumes a +FlatBuffers serialization of the network subgraph generated by the +TOSA Serialization Library, along with input tensors for placeholder +nodes in NumPy format. By default, the model validates and evalutes +the network subgraph, and writes out the resulting output tensors in +NumPy format. + +# Installation Requirements + +The *TOSA Reference Model* and testing suite requires the following +tools: + +* CMake version 3.4 or later +* GNU Make 4.1 or later +* GCC (tested with 7.5.0) or Clang C++ compiler (tested with clang-9) + with C++17 support + +The model includes the TOSA Serialization Library, Eigen 3.3.7, and +FlatBuffers 1.11.0 as git submodules. The model is written using +C++17 and has been primarily tested on Ubuntu x86_64 18.04 LTS Linux +systems. + +The testing infrastructure requires: +* Python 3.6 or later +* TensorFlow 2.3 or later +* NumPy 1.15 or later + +Check out the required git submodules with: + +``` bash +$ git submodule init +$ git submodule update +``` + +# Compilation + +The *TOSA Reference Model* build can be prepared by creating makefiles using CMake: + +``` bash +$ mkdir -p build +$ cd build +$ cmake .. +``` + +Optionally, `-DCMAKE_BUILD_MODE=Debug` can be used on the `cmake` +command to create a debug build. Next compile using `make`: + +``` bash +$ make +``` + +The resulting executable will be named: +`reference_model/tosa_reference_model`. CMake only needs to be re-run +if the build environment changes (e.g., new dependencies or source +files). Code changes that do not affect these build rules can be +rebuilt simply using `make`. + +# Usage + +The inputs to the *TOSA Reference Model* consist of a FlatBuffers file +containing the serialized subgraph, a sequence of placeholder node +name/input tensor NumPy file pairs (produced by an external tool), and +a prefix for output tensor NumPy files (produced by the reference model). + +An example command is shown below: + +``` bash +$ mkdir -p examples_out/test_add_1x4x4x4_f32 +$ ./build/reference_model/tosa_reference_model \ + -Csubgraph_dir=examples/test_add_1x4x4x4_f32/flatbuffer-tflite \ + -Csubgraph_file=test_add_1x4x4x4_f32.tosa \ + -Cinput_dir=examples/test_add_1x4x4x4_f32/ \ + -Coutput_dir=examples_out/test_add_1x4x4x4_f32/ \ + -Coutput_tensor_prefix=ref_model_tflite_ \ + -Cinput_tensor=InputTensor-tflite0:InputTensor-tflite0.npy,InputTensor-tflite1:InputTensor-tflite1.npy +``` + +On a successful execution, the output tensors will be written in NumPy +format into output tensors in -Coutput_dir and prefixed with +-Coutput_tensor_prefix. + +When using JSON-formatted FlatBuffers input (.json extension), the +FlatBuffers schema file from the TOSA Serialization library must be +specified using -Coperator_fbs=. When using the binary FlatBuffers +format (.tosa), the schema is not necessary. + +## Examples + +The TOSA Reference Model distribution contains several example +networks with inputs and reference outputs generated by +TensorFlow or TensorFlow Lite in the examples directory. + +These examples can be run through the TOSA Reference model and should +produce the equivalent TOSA-compliant reference output tensors. +Please note that differences in floating-point ordering and rounding +may cause small differences in output for floating-point tests and +differences in quantized scaling between TensorFlow Lite and the TOSA +Specification may cause differences in quantized integer tests. + +# Debugging + +The debugging facility can be enabled by setting a debug scope and +debug level on the command line. For most purposes, the following +flags will work: `-dALL -lHIGH`. Debug output can be directed to a +file using the `-o` switch. + +# TOSA Unit Test Infrastructure + +The TOSA Unit Test infrastruture builds and runs self-contained tests +for implementations of the *Tensor Operator Set Architecture (TOSA) +Specification*. These tools directly generate TOSA operators for +verification of the TOSA reference model against existing frameworks +or other operator implementations. + +The test builder tool generates tests with random arguments and +reference inputs for each TOSA operator. Currently, the test builder +focuses on generating a wide range of legal arguments to each +operator, but it also has limited support for generating tests with +illegal arguments in order to make sure such usages are properly +detected. + +The unit tests are typically structured as a combination of input +placeholder nodes, const nodes, and attributes feeding into a single +TOSA operator. The unit tests use a Python copy of the FlatBuffers +schema written by ``flatc`` to verif/tosa. + +Each test has a JSON file which provides machine-readable metadata for +the test, including the .tosa flatbuffer file, names, shapes, and +NumPy filenames for each input and output tensor. There is also a +boolean value for whether a failure is expected because the test is +expected to trigger an invalid set of operands or attributes. + +The test runner tool executes the unit tests on the TOSA Reference +Model to generate reference output tensor values (for legal tests). +The test runner is a modular tool which can be exended to run the same +tests on additional tools or frameworks. The reference output NumPy +files are generated by this step and can be programatically compared +with output of other tools. to validate those tools. + +## Usage + +### Unit Test Builder +The test builder is in ``verif/tosa_verif_build_tests.py``. The +builder generates test outputs in ``./vtest/<operator_name>/`` by +default. To restrict test generation to particular regular expression +wildcard, use the ``--filter `` argument. The tool can be run with no +arguments to generate all tests. + +Inputs and certain attributes are created using a random number +generator, while others are exhaustive (within reasonable bounds) +where the combinatorics allow exhaustive tests. The test generation +is deterministic for a given random seed, but additional tests can be +generated using ``--seed``. As many corner-case error are often +uncovered using creative tensor shapes, the random seed parameter will +help get coverage of additional shapes. + +Additional parameters on some operators can be found in the command +line help. + +### Unit Test Runner + +The unit test running script takes self-contained unit tests from the +builder and runs them on the reference model. Shell wildcards can be +used to run more than one test at a time and tests can be run in +parallel using the ``-j`` switch. For example, to run all of the +add operator tests: + +``` bash +$ ./verif/tosa_verif_run_ref.py -t vtest/add/add* -j 8 +``` + +The test runner is quiet by default, so running a large number of +tests without any obvious errors will show no output while the tests +are running. The ``-v`` switch will show the command being run in the +background. + +To enable debugging on the reference model, shortcut commands have +been provided: ``--ref-debug=high`` and ``--ref-intermediates`` to +turn on debugging and dump intermediate tensor values. + +Additional Systems Under Test (SUTs), such as reference +implementations of operators, full frameworks, etc, can be defined by +extending the TosaTestRunner class. The SUTs can then be enabled by +using the ``--sut-module`` flag. + +# License + +The *TOSA Reference Model* and TOSA Unit Tests are licensed under Apache-2.0. diff --git a/examples/test_add_1x4x4x4_f32/InputTensor-tf0.npy b/examples/test_add_1x4x4x4_f32/InputTensor-tf0.npy Binary files differnew file mode 100644 index 0000000..1b3effb --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/InputTensor-tf0.npy diff --git a/examples/test_add_1x4x4x4_f32/InputTensor-tf1.npy b/examples/test_add_1x4x4x4_f32/InputTensor-tf1.npy Binary files differnew file mode 100644 index 0000000..f233cd4 --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/InputTensor-tf1.npy diff --git a/examples/test_add_1x4x4x4_f32/InputTensor-tflite0.npy b/examples/test_add_1x4x4x4_f32/InputTensor-tflite0.npy Binary files differnew file mode 100644 index 0000000..1b3effb --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/InputTensor-tflite0.npy diff --git a/examples/test_add_1x4x4x4_f32/InputTensor-tflite1.npy b/examples/test_add_1x4x4x4_f32/InputTensor-tflite1.npy Binary files differnew file mode 100644 index 0000000..f233cd4 --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/InputTensor-tflite1.npy diff --git a/examples/test_add_1x4x4x4_f32/flatbuffer-tf/test_add_1x4x4x4_f32.tosa b/examples/test_add_1x4x4x4_f32/flatbuffer-tf/test_add_1x4x4x4_f32.tosa Binary files differnew file mode 100644 index 0000000..673efdb --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/flatbuffer-tf/test_add_1x4x4x4_f32.tosa diff --git a/examples/test_add_1x4x4x4_f32/flatbuffer-tflite/test_add_1x4x4x4_f32.tosa b/examples/test_add_1x4x4x4_f32/flatbuffer-tflite/test_add_1x4x4x4_f32.tosa Binary files differnew file mode 100644 index 0000000..8035292 --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/flatbuffer-tflite/test_add_1x4x4x4_f32.tosa diff --git a/examples/test_add_1x4x4x4_f32/placeholder_0.npy b/examples/test_add_1x4x4x4_f32/placeholder_0.npy Binary files differnew file mode 100644 index 0000000..1b3effb --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/placeholder_0.npy diff --git a/examples/test_add_1x4x4x4_f32/placeholder_1.npy b/examples/test_add_1x4x4x4_f32/placeholder_1.npy Binary files differnew file mode 100644 index 0000000..f233cd4 --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/placeholder_1.npy diff --git a/examples/test_add_1x4x4x4_f32/ref_ofm.npy b/examples/test_add_1x4x4x4_f32/ref_ofm.npy Binary files differnew file mode 100644 index 0000000..71e2008 --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/ref_ofm.npy diff --git a/examples/test_add_1x4x4x4_f32/test.json b/examples/test_add_1x4x4x4_f32/test.json new file mode 100644 index 0000000..cd993ef --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/test.json @@ -0,0 +1,27 @@ +{ + "pb": "test_tf.pb", + "ofm_file": "ref_ofm.npy", + "ofm_placeholder": "result", + "ifm_file": [ + "placeholder_0.npy", + "placeholder_1.npy" + ], + "ifm_placeholder": [ + "placeholder_0:0", + "placeholder_1:0" + ], + "ifm_shape": [ + [ + 1, + 4, + 4, + 1 + ], + [ + 1, + 4, + 4, + 4 + ] + ] +}
\ No newline at end of file diff --git a/examples/test_add_1x4x4x4_f32/test_tf.pb b/examples/test_add_1x4x4x4_f32/test_tf.pb new file mode 100644 index 0000000..dae00ee --- /dev/null +++ b/examples/test_add_1x4x4x4_f32/test_tf.pb @@ -0,0 +1,112 @@ +node { + name: "keras_learning_phase/input" + op: "Const" + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: false + } + } + } +} +node { + name: "keras_learning_phase" + op: "PlaceholderWithDefault" + input: "keras_learning_phase/input" + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "shape" + value { + shape { + } + } + } +} +node { + name: "placeholder_0" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 1 + } + } + } + } +} +node { + name: "placeholder_1" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + dim { + size: 4 + } + dim { + size: 4 + } + dim { + size: 4 + } + } + } + } +} +node { + name: "result" + op: "Add" + input: "placeholder_0" + input: "placeholder_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } +} +versions { + producer: 498 +} diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/InputTensor-tf0.npy b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/InputTensor-tf0.npy Binary files differnew file mode 100644 index 0000000..328dbd8 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/InputTensor-tf0.npy diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/InputTensor-tflite0.npy b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/InputTensor-tflite0.npy Binary files differnew file mode 100644 index 0000000..328dbd8 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/InputTensor-tflite0.npy diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/layer_1.npy b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/layer_1.npy Binary files differnew file mode 100644 index 0000000..79bf0ec --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/layer_1.npy diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/layer_2.npy b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/layer_2.npy Binary files differnew file mode 100644 index 0000000..42ff6d7 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/layer_2.npy diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/layer_4.npy b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/layer_4.npy Binary files differnew file mode 100644 index 0000000..ec9d526 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/layer_4.npy diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11.tosa b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11.tosa Binary files differnew file mode 100644 index 0000000..42f11de --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tf/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11.tosa diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tflite/layer_1.npy b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tflite/layer_1.npy Binary files differnew file mode 100644 index 0000000..ec9d526 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tflite/layer_1.npy diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tflite/layer_2.npy b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tflite/layer_2.npy Binary files differnew file mode 100644 index 0000000..207be76 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tflite/layer_2.npy diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tflite/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11.tosa b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tflite/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11.tosa Binary files differnew file mode 100644 index 0000000..105b755 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/flatbuffer-tflite/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11.tosa diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/placeholder_0.npy b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/placeholder_0.npy Binary files differnew file mode 100644 index 0000000..328dbd8 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/placeholder_0.npy diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/ref_ofm.npy b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/ref_ofm.npy Binary files differnew file mode 100644 index 0000000..d0ee52f --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/ref_ofm.npy diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/test.json b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/test.json new file mode 100644 index 0000000..5962306 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/test.json @@ -0,0 +1,19 @@ +{ + "pb": "test_tf.pb", + "ofm_file": "ref_ofm.npy", + "ofm_placeholder": "result", + "ifm_file": [ + "placeholder_0.npy" + ], + "ifm_placeholder": [ + "placeholder_0:0" + ], + "ifm_shape": [ + [ + 1, + 32, + 32, + 8 + ] + ] +}
\ No newline at end of file diff --git a/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/test_tf.pb b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/test_tf.pb new file mode 100644 index 0000000..3b00d26 --- /dev/null +++ b/examples/test_conv2d_1x1_1x32x32x8_f32_st11_padSAME_dilat11/test_tf.pb @@ -0,0 +1,163 @@ +node { + name: "keras_learning_phase/input" + op: "Const" + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: false + } + } + } +} +node { + name: "keras_learning_phase" + op: "PlaceholderWithDefault" + input: "keras_learning_phase/input" + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "shape" + value { + shape { + } + } + } +} +node { + name: "placeholder_0" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + dim { + size: 32 + } + dim { + size: 32 + } + dim { + size: 8 + } + } + } + } +} +node { + name: "const_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 16 + } + } + tensor_content: "\234\225\213?\343\017\327>\324\256K\277\371\365->9KC??q\254?Gp\031\276\257I\305\276.UL\277\336\263\260?\272\245#?\2343\337\277\016\312\363\277I\003\353\277\232F\325\277\255\264\301\277t@A\277\311#;\276D-\374?\347/\322?\026U\242?3E\217?\217\225\206?\204v\360\277\033[\217?\310\033\260\276\273\277\331\276w{\257?v\315\310?u\252\343?0\254\222?m\004\274?4\3420\277n\016\261\277D\362\202\276\251}j?\225\242\014\277\240\322\300?\233\205\202?\362\375\362?\377\302\222?\337\t\275=\207\021\r\277\"4\337\277\351?\354\276\037\362f>\326Z\214>2o\364?\201\357\357;\2703\332?[;J\277Ta\253\277\335}\324\277\354) ?&5\253?\353\257\231?\031~\242\277\225i\006\277\025\225\343?\rs\227\274\007\367L?uH\231?\303\027\305\276\315\247\260=_x\374?6\305\310\277\017\337\350?\206@\035\276\217\235\355?\300d\323?H*\266\277\223\300\332\277\325\251\256?9j\007\275\356\025T?\006\240\302\2779)N?\3212\217\274\233p\027\277\312a\212>\265ly?\310?\247?\345%\356\2767\257\342\277\345\276\226=\367\202\267\276!\254\307=\375\326!?\017\256\274\273\006\321\201?@0\242\277\325\333\355?\353\030\212\276\025|\000>\224\2353\277\270\250@\277\213\014\246\277\275q-\277\225\370\366?7\033\363\276\331\246\022?\306\3439\277\242\334\030\277(K\375?W\322G>d\350K\277\236\2754?\177\262\252\277\024\327K>\221\220\306?D\244\304\276\243 \342?t\326\026?u7\363?\365\000\200\276*\215\361\276?\256\035\277\210o\266\277&\026\"\277\342\021i\276;m\317\276\373N\037?T?\205?$\340\361?\230\032\034\277\004\235*?\225\254\324?\263\207\016>" + } + } + } +} +node { + name: "result" + op: "Conv2D" + input: "placeholder_0" + input: "const_1" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "explicit_paddings" + value { + list { + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +versions { + producer: 498 +} diff --git a/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/InputTensor-tflite0.npy b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/InputTensor-tflite0.npy Binary files differnew file mode 100644 index 0000000..c9e9b19 --- /dev/null +++ b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/InputTensor-tflite0.npy diff --git a/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/flatbuffer-tflite/layer_1.npy b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/flatbuffer-tflite/layer_1.npy Binary files differnew file mode 100644 index 0000000..0bbfb0c --- /dev/null +++ b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/flatbuffer-tflite/layer_1.npy diff --git a/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/flatbuffer-tflite/layer_2.npy b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/flatbuffer-tflite/layer_2.npy Binary files differnew file mode 100644 index 0000000..67c2421 --- /dev/null +++ b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/flatbuffer-tflite/layer_2.npy diff --git a/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/flatbuffer-tflite/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11.tosa b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/flatbuffer-tflite/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11.tosa Binary files differnew file mode 100644 index 0000000..d5b4fab --- /dev/null +++ b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/flatbuffer-tflite/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11.tosa diff --git a/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/placeholder_0.npy b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/placeholder_0.npy Binary files differnew file mode 100644 index 0000000..d20c639 --- /dev/null +++ b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/placeholder_0.npy diff --git a/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/placeholder_0_quant.npy b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/placeholder_0_quant.npy Binary files differnew file mode 100644 index 0000000..c9e9b19 --- /dev/null +++ b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/placeholder_0_quant.npy diff --git a/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/ref_ofm.npy b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/ref_ofm.npy Binary files differnew file mode 100644 index 0000000..e8f4b56 --- /dev/null +++ b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/ref_ofm.npy diff --git a/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/test.json b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/test.json new file mode 100644 index 0000000..3331b46 --- /dev/null +++ b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/test.json @@ -0,0 +1,27 @@ +{ + "pb": "test_tf.pb", + "tflite": "test.tflite", + "ofm_file": "ref_ofm.npy", + "ofm_placeholder": "result", + "ifm_file": [ + "placeholder_0.npy" + ], + "ifm_quant_file": [ + "placeholder_0_quant.npy" + ], + "ifm_placeholder": [ + "placeholder_0:0" + ], + "ifm_shape": [ + [ + 1, + 32, + 32, + 8 + ] + ], + "framework_exclusions": [ + "tf" + ], + "quantized": 1 +}
\ No newline at end of file diff --git a/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/test_tf.pb b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/test_tf.pb new file mode 100644 index 0000000..65d7a78 --- /dev/null +++ b/examples/test_fakequant_conv2d_1x1_1x32x32x8_qi8_st11_padSAME_dilat11/test_tf.pb @@ -0,0 +1,312 @@ +node { + name: "keras_learning_phase/input" + op: "Const" + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_BOOL + tensor_shape { + } + bool_val: false + } + } + } +} +node { + name: "keras_learning_phase" + op: "PlaceholderWithDefault" + input: "keras_learning_phase/input" + attr { + key: "dtype" + value { + type: DT_BOOL + } + } + attr { + key: "shape" + value { + shape { + } + } + } +} +node { + name: "placeholder_0" + op: "Placeholder" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "shape" + value { + shape { + dim { + size: 1 + } + dim { + size: 32 + } + dim { + size: 32 + } + dim { + size: 8 + } + } + } + } +} +node { + name: "const_1" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 1 + } + dim { + size: 8 + } + dim { + size: 16 + } + } + tensor_content: "\266\"\346\277}\306\256\276,\3103\277\334\364\310=\3762\200\277\325@{?\n\312n=\002\202M\276\314\177g\277\215\233\376\277S\315\t\277\370\357\233\277\216\300\226=L0\377?\316\273\323\277\270G\226?\032l\353>\334\376j\277\212dj?\305\032\210?!t\235\277\377X\324\277\3751=?E\022\235\276\033\353\356\277\3570\342>r\203\016\277a\'\266\277\266\021\034>\306\225C\276I\370\247\276\024d\245?\233\262\355\277\022\254*\277\265\0026\277\266\333c?\237Z\220\277~x>\277p2\216?\001C\267\277v\254\247\277\026\322(?\231\r\346\276\252\372\352?\315+\240\277\213f\320\276N\233\367\276\002\262\241\277=\177\335>\234\327\275>+\027M\277$\324\265\277\351\373\227?\261\266L\277tP\024\277\203\353\000\275}\334P=Rr\232?\240y\373?\343\264\230?\037\316\212\276\232\203\347?\257O\361\276\262j\243?\251n(\277\002\266v?\031%\216?\311s\235\277f\274:\277\274\"\205?\262a\225>\251,\351>\025\204\352\277\204?\310?\017{\370>\023\240\226\276w\r\246?\337\274\311?\267\241\325?\206\341\325?\005\246\276\2779\036L\277h\376\260\277\201\247\306?\207R4?s\304\230\277\3503\215\277\310\t\205\277X\336\255\277\275] \277F?\215\275pj\370?\346yK\277\0028\272=\207e\343\277\231,\371?\004Z{>N\261\347\277\355\323\007?\310\275\221\2771\266\206\277\010\307\323\277!5\262?\244\366)?\n\360\321?\300B9\277Py\324?Y5\313\277I\n\244\277\313W<?i\221\227?\003\327\245\277\265<\264?\240\363\253?\225\3607?bX\301\277\230\250\200\276\327C\237\276\023X\373\277\336\235G\277]\252\206?\322\260\366\277^l\264?f_\031\277\355w\340?T\025\331=\001\276\331?\335\231\230=" + } + } + } +} +node { + name: "gen_quant_npy/inputs" + op: "Const" + attr { + key: "dtype" + value { + type: DT_FLOAT + } + } + attr { + key: "value" + value { + tensor { + dtype: DT_FLOAT + tensor_shape { + dim { + size: 1 + } + dim { + size: 32 + } + dim { + size: 32 + } + dim { + size: 8 + } + } + tensor_content: "\267*\224\277\323\277\231\276hE\323?\321\230\336\277\355n\341\277\031\030\345\276Z\223\037\277 \006\\\276\006\213\333>\345\014\315\277!\210\014\277$Iq?\254s[\2767m\204?\031-\201?;\314\026>/\377\261?\264b\275?\213\314a\277D\370\213?\212\342\361\277\033c\227?\253p\261\276\235\t\217>}\316\213?%.\364\277,bC?\261\177\337?\273l\200>o\035r?\275\327\226?A\346O\277]\340\330?\374{\001\277\303\036u?\331j\237>\357\002\244?l\270\224\277+\254:\277\365\3254\275{*\260\277P\326\311\277;\363\376>W+\236>\226\034\025>\336\353s\276Y?\363\275Z\361\375\276L\240\337\277\205\237\326\277_\t\223>\036\312\335\277I\240\251\277\\\367\222?\322\037\345\277\231e \277\225\260R\277\301P\271?5\016\365?\337r\335\276y\300\364\277lN\234=\245U\210?\\E\265?h~@\277_e&?\373\241\367\277-a[?\003\032|\276\360\307\376?\2023\244?\367\243\344\277p)\215?\367]\272?\013\3341\277[\024\374?\263x\311\276x\341\242\2768F\361?\362\360`?\340\225d\277S\204\214?\257\244\362\276\\z\373?*\031\330\277Pz\363\277\270d\016\277\330\210\024\277\024yN>\234\250\215?\222\344\273\277\346\277\343?\300\320\313?\016\207a?&\236\263?\340\231\243\277\214\270\363\277\344u\346\2760\376\231?Z?\315?\331*\223\277\234#\323\277,o\224?Bw\231?\2452,?\263\377\002?\334\026\337?`\274\022\277\327\277\273?\237\312\276\277\274\227\261?\3714\341?ibC\277Q\364\205\277\206tQ\276J\324\205?F\207\300?\362\2154\277\005\231\202\277+\355\300?\315X\216>t=\376?\013[\333\277\362\366\031>\222W\271\277\002C\216\277\007\265\216=\330C\334?\036\245\305?0\374\365>m\214\201\276\205\303\357>\270\215\305\277;\305\376\277\252\375\214\277\222o\210\2765m\274\277(\3737\277%it\277(V\267?\355g\322?Hz\224;\330\346x\277K\207\354?*\000\026>\265H\272\276Jo\216\276\014X\325?\320\267\245=\353\225\250?\314\361\300\276>8\025?\277\270\255>\006\3714\277\337\340\301<F\177\354\277\242Y\341\277\0313\263\277\217\304\223>\327\316a?\314y~?\nF\310\276C\317\226>\331\274\303?\030\206}?\035\n\272\277\005$5\276\367+\206?b\"\371?\261s\200?\003<\014>\325$\233\277\332]\204?\020\007\222?\025\237\261\277\331\225\375?\t\356\034\277.\273\360\276G\221\325\276\350\010\316>\350\303x\277\247\347\262?`\207\204\277\034F ?\306!@\277\177\355\270\275\306\257j\2779\315\234?=\003#>/\234\213\277?C\245?\331)\"\277\347tH\276=`\260?\\\235\225?r\236\351?\036:\320\277\244]\210?\227SS\277\213\262\362?4\177\215\277$\322\324?\365f7\276\273\350\227\277\271t\215?\211\366~?\216Y\202?\276\235\224\277\033U\243?$i\303\276\235P\371\277\2059\222\277\301\307D?\366o\327?\0139m\277\344\377b>\204\344\202\277\246\234\337?\007K\034\277\314&\360>\213\003\353\277\026\252\341\277\014FT\277\366\224}?\271\260\341\277\236)\333\276\356\266\205?16\352\277\327\332\236\277\322\241\243>B\327\313=\260H\233?\246r\247?\365\030\217\276\362\362\207\2772\357\314\277\230J$?\254\307\236>\221)\256?\356\314\275\277\r\035\360\276\204e\231?\007\367\274\277-\255\007\277\352\234\\\277\325\225\211?\035\263\226<F]\361?i\261*?Y\305\323\277\261\030\305=\362U\264?\235\275O?-\307Q\277[s\261?\302\221\376\276\3203\324\277\005\023\355?\016\250n?\326\353\363>\\9\307\277\277/\324\277\363 t?u\252s>\366\367;\277d\252\207?\010:\357\277\322\343\220\276\214\\\020?\230\257\367\277k1\005?XO\034?<\272\364?\000\177\312\275\362\376\236?L(\232>\267\346<\276s?\313\277-\304\345\276\335v\276\277\307\004\203\277\331\213\\\277\305\370\337\2753\302\277?!Q\361?w\010<?\025,\353\277\232qa?5\t+\277Vb\256\277dV\203\277\250\252\254\276\233B\323\277/-\330>3\225\200\277x\374\333\277(\345\254?6\325\257\277Y\243\373?\242\210*?\304\311\375\276\264\371\242\277\343\0275?\234\333\350\277|\346\223?*KW?j\303\313?0\326C\277h\371%?\253@@\2770|d\277M\'P\277\270\030t\277\230h\212\277\355\021\203\275\025\037\254\277Q\311\337\277#\374.?\337\203\341?\305\t\215>\\\352!?\000\340\243\277F\002\260\277D\227\202\277+\207\221?L\010a\276xA\273?\237R\262\277\305\215v\277\021\343\225\277O7\226\276`&\366?n\3346>},\001?\262\3735\2775\300\356?b\006\220?\021\262\366?\002\351\345\277\000{\240\277%C\224\277\205\300\345\277\335\370K\276V\336/\276\217\215y?\357\362\356\276\364\262\255?_\327\201?\260Jw\277\264K?<h\007\210?n?\243\277\302\364\235\276\233\373\201\277\023\333o?{\033\270:+\245\373?\024J\250?\322\347\025\277y\010U?i\234\257?n\021f=A\233}\277\344\267\272>\201\352\227>\024bD?_\261\016\277B\241\362\277y\205\244\276\237\265\363\276h[p\277Q\010\313\276a\306\341\277\nl`?\035+\232\277P\315\342\277\275T\273\277J\245\003\277\317\302+\277fwt\277\030W\007>\267\334,?m^\'>\213c\245\276\321\217\024\277\033\026C? \230\361?\265\312\315\276\363\271\305?c0\231?\260\201\244?\263\266\n?>=\214\277D\212(\277\304Y\017\277\013\367\334?\242\177=\277\000\225m>>\227\023\277\020\340\256=p>\237\277n|\372\277\317-\322\277d\343\374?\316\272\371\277\260f,\277\005\267\202?1\375N\277\0367\350?\3059\346?\212$\301\277\315\177\307\277\346\265r\275\233m\346?\020a\303\276p\274\257\277\030\372p\276 \314\303\277\365\204C?\242\220A\277\322\352$?\023\331U\277Q\331\346>B\215\245\277s5;\277*1/?\3419U?\216\317\324\2776\214\364\276\r\261\317\277Z\266\374? \303c?\252\360\t\276\344\\d\276\351f\263\277\243\001\224?b\023\026?\300\221\304=2b\275?\253\203\"?\221\322\327?@\315\351<\237\313#=i\020v\277\325\325!?\360?\325?\275h\177?\335\002A?\366m\367\277\302Sw\277V\323/?\024]\252=\252\225\305?\251\246\036?\177\252\342>-\204\347>\002]\215=r\300\200?\233\332\367?\222\311p?*\353\213\276\014\376\371\277\314]\342\277\350\001\277?\362\300\340\276\376T\272?7\226\376\276\016\223\272\275\213\nb\276\014\355Q?\220WR\277\006\360\337?\306\365\211?\230\211\213\277\262\030<\276\355V\311=\2315W?\257\373\276\275\213w|>\243\364\317?\362I\330>\312\343\210\276<\352\350\277y\267\310\276\321\014v\276\027l\356?\"\245\353?\244i\334?\252\341\'>#\033\217\277K\223\331?\377q\235\277\374\342\212\277\372v\000\277\214`\321\276\276\350\263\277Q\261\211?\247~\243?1\377\237\277\354\207\227=\352\231\335?L\272\223>\243J\364\277V\264\320\277\366e\370\276XZ\316\275\304\223;?\333c\332\277-\307\366?\256\203\277?r\3010?\300W`?\270\201\035\277\026\036Y>\274L\232?\350\327\223\277O\351\357?\246\366\351\277\272\206\243?1\274\263\2760\010\342?\274\332\213>\233\253\305\277\314J{\275\325:]?\365d\224\276\212\240w\277X\376u\276<\300\262\276c\'\212?\222\013;\277d1.?\217\301G\276\360G\314\277\026\005\213\277\022@\242\2775\235\334?A\352\016?\3319\343\277\251\227N?\"E\026\276\220a0?\360^\323?^\264\356\277\211\361\007\276O\355\266\277\206\343\250\277\320\033\305\277\336\320+\276O\220\230?\325@\340?\240L\333??\301\202=d\253\347\277Q_\014>\365Z\326\276<\001\034\277U\347\326\277\023M\200\277\004q\302>h;\326?t\266y\277\324~\025\277Kh\201\277?\214K?\256\014\344\276\311\266{\277\371\nX\276c\272\343\277z\246\343\277_\001$\277\023\\Q>\233\204\265\277&v??5I\244>\016F\377?\034Fz\277Z\232\202?\r\332\364>X\235\256\277A\002\232\277\010|\315?\233\356\264\277X\275\200?\263\337\244\277\0005x\277<\272\232?8\352\262\276\365\326\030?\303\255R\277\272\265\346\277\335tN\277v\177\"\277\302\253\356\277\020]X?\224\312\340\276\025\004\323\276\326X\274?\224|\354\277[\240T?\277\025\316\277\240\332e>/C\322>\245\231\303\277[\335\206>\267\244\213\277\205eh\277\035\007\324?\026\247\352?\304\210\257?A\300\322\277\002>\017\276?v\374?\261\002\311?\003//?\324\316R\277\335M\203?\221\276\374?\262\313\034\272\306\344#\276=M\333?\202f\r?\327#\020\277\007\234\215\277\226N\214>)\344\247>\326\t\234\276\177\236\031>C\262\237\276\2446\266>9\236V?\006\242\231?\266\354W\2775d\270\277\242\241*\277{\354\236>\362\323D?.f\322\277\350\264<\277\214\304r?N\035\202?\250\251\304\277\351L\300?\260\037\261\277\307t\300>O\'\350\275\305g\n\277\177y\303\276w6\246\277\314x\354\277\251\321\303?y]\272?\223+~\277\235\347\353>\260\261\302?!\360\253\277\254\221\006?\033\350\232\277\211\275\262\277\354[\320\277\313\350\204?\222\373H?\3439h\277\017Za>^@q\277{\256\222>a\274\350=\374\364\003>\\Y\220\277\230\371\226?\3261\325=#r\347?$\n\336?\374\026\366\275\364D\266?\001\370\376?\006\036\316?\006CO\277\251\265p?\366 0?\'c\240?\351-\335\277\312\243\215\277D\357\235\277f\241\353?\353\026c\276\210u\201\277\371\'/\276\270\217\251\276\256\031\353?\266\0317\277]H\243\277< \254\277\2139\340?\021\315\027?|S\344?\372.6>\224\272\204?\0350\272?\311\030\307?\022\322)\277\2521\301?\267\315\363?\273W\353\277F*\204?\332d\232?&\301\205\277\222Wp\2752\277\336?\371\316z\277x\367\266?e\243\372?\363\366=?\016\210\262>\227}\262\277\236\347\201\277\253\354\277\277\245K\276?\271\337\266\277\303\253\204\277UE\357\277RK\241\277\247\342\335\276vm\232\277`\274\000?>\020x?\267~V?\244+\237\277\327\330\235?\021\222\227\277+\253>?\033@\256\277\211W\275?\230\003y>C\267\351\276\312\374\253\277\200\266\006\277Y\325\355?\256\023\335\274\374Y\240=\303\213\360\277b)\317\277\031\307&>\337\220Q\276j!\233??cE?\'Z\247?\021\260X>1\256\362?\332\233\311\277l\316\274?l\371\220?B\265\361\277\266s\331\275,\0132\277D\261{?\350\356\374\277,\206\001\276\247S$>\357\224\350?*q\007?w\014\333\276\334\327\241?\343\316\313?\221\014\306?tq\274?\004Y_\277\257\253\275?\3511\372?\232Sc?\216\362\013\276\006<)\277y\030\207\277^;\320\277\276\024\233?)\376\024\276\245\2669\275P\223\347\275\210\226\241?Q\263\254\277_\270\212?D\3539\276\277\320\367>\003\277\262\277\337\346\300\277W_~?\222\207\365?|[\236\277\032\3073\276N^\\\276\312q\356\277\353\221\360>\010\013\343?\\*\200>v\342\031>\344\377\376>\241?\004\277U\241\326?N\242\201?\301\336\361?\177\270\244\276\237f\342\2778\231r?\345\202[?*`\200\277h\021\221?\301C\360\277\273\021g\276;\033\232\276\216\323\347\277\344e\257?\005\333\352?P\354,\276(\000\235\277eB_?\361Zb>\237\036\315?\002^0=\026\002\263\277\2240\243\272\177\343B\277#\305\253?w\352\332\277~\251k\277\034\304\302?\372\220y\277\310\356\320\276\355\336\213\277\236\221\n\277\332\013\245?\036f\255\277\205=\225?\313\372\212\276$:\230\277\324\243\351?\250\231Y\277\260Y\262\276\367\272\207?}\210\220\276\rX\017?\224\251\366\277\212\0045\276\252\216h?\007\215H?c\304:\277\255\222$>\357=2\277+\236\324\277J\216P\277\024\006\300?q\037\366?\346t\350\276\330\252h\277r\317\205\277\024\204\251\277\266a\020?[\273\335\277}\003\332\277x!\200?de\t\277\265\377\373\276\230*1?\300n\247?^\313.\277\010v7\277<C\343\277,v\027?(\031<\276\231P\345>\240%,\276\251hF>\3650\016\277\360\223\205=\302\374p<\275v\213?\177\222\357>q!\037\277~\037\330?\2276\334\277\271[\342?\223\n\341?4\'\300\276\332\270@\277U\335\371\2774\211\317\276\272\020<\277M\000\206\277I\r\212\277\336\267\277>\242\347\342\276\234*s\277N>\324?\312\226\270\277\311\205#\277f\311\032\277\326\264p?\032\347\264?_o\372\277\033\364\t?d\342\256>\207r\332\277\177\207\342\277\310t\177=\224\215S?\272\310\235?\300\207\242??\177\256\276\036\205\036\276\307\0021\277%_\236\277*d\341?\320+5\276\266\024_?\365\232\260?d\367\254>5\207\014?\351\036\315?\335#\005?g\207\231\277\252w\306?\216\210\262>\314\271@\276\301yE\277\376\033\263\277~:\206=B\324\215?\370\003\027\277d\264g>\347\362\363\277\367\005y>\304\352\024>\355\004\226\276\003\254p>\254\\\264?\302\334\310>\341\304\337?\354\206(>)\013\007\277\336\217C\277!\324:\276\202\311i\276\357\301\262?\243\007$?S\226\326\277]J\212\277\035\372\231\276\241#\237?\3251\247\2770\0068\277\253\201\317>\322|\226\277\225[]?O\332\300>j\257\214>F\221\206\277h\014\336<\346\201\303\277\351\004\306\276<\360\253?\304\336.?h1\215?\374.\362\2771\342\314\277\3211\332?\227\371\225\276\226\006\271\277\270\336\025\277\3019\305\276\213]\333\276\377-\244=\250\311\205\277\247>Y?I\362\226?\030hl\277\3219\000?\300j\264>\2764\220?\373sU?&\014\253\277\035\023\302?s*\205?\243\006\256\277\373\222\225\277\366F\376\276%\026,?\252\241\354?}4\360>`\371\304\277b\234\344\277\300\376N\277}=\206?^\306\207\277\005v\234\276\226\221p\277\2572\234?\\\373\325\277\022tZ>\204r\030\277\024\315\301\276Y\206E>x@\300>,S\231\277S\367\226?\232\t\342?l+\261>#\206\346?\017|\247\277]\303\236\277\251\322\031\277>k\373\276\001h\007?\361p\240\277\366\204 ?\233\301H\277B\357\300?\222\021\216\277q\251\320?\233ut>\356\006\337\276\034\211\356?\345,y?#j\207?\n\302\306\277\027L\377\277\t\226\350\277B\316\020\277\315\270\366?\016\006k>\370L\355\277\337`m\276pl\312?p\031\360\275\377\316\301?\223\355\360?\264\326\346?#\377\330\277\373\263\273\277y\"\366\277\211H\237?\374\361/=\355\310\035\277\204\361\232=\"\230!?Z\332\036\277\221\233\253\276X\3050\275\214:\355\277\205\307\332\277|\024Q\277\215\363\324\276\220\375\245\276\260\023\242\277\004mh\277%Hx?\375\270\036?\177\270\327\276\3413\027\277T\317\372?\207\220\355?\01432\276Ll\367?\306x\364\277\037g\224\277cR\253?\256\305\312?/\0041=c\371\317?\371\201\325?nM\267?\331\003K\277\3512\370>$\206\215\277\3479\335\276<\335t\276;bf\277\207\020*=]\210\303?\252\337\256\277\345\t\234>\014E\325?\301\326\303?\3457\264=\343\271\027?\372\2612\277\263\227\266\277u\223\221>Z\r\n\277e\254\200>v\274n?\361\220\245\277\346\340m\277\177|\305\277\032\034\213\277)(w\277o\025\260\276Q\023\332?wM\303?\007\306\245\275\262\227>>\240\346\204?Q\203=?\277x\263\277U\323\370?\302-\230?c$\007?\273\273a\276\314\013\035\277\346i\024\277\023\220\232?\213\335u>8\265\240?\2152\320?\323I\370\277\217PF>\364\344\205\276\352\341\313=\340\254\264\277\201,\201\277+a#?\014P\256?\034\300\343\277\254\032\256\277\241\244\352?\271\231\226\277\207\331\305?C\177\014\277>\033!?\226W\037\277T}\347\276\231\000i\277$\347\327?\266\022\376\275\027\265p=\201\0063\276\366\200\203?\374\253\376=\253\222Q\277\301\020C? \304e\276\345>\344=ZT-\276\350\261\326?\241\256\302\277=\325)?PT\236?Y\275\373\277,\315\002>\333P\352>\263m\225\276\276\335X?[\222E?kFs\277\005L\346?[o\330>\024\311\301\277\3671\214?\027\372\217\277r_\245\276\231\375\330?\325B\245\277#\031\017\275\311Y\253\277\334\3002\275\024\262\032?YP\234>\227\017\365\276\013\276\316?\304\312t\277O\264\364\2771\033\356\277\301\032\201?\364\001f>,\005\262?Y0\274\277+\214\365?\003\364\216\277a\302\262=\365T\363?\337\352\205?s\004s\276\221f??Y*\242\276\003\n\022\277\341\303\036?\233\375\344?[4\240\277*>\211?\373\373\324\2778\227\275?\307\365\325\277\356%\366?\3052\276?\001\207\356?\304\317\364?\356\316\225\277\313\354\202\277\2726\231>\303C\367\276\246\333b>P\213\361\276L.\351\277\3556\261\277\207g\030?\365\322V?\027\353\007\277\245\335\362?\313\r\342\276>\213{?mh\244?\374PI\277\341\017\276\277\223\240\224?\372\223\227\277o&\225?\002d\303\277\036\302\330>\201\322\014?\315\354f\277S\264\221\276\31736?R\213k\277\254\2074\276)K\277?\373\271\352\276,\356\323\277GQ\364\277\355b\207?i?7\277\007\345\313\276oc\265\277\312j\316>\345\334G>Q\361\027\277\241@\303\277g\224\360?\0174\350?\303\232~?\212&\341?\372\307\264>TI\333\277\\\343Y\277~\332\266\276\304o\277?\007\250\312\276[\360\302\277\3564`\2772i\013<1\023\216?E9s?\334\322\365>\273\310\205?\212\304 \277\027\232\367?\2567w?\363\274\357\277\223hP\277V\255\203\2778D\271?\242\333%\277\222\263D\277\\\022\346=\262\006\374?[\376<\277\302\240\221?\345\342\312?%=\210?7\025\330\277\246\352\354\277J\305\031\277Da1\277\363\022;?\304\020\266\277bDr?/\333\t?\031\245\262>\374\025\235?\3469\232\277v\t\177\277\212`\376\277!\024\306\277\330d\025\277&>\270?o\271<?*\273,?\244b\311\276\220`\273?8\361\210>fn ?~\372\324\277gE\367\277U\206Z\276\356\240\303\277\275 \261?9\264\211\275|\037\223\276\036\371\255\277\300\371\246?v\224\362?0E\344?\273\"E>n\246\010?E4\343?N\2463\277\002\277\222?\312\341\345?K\311\375?\022\233$\277\255J\212?\321i\301?\026\267\340?\346`\263\276\337u\330\277},\217?eZ\317?7\205\242?9[t>U\320\370?\260g\275\274,\315\372>D\325\334\277T6\374?\300[\221\277\346\355F=\251\002\211\277\217AG?m\230U?\032\016\346?\336\260\312\276\263\201\004?\3278\274\276\320\026b?\221\356\354\277W\300^?\204\257\317\275\\-!\277\253\327N\277\277\326\310?\274\235\265?\234\024\371\277\316\214\226\277%#<\277\206\007\177?d\024\350?\367\024\225?\376p\350:\"\013\264?\022\277z?f\013\223?8E\275\277\275\200\311?\037*\300\276\371a\323\276S\031e?N\2433\276\3452\300\277\344\206\307\275k\373\331>2(\355?\235\210\352\277\342\307{\277\3045g\2778\027\263?\275,\212?\226l\313?\333\366\277\276\201y\017?\273i\230\276\254U\247\277\036r\004?\274\036\337?\313\236\376?-\340\347\277\223\3206?\005\357\271?\036\244\214\277\004\272\324?=\341\223?\304\342\357\277\207MJ?\357\271\232\277\244\"\034\277_\270\233\277K\214\346?\365\354\217\277Q\326\177?o\224\032?\036~\325\276\272\032\t\277\256\026\243?\247\273\372?y\013\303\277t\351x\277q\245\260=Wj\341\277\200-\372\277\205]7?\201\024\232=\375G4\277\037\357\213\276x\333\337\276\021\010\335>1\227\216?\275+~\276\354\245(?^\335\017?\230>\214?\360\374\243?\363Y\336\277\253L\221\275d\021\353\274\345\010}?\213\024\361?\247\345\277\277\356[\213? \307\233\277\326\254\303\277iT\367\277\252\020\221?\n\307\214=\226\331\346?\315\014\005>\350o\\\277v\224\370\277\024A\255\277\310\310\247?_\201n?\362\276\363\277\001\031j?d\350Y\276Kq\262>U\325\005>\347\366\364\277e\311\264\277\212\232\217\277\266\222,?\005\272\373\277\204\274\276>\005\342>?\336M\233\275-b\324\275\002\3343?\373\370\376\277\312\360\302\277\211\003\352\277w\376\245\277\336\252\">\014\"U?\340\267\374?d]\312?\027\216\377?\204\247g\275\027\022\272?\334L\341?\340\031\305?\323\004_\276\376^\347\277\261\307\213\276P\341\232\273\351\'\321=\347\276\232\277\211\277\210?Z\r_\277y{\272\277\352\246\214>m\343\305?\374\362\375>\204^9\276\304\254\225\2767\260)\277O\204\277?nK\007?$\035\351\277\341\270\"?\225-x\277Pr0>\377\016\216\277\250\310\207?\225\362\246\276\251\273\332\277\005@\337\277\353q\377\277m\037\205?:T\212?X\215\323\277\336\365#\277\233\007f>\tlt\277V\021\320\2775?=\276\226(p?\240.@\276\271S\333\277\365\242\243\277\232\225H?Z\245\327\277d\343\320\277ee\027?\302\275\275?\273\247W\276h\302\234\277\030\r\206\277\271\316\031>c\303\273\277{V\312\276Y\007\361?s\307\311\277N\367\214\277\217\250\233?5\032\234\277\353\221O\277u\027:\274kV6\275\234\206\311?v\351\250?\330\225\315?\031\357p?\205v\204>\310o\315\277f7\352?\230\346)>\033t\243\277e\364\333>\360ya?\312\235\002?\237m\236?\206\017\223\277\251\201\036?\203\303\217\277\322\2176?\325\034u?\313\036/?\025\026\236?w\361\312?a8\365?y[\212\277\330es\277\325\233\375\277\035h\376?sh\264?\306\032\206\2779\005\341\277\034\225\327?\334B\245>\254{\226\277\201\334\305\276\242\251$?6\200\320\277\314Lg?!\014\271\276\315\025V?\357v\017;\001\024\350\2766\314\366\277,\372\366?S\324\326?\376\261\317\277\315\355\323>\335\224G>\3162\212\277a\3535>Fe\243?x\031\377?\240\027\310?v\311\264?J\024\232?\264\336\315?\207\367\357\277\335D\235? \247\335?\317\360\031\277\206\336\246?\032l\315\277m\343\355\277]r\325\276;\270E\277\265\022\245\277\256\250|?\224\256\252\277\222I\260\276\241R\362\277-\351\231\277\204\031\332>\265\211\327?\232\203\314\277\177\216\227\276v9\263\277\214\261\373?\372b\n<\256+\357\277e\321\350\277\232\023\017\276\226\030\316\276l,\324?\354\334\306?<\033T\277\355\365\336>\236\315\244\276O\331S\277O6\233\277&w\000\277\314\235/\277\027MV>\354_\315?\323L\372>[\240\242\277stW?eX\332>?\264\232\277!\256\216\277\353\364G\277\356S\361?\026;w\276\002\206\237\276d\206\232\277\231\021\234\276\006\370w?W\372\035\277\361\320\352\276S\271\374?\235\3072?l\036\323?U\366\037?\257;M?\235L?\276\251h\225><Z\234?\311\022\256\2779Zg>M!\207?\265\326\276?i\260\265\276\334\366X\277=G]\2773\001\024\277\342w\322?E\325\254\275kdK?\235\t\372?\237{\250>\'\256\350\277\265R&\277\2041\346?\026/\006?\247\370\273>\350`\036\277*\254\346?\300\343\330\277\002\355|\277\335g\200\276R\201F\275\302\302|?\265\004\212?7~q\276l\'\311?\234\211s?\231.4\277S\353\022>\t>\365\276\216\001#\277\003\300\037\277^=U\277\277+\254\276\202\361\003\276\257\306\273\277!\332\213\277\014n\366\277\332\313\321\277\027\037\317?~\030\266=\234T\330>N\352f<\255p\220>\326\363u\277\371\314\251\277\351\315>?+\020n\277\275W\200=\225\306x\277?C\270\277\235\360\212?\021\377\272\277\300\260\204?\212\"\345?\301 6?\236Sy?\204{\317>v\"\313=\013WH>\033y\337\277\341\223\207\277CBC>\327\255\270\275!{Y\276\rB\307\277\357\033\226?\251\201T?is\240\277S-\326?n\264(?P\346(?G\350\362?O\210T\277R\376\300\277S\316g\277x\333\365?\221\003\304\277%\207\251=\216\023\257?x^\345>_\203\240\277\210K\346\276\031\306\241?Qv\177\277\006\213\261\276\310\274\230\277\002S`?0\364\351\2763\210\207?\267\256w?\311\352\351?\002\211\205>\302@\334>s\223\303\277<\016\201?\010\263\376?\335\322=?\025\376\255\277\265\315y?\013\352\233\277w\267b>\301\r@>\264\307\350>\347\326\210?\203\267\214\276\301\241\277?\304Xl\276\337\331\272\277\345\237\264\277\326\364\236?\231\324V?\301\217\331\277M2\303?T]f\277\r\235\235\276\t\346\321\277\251h\007\276\033\355\227\277\300\336\t\277\3158\210?\316\374\343?3\266\005\277\242\2522\277\200\302Q\277\237\014\237?\331h\363?\030\257\321?\000 \032=\203\232\030\276\324\306N?\275\356\263?V\n\260\277\374\255\336?\245\213\233\277e\024{?95L?r1\223>p\240\371?\343,X>\327\234\212\277\350A\230>FI\200\277`B\373\277\362\231\324?\264;\322?\374\217\247\277\001\377\341\277\323/h>\013\352\323>\263\337\357\277\277\221\217?\213gC\276\305\245`\277YH\352\277\236\241Y\274m\217\266\275\010\333\255\277\014\377P?\371\230\364\276k\324j?\304\235\345\277\257\225m\277\242\374\376?\313\344]?\317i\334\2771\207\347\276\211\001\347\277hS\232?\327K\334\276F\357\250?\0132\257?a\001\351?4\321\306?\316Gm?\352\250\223?\200\200\346?\333\367:?\346\234\020\277G!\225>9\177\271\277\n+\276\277\306]\333\276M\260(\276&\331Y?\256\271&>J\277\031\277\374v\254>h\272\335>\021k\241\277-\247q>\254\247\372>`\366\263?\232Z\233?\340aP?\272\216\025\277\2221c\2778*{\277\343\023<?W\202\202?\346.%\277\205\333\211\277t\275\t\277\\]h=\276W\307\277N\202\310?\224\253\204?\354\244\212\277p^\366\274p>\024<\026oy\274\331\"\022\277v\003\233=\345\326\255?\304\307\314?\206\206q\277\305\206\247>\000q\301>\320\363\243\276\331y]?e\327\303?\366\321\376?$\"\221>Q\022L\277u\266\231\277D\210\337\2762\261\351?ot\223?\234\245\250?\345c\247\277,q\225\277\227\207\215\2765\035\272?\222\002\233?\263[\303\277Z\321\246\277\305$\027\277$J\300=yp\361?\321\020\'?\347\205\311?[\376\264\277\004\016\256=\006p\322\276\017\262\233\277\326\364\332?\024K\304?\004\356\345\276\224y\310\276\2025\251\2766\254\225=\242Y\371?\265\306\352?\0219\017\277\317\313\235\276\027\321D?\226\227v>\212MT?Y%\351?\251\300\014\277\302|\226?\267\\\365?)@;?\360B\270\277\320\226\376?\231\264\350\277dE\262?\000\224\316?/\345\200>\220\212\223?p\016H\2777K\227\277\223\337\215\277=\3656?\370\270\022>\377\035e\276\370D\345?\235\362\234\277\270\316\341>\265&\321\277\0344\275\277\337W\372\277}\2627?\317- ?0\271\305\277\364\033\355?\005\374f?a\305\354?\322\253\035?\0165\305\277\233\314\317\277\243\315\350?\316\304\311\277\273I\306\277\235\030\364?\226<\000?\002\277\034\276d\324\250\277}~\222?\035O\347>\024\216\337\277\267\225Y\277\\\300\335\277\n\235\354\277\243q\325?\251{\360?\360\366\225>\200t\257\277\270\221\345>\205\na\277\247^\271?\226\032\311<\017Y\361?S\205\204?\253\263\222?|\271\204\276B\233\250?\367\342\345\277\000\347X?\216\r\244?\244(\037?\352f\355\276rV\245\277a\177\371\277\022\353\'?\250\247\027\277e=\332>\021\004\250?\261\3529?\365\237\242\277\020h\344\277\236\315\317?\177\241H\277sw\333>g\304\032\277\354\225\311?H\001R?Z\007\320?}\264\265\277mF\240?r\322\351?HbF>*\305\212\277>v\231\277:\231y\277\20624?Lg<\277uv6\277\346\221\354>\303\213\266?D\000\304?0\277\227?\027\232\366\277\372\ru?\020)\227\277\\\353\335\277z\264v?\037\363\262\277\036J\254?\306!\302?\257\245\330\277\255\330\022>\226\373O?NE\241?\234\014\005?\354\0045\277(N\345?\260\017Y\277\315\325\205\277\245}\325\277\002\3422>\231f\356\277B\312\314?\222\nF?*\323\274\277\024\244\354\276R^\014\276\023\033 ?\240\005\355?\\\274\333\277\375\337\321?u\214\361\276\273\313\316\277\253\224\341\276gh\t?\032\326\331\276\232\370|\277\353\206\244?\323\354\316?\3128\326?su\312=\376\317\261?\034Q\313>\205\316\271\277On\322\277\237<\204?0\271\036\277\2069\201\277t\210\221\277\036\327\227?s7{\277)\225\326?\022T!?\241_\257\276\256\027d?\037O\211\277_q\035?\364\037\242?\325E-\277\320\241\214\277\013\026P\276\370\030\236>8\200\217?\260\001\340\277\2679\346\277~E\370?\204e\356?\224\234\017?\211\315\250?Z\355\347?^J$\277\005R\312?\202\207=?h\311\263\277\326\3059\277\273T1>\352\227\247\277\007\321\275\277qc\243\276\002Q\361\276\343)\243\277[%\036\277\343]\231\277Y\034\275\277S]\263?O\017t?\024\273\375?\275\375\334?\360\327\336\277\372\367\340>\376t@\275\353\373\302?\033\204\224?\270\354\277?u\350\340?\376\203n>U\224\302\276\346\340\370?N>\331\277\023G&?\037\371^\277\007_F\276\1776\337>\033\245\272\276\304\033\030\276\252\346\341\277\332\232}\2773\210\360?\nQ\303\277\334\324\320?l\035\326\277\341w\210\277V\317\374\277\203\250q\277d@\371\277{J\225?\274\224\347\276\342\232\362>\371\010\263\276e\027n\277\034\202\242\2778x\271\277 v\244?\022\244\312\276L\335\326\277\271r\331?\006\234\211\277(\375\360?7Zk\276\321o3\277\362\006\256?\361B\247={+r?.\001\214?\314\014\337\277@\034\037?2sb\277\332qI?\357\273\257=D2\320\277\030\225\372=\022\013\242\276\362z\375?qv\330?\230\021\362?*\234\260?\335\255\227\275\220\256\022?\370\272-?\316G\010\275\213\215\324?\t\350\344\276p\245\356\277\022\201m?B I\277\201\352\037\276\375\362\256>P9\354\277\323\n\377\275\345\315\321?\026\207y>i\216Y>!w\254\277\017\222\245?\370\362_?\036}\363=\3549\341?\343!\001\276kW\212?UZ\270?\353\216T\276\365T\363<\3645\252?\225X-\276\227\322\217\277\266\225v\277`r\317\275Cp\357?\331\324\302?\311\035;\277\270\234\357\277\374\021Q\277\230\034\235\275.\266\347?|\311\202>=\006n>\255X\354\276\\ \014\277N\335\316?\215\374\304\277\321E\360\277\020uD\277<\214\360?\371\333\211?\373(\245?\341v\346?\320X\027\277J\244\001?\024P\222>\214\264y?E\216\273?\370\256\202\276\352|\234\277\352\323\221\277p\032\227?\267e\363\277\311\217\275?\323\177\204\277\232\331\276?\324UH>\320}\232<\3000\375>\236\230\353?\027\370\326\277w\005\003?\336\347\214\277\035\351\245>r\241\336\277\276\3338?#\036\376?\3263\313\277uT\201\274\215Hx\276\210\357O?\250\016\017\277,\010r\275cQ\214\277\260\306\306\276\271\330\304?7\237\201?\374\315\326=\252\363\217?\254N\363\277\224f\'>\206\316\211\277\212\271=?c\234V?\316\272\227\277\325\361\244\277#\001\337?\034C\301\277b?\022\277\215\376\322\2774K\360\276E\224\246>I*\211?\351\\\266\277\244-\232\277\336\227\230?\246w\256\277\022g\210\277\361\201\214\277\350\242\243?J\274\272?\226L\366\277S\353L\2773\377\033?\240\220\337\277\310aV?glR\277\333\342\271\277\007\024\322?W\000O?\325\315\333?\230\002\315?R\206\276\277\210\230\265\277\016m\221\277\025Y\267?X\211\270?\327,\237>\245\227s?\r\002s\277\223\311\277\277\336\224\214\276\277\317\207?\336\312\252?9c\371?\306\263\365?5\315\216?[\271\316?\r^\304\2762$\270?Zq\353\277^yo>>G\272\275!\020\221\277\367\231\310?\343\036\332?U5\210?J3I?\206\231\316\276Q\354\334>q,k\277\234\351i\277\271S\335?j\237\346>1J\352\277\221_1<\271Ga?a\014\207?\003I\360?\351\006\234\277\314\202)\277\214\315\302?\234@\244?\035\350\355\277w\3007>s\271E\276C\247\037?\177|\320\277\270f\205>`\016.\277\371\341\207\277M\206\023\277eR??n\363\277\277\223\375U\277\273\013\204\277k%\243?\022\231X?<\304c>\352\237\225?h\271\312\277~PB\275=\010C?\325\376\034?L\007\330>\332l\243=*l\372\275(\\7\277\277\265\366?y\373K=/\021\247?\354\265}\277B\253\364\273mx\242\277\267\024\250\276\030\210\313\277f\013\316\277\025\254\002\277\220W\237\275D\222\247\277P\215\345\275\351\345\344\277\335\006n\2772\256?\277\265\300\n\277\260cT\276s$B\277\330\221\235\277o\334Z\276\375\367\340?\027\302\261?\005\334\362>H\262\316\277\361\222\370?\n\252\242\277d\007\347\277#\311\220>\240J\265\277\360\253\224\277\242\233h?\273\322o=\007\031e\277\225\010\244?\332\210!\277\001\233[\276\372\344\333>f\346\354?\2621q?\003\373\255\277\253F\200?\347=t\277\325=\303\277\221\365\200>\325O\367\276cv\220?h\370 \277\233\3024<\3641\341>\016\253\366=KXK>\227W\205?oV\273\277\354:\356\276C\317\367?\352\265\362?\346\361\366?-\216\267\277D\260\311\276+2\372?\\\220\206>x\225\352>B}\306?\212\322A?\227]\347<\255V>?\311\313\033\277\n\334\315\277\\\232\026\277\0148^\277\3201\346\276\303\202I\277\247\372\265\277\360\366\312\277\261x\274\277\305/\037?\271\000X<[\026\267?\360\177\025?\034\027\311\277\376\007\276\277-\341&?\364!\354?\336At\277\305\304\373\277$\202\244?\220;\240\277\222:5\277\231\031\352\276\367V\227\277Z\376\364?\261\037d?\227\330h?F\241\373?K\213\325\276\016\356\275\277\322\364\336\277\353\371\027\277\2075\243?\372\327\257\276Q#!\277\255\033\224\276y\330\350>L\000\324\277\311\307\320\277+\224\377?\216\217\032?\020mp?Z\032\227?d2\236\277H4\257>\326\202\274?\263\255F>\320\347\371\276\0377\354?\374\201\204?\001\376+=\265\271\230?\301\306\342\273\316B\200?=]\340?M`\221\277\177\265!?\343\253\311\276L2\336?s\2637\277_c\247\276a\023\323\277g2\235?{\253\366\275 \226\341?<\250\020?\\\335\303?\033\322\030\2771\010\210\277\006c\215\277i\200\270?\304F\320>\272\353\023?mc\234\277\t\374x\276\305\260h?I\277\260\277\361\216\344?\310C\342\277A\273\340\277\372\241O>\267c\324>\333\364\331?\251\306\326?\027\204\203\277\372R\232?pJ\031\277K\000\204\276\240\031\277\277\230k\251\277\016\255\207\277\330E\377\277mx\350?UY\256?\202s\236?8}\324>i\340\333\277\256 \357??_A?4\013\220\277G+\230>\334C\335?\022\344P\277\td\252\276\355?\317\277\332`\362\277\014y\025\274\225\363D?\237E\265\277b\345\276?\323g\206\277F\321\241>\201\373\221?\226\311\271?Y\3717\277\361\205\224?\234F\216?:\200\272?F@\216?$\214m\277\312\033\341?4\240\360\277\343\336\272?\306\253\275?\215J\260\277\362h\212>\316\313\214\276d\352o\277`m\237?\211\233\203\274\'=.\277k\000\032\276\207\022\032?\0136\231\277\000\373\236?\177\337\367?\365\365\220>\335\332{>\265\206\371?&\217\250?\365H\240\2776\214\023>\032 0\277\302\264\315\277\035\307~\277\242\n\346?i\256\252?\246\257Z\277\306\375\237?^Ti\277\202C\326?\225\250\356\277\204mM\277\3259|?\3638\235?\374B\225?eN\270?4,\331\276\235\020>\277&\351\241?\230\311:?[\232\211?+k\345\277~\311\315\277Xy\247?\326\222\231?7\363\303\277\224\357\262\277\3313\330\277\307\367\230?z\177(\2773\364\314\277\327K\334\275\310\2216\277\351\035\022?Jt]\276_\350]\277/m\213>\250\315\036?\024)\235\277\010\226\362\277\016\320>?\007\315\306\277JH\231\277\311\265B\2757\203\254?\024=\027\277\210\230\027\277\306_\316?x\315\262>\215 B\276\251\005d\277q\035\315?\347\031!\277Y\264\373\276\264\n\354\276\377<\373?\371\034\266?\370\315\343\277\003\302\240?\202!R<\361\273\362\277$\207p\277]>\253?]\223\006?P\330\300?\034\3262?\036~\215?\376\233\302\275\357k\341?E\224\247?\366\314\361\277\020/`\276i\017\313?\021\"\320?\032\245>>\267\310\332?\005\323C?\302\227\321\277\221\035\300=\036r6\277/T\353\277?\371\360?\010\262\350>U\262\216\275D\\\360\276\2150\353=j]:?@.\307\277\2401F?\331f\221>}j\353?q\303\205?\266\315\211\277\207\020R\2773~\245\277*^\035\277\024\032\223?\306\375\214\277HE\264\277B51<\301\013\350?\021\335\324\277)\343\220?\203\330\235\276\231\210q?E\270\273\277\037\360|<\367W\346?47\363\2779\234\240\276\317}\252?\240\330Z?\336Z\366\277s\343\230\273\023\222\005>y\224\377\2752V\025<=\000D\277\206\233\030\277\204#p?\366:\336?(H\245\276\212\236\310?\267}l\276\334\033\275\2764\346B>K\330Y?\033\217>\277a\200\265?9Si\276G\354D?\225;\243>\004\220\252?v\272\'?\371\342\022\277\364\307\321\277Lm\016\276\024}\344\277\tY\256>[\\\373\277\023\246V?\266\014_?\354`&>Lx\363\277`P\323?\035\313\271\276\351\300\324=[/|?\211yV<\260\223}\275e+L\275\030\'\017>6U\232?5\325\355?\327h\027?\t\207\366?+\266\036?\021P\376\277 \305\350?\374+\232\277\250Ow?\2165\000?\233\004\206\277\022\237\266\276\226{\'\277\375\270\230\277\330*\341\277\311*\270>\274~N?\233\031\376?\274\030\177?Z\241\337?\313\032\361\277e\004\373?L\223d?H\333l=4\234I?\362\213\205\277\234\341\314?\303F\346\277RnF?\266ut\275%\316\352\277\226\320\322\277tIb?\005\262\337\277\335\203\212\277\205(\263=z\n\233\277\024\244\275?\315\271\227?\004\242\020\276\320\217\335>\017Z\000>\017\220\356\277x\005\264\2745\222\240?\331\\\253\277\3029\024\277sD\307\277\240\261\331?\rY\223?\206s1\277\3025\267\277\241\234\335\277\350e\325\277K\245o\277&\205\242\276[\017O?\246\227\360\277-m\007\277-\251\236\276\260\257\303?\210\370\037\277=\363R\276@\3654\277\374\3451\277\203\273\251?\222\304*\277\177\237\367\277e\274\360\277(0\223\277\332\317P\276\342A\r?\236K\271\277\205u\221?\267\215\241>\356\324\322\277y\344\202?\020E\353?\n\251\034>Wu\327\277\317y??\370w\235?#:\254?\017\233\365\277\221R]>\302\373O\277\001o\001\277\0140\361\277\203\034\002\277C\003\235\277\343l\222>q\037\352\277v\241\210\277\345H\365\277\202Y\205?Xs\370?\314\223\356\277\232\246\324?\272\324b\277\272A\316>2\225}\277\265\373\374?\370\356E?\227<\001\277@\230\302?\324\320\373?\227\256\023\276\037Oy\276\261\352\246?\206\205\255\276j\331\253?\035\n\345?s\325*?\n\207e?\270h\345\2773y?\277\355Z\222\277|a\337?\252\2644?02\247?#\276}?K}H?7|\377\275^+K?\330\347:\276X\020%>\'\224Z\277!eC?\023\251\330\277\226\324\343\277 7|\277\222\243\203\277\315uU>X\274\234\277\360\350\240>1\210/>{[i?X\010\241\277\202(\335\277\352\255B>\302%\201\277\351F\343\277\244\304e=\030\303\375\277\366\220\351?\034q\030\277\314\001\305\277\n\363\320\277H\321\346\277\243\002\'\277\220\223\265\272\304\254\t\277\330\216\274?\223\002\215\277\243p\350?\021\346\006\277\004KJ=\350x\357\276\032\032\305?\263\232\207\277\032\245\303?\037d\225>\352\n\245\2776\\s?\261\350@?\200-\314\277|w\256\277\244J[>\235&\030?\242X\260?\010{v\277g)\363?aJL>w\037A>\334\"\204?R\340\347?\276g\212\277\202i\306\277?\307\224\277\237\347\022?\037\032\266\277\207\301\254\276\354\266r?x\"\302\277O\254\007\277\367d\342\277h9I?\235G\201?\212f\222\277(\205\310\277\007M\007\276JE\325?Yg\273>=\300\272\276\211K\030=\t\272\353\277\003\265\323\277F\217\001\277j~\337?\014\257`\276\317\032\235\277\347}\327?\235\272\020?b\006\246\277\007\275\352\277\332\'\251\277J\267b?b\215\270\277\323\227\341\277\246R%?qV\336\277\364(\271\277u\232W?\177j\023\277\036\376\347?\264\204\207\275f\252\366\277\323p\306?\262\224e\277\211\237\364\277\355\306\010?h$\263=\320f\017\276w\271\367?\235\001I\276\3711\202\276[\000\334\277\023\002\325?\323\347\361?:\300\213?f\252\241\277\2331\242>9\254h?j\220_\277\005\217\206>XN\374?\245&\244?^Q\242\277\002\376\303\277\234\313\314?\030\375\326?\027\223\264\277\221\343\263\275\305\203\336\277\261#\240?P+\230\277=\251\253>q\377\003?\207\241\317\277p\014(\277\'A\374?\320{\227\276\350\257\243\277\264\177\343?\204\244\343\276\234w(\277\355,z\277\030\344}>\262\221\334\2777\007\320?\273R\237\277\316\312\275<z\212\312?H\250\242?\230\272\\?\303f\337>\3144\271\277\300\367\307\277\276\224\217?\205 \231>7p\206>\367\277\221\277\016A\255\277v\320\005\277\315\240\217>\357\004\305\277\221\353\215=/\251\205\277\233\271\022>\210 \207\276\274&H\277\377i\245\277y\252\335?\337\306\215\276@f\353?l\252\245?b\342\234\277\254\262\270>d\324<\275\025.\277\277\202\264(?\215\232\313\276\372q\206?(L\360\276>\027\255\275\375\350w< k\374\277\330\266\260?\2455\000\277,\362\222?\026\311j>Y\014\267\277\366M\235>-\341\364?\241\251\n?\311\305\234\277u\303i;\250\302\327?0}\006?\212\2052\277\241\027\376?\274h\256>8Md?7\241\253\277\325\025\320\277)\300\243\276v\276\034\277\347[$?%3\241?\243\246`\277\224\3157?\264Y\343?\322\272\311\276\243&7\277\035\236\336?\255\327\r?\370\237`\277\270\234\273?\306\367\336\277l7\312?\262\370\230?\326.\360?\n\376\347\277gl\317?\235i\256\276\306\363\204\275s\220\306\277k.\215\273\250!\352\277\013\370\242\277\343-v\277,$\237?\"\241\205?\332\266\"\276c\325\277\277\232\352\270=B\216\315>\243\256\353\276\032\352\240\277\250\034\363\277SV\302\277\256\341\202?\031\360/\275\324\024x\277\214\204\336?O\355\233?o\027\210\277RP\031\276\226\003\243?o\344\027\277i\250\240\276\222}\255\276\334H\204\277\210>q\277\\\304\231\276\335\206\340?0\302A?\230E\355>H\2261?\335\014\200?U\341\212>\331Z\207\2774\000\204\276}D\366?bi&>\370$\336?\352\225\234?\207\022\364\277\253\374\341>)\326\207?\177\202\317=?\026c\275\031\212\333?\265\027\312>-6k?\021\352\233\277,M\024?\377\347\223?-:\014>\216\036\237?\213\307\022?\230oc?\251u\311\276\031\260\322?\320RM\277\225\037N\277\222\262\242<\221]\205?1\204^?*R\327\277/\030|\277\332\3212?\341\312\342?/)\334\277\375\223\317\277`\264\005\277\005\034Y\277\241\314\247=\262\372\356?\347Cr?I\340O=\240s:?\366\223#>\336\223}?a0\261?\025j\030?\331\376\270\274\360\265\374?Y\205e\277\267\336\321>&y\343?Z\017\227?\001\247;>\256O\200\277\237\351\375\277\303\347\362?O\333\276\2772\342Y\277>\213\224\277o\304I\274\274\350\320?\010{d>\036\217\224\276\361\363r\277\3570\334>\352}\026\277;\270T?<I\342\277e~\"?\\\201\277>^\035\310\277\305\037\300\277&4\214?\nG\234?1\204\023=8\340\346?\357Q\243>\214!D>%\002\330?W \224?\3709\376\277\366\324j;b\303c\277\224\326i?bK\006>n[I>\265\334\372\276,\033\367?\244?\353\2777\031:\277\347\003\250\277|\374\324\276\200\343A?\200G\203\277U\273\016?of\343\277$\007M\277\032\351b\277j\325\337\275\260\350\375\277\227\263\240?\203I\r\276\256\001o>\245\314\355>\376\375|\277l\037\370?\'\223\246\277\350\322??\006\363\265?v\331\372\277\227c\246\277\352I\343\277,i\243?q{\265?\313L\233\277\205\033\352\276\375\331\247\277F\307\321?\352\371\306>|O\207\2771\203o\277^\255\321=\037\021\201>\\#\366>\343\367\365\277\235\261\203\277{?w?\270\204\347\277\036\310\224\277\203Z\357?\035\275\317\276&M7\276\241\373J\2777\251\250?\320\270\306?\261\027\304=o\232O\277\023R\252?OL#?p\223\311?\212\305h\277s\272\243\275\267\370\260\276\025\353p\277\271\367\212\277\251\254\336?3\217\233\277`\237\230\277*H\317\277gYA>#\016\317\277)\251\246?\213\214\327>\312\333\263?9}\355?\212\342\303?g\307\260>\301\017\270\277\016p\315?\352\030\014\277\343\245\315\2763\3409?=\334\307\277\334\3707?\210m\356?<\211\364\276IX\325\277X\0008\277\366\240\305\277\226\366\356\277\223\n\321?8\346G\276\305s\337\274\250\274a>r\222\311?\352\351\300\277\231\206\266\275\211Au?\022S\340?\263\202\276?\313\313\037\277,\236\026>\264\177\262?\033o\023\275\310\267\343\277\200 \343\277\272\334\335\276\006\367\317?\031D\363\277\243\024\224=\261b9?\272\373\214>\022\261\241?\352\300\256>\360m\252=\363\355\275\277\356\327\213\276%7\332>\315\003\300\277\010\2221\277\324jv\277B\2425>\324\3137?\230(f?\277\367\362\277\216\270\202\276\236\365\240\277\212*6>\214E3?\036\r\237\277\001\2117\277\256\320\366?|\204\365>\301q)?\323\002\251\277\364pE\277Dl\254\276\030\251E>\014\366d=\002\001(\277\267\0175?\200e\005\276sfE?\"\310\373>R\245\364?}C`?\'\233\272?$\224\317<\256\030\335?\264y\320\277)2\322\277i\034\032\277\261\363\212?\026\017\024?\302\310t\277\350A\251\276\210\205X\277\333a]\277m((\277W/\306\276\335\0333?\311\373\374\277\210\345\216=\334X\000?\312U\244\277\273\321\276\276\0149\\\277df\341?H.r\277G\340\271?\213\205\306\276\\\262|?y&\314\276\0042\025\277\314\324J?\272}\211\277\347h\347\276<\273\361\277+@\367?#\235\320\277\000\205\247\276\251\036\205\277\213\266\217?(\330r\277\306B\322\277\270\213i?c\353\260\276\260\376\373>d\332\344?9/p\276\357pV?\271Z\035?\221D\272\277v\350s\277\335|\300?>\000\341\277H\3403\277\017\354\270?\343F>\277\365i,?8\177\332?\t\\\266\277e\205\213?\362\205\362\277\256\\\\\277\337=\227\275\n\366\363\277\253z\304\276\242\373\350?\261r\r\276gG\000\276G\250F?\360P\233\277\263\260\201?\273$]?\2124x>\204B\352\277gc\355?\262\300_\277&\304\247\273]\3612\277\300\304M\277\324t\304=\257\311\177>\373\303\346\277vV\215\275k,\234>C}\345?j\205\341\277\363\003\265?=\005\323?!|<\277\211/8?\271>\370\277\347S\215?\003\241\365\277\000\307\277=\371\203\206\275\221\3223\2772\020\217?W\300{\277\017r/>3-\017\277\"\024\341\277tw\026>\254\037\317?\321[\020?\356\002\t\275\213\212\021?\177cw?\305\362\321?\323o\267?\377\341\366=N\372\262\276\026\016\315?*\014\315\276]@p?\327\254\314\276O\007\363\275\233\017\277\277M\032\021\277\016F\313?\344\224\326\275\264S\221\276*\033\236\277\263\004\362?F\305\242\277\275\370}\277\363$\217\277\010T}\277\211\334\350=J\232\355\277L\242\331?]\327\315?\247\275\t?\213\234D?W\347\276\276\255[\231=\263\tn\277T\224\311\2770\202\362?\201,\300?\342v\274\277\241~\212\277\004r\217\277_;W\277j\353\256?%6\260?\264od\277C \216\277\315\361?\277\370\2549?\302\251\014\277\302C\331\277\t\311\207\277!\346\216?H\212c>w<\326\277\366.\"\275\245$\361?\346\224\261?\362\377\223>\213\013\252>Z\360\244\277\007!\251?\313>;\277\025YS\277\207B\261?\275\014\337\277\313\200\261?\365\375\362\277\034\257\265\277\310\300\360\276Y\256\363\277c\267F\276\275e\224?0\251\335>Z\007\221\277!\2353?\002\213\223\275\252\353H\277\353\350\333\276\3117\355?X\030N\277\305\324\364?\270\221\204?\004&\273>\264\000\231\277U-\241?L\220\256\277\353p)\277\351\263w?\236\'3?\277-\361\277^E\307?x\245\005?\351G\372\276jag?7\237t?6\240\311\277\206\234\035?dE\323?\272O\356?\274\342k\276\223r\225\276\007\346\235\277Y\352\305?\013y\232\275\203\266\303=\323\207\371\277N\025\372?\316\310\206\277\323\223\311\277[\212(?u\301\205>#0\001\277\311\204Y\277e\230\372\277f\267\250\277u]\341?\274\327M>e\010\256?\036\344\360?\033\0241?~\367\335?o\233\023?\300R\'?wF\321\277@\034\341\276\243+\206\276\234\177p\277m%\227?\177\236\020=X\003\266?\365\247\350\277W\221)?ZJ\025?[\366t?\340\247\302<\260\346\236>\tV\265\277\256\001\252?\017\336b?\021\001\212\277H\376}\275\r\030F=;;\330\277\025+\254?\n\336\327?\316\323G>\274\005\236\2774\207\336\2767\227\275\2774\262d\277\353KP>\2766\200\277\315\317\020\275\267\220!=^0\252?H\360\240?jI\321>A\242,\2776ms\276\344\332\243\275lh\267>\2217U?\344\217l:qI7?s\025\030?\334\037\367?\341\177\001>>\262\322\276\356M\010?\030\346l\277\247\370\252?\2443h\277\004J\372\277\350nI?\351;\317?\363\030\356?\014\3428\277\207\'\312?\261\356\336>\214\316\347?\231L\373?G\252\201\276\211\231P\277\211\366\245?\"\2768\277\"\255\200\277\010\331\004\277\274\244A>\331\257\016\277\244\017\t>\034\t\333\277\\\366\227>Tg\276>\'>\035\277\301\006\315<\274\377\224\277\367c\322?\342\343\230\277\327}\235\277\310%T?\210\205\315\275\227\300\215=\214\n\274\274\264\003\237\277\377\3263?\275+\371\277H\314\263\277\311\231\373\277\037\230\354\277\024\373N\273\310\303\356>\300\261\374>\331#:?\342\253;>\200\262\020\277\231o\005?]_\222?\267\242&\277\364\004\344?\345!\032?\256Lf\277\251e\377?@=\301\2774\032\r?\306\367\253\276\236\330\353?]\276h\276\355\336\236\276\204J\213?\212_8?81\032?z\360\267\277eX\232\277\370\021\353?\210|\004?K\365\034\276\347\200s>\244\240\345\274\354\000\215?\275]\203\277x\312\354=m\\u\275\304\201\313?\005\241\374?\"\341\263\275\252\th\277\275\307\244>)2\325\277\301g\212\276\2079\342\277d \316\276\241z\361\277\027\340-\276\026\036\374>\037\263Q>\002\221\217\277\035\256\321\277\033\010\002\277\177\3730?\250\232\272?\351\256\366?#\022\244?\004\372\016\276\341G\311\2777\352\201\277?n\341\277\362Z7\277.\307\246?\336W\207?q\334f?\365|\010\276\327\305\245\277\235H\315\277\030\022\376?\242\026e\277Z;\311>\276\254\376\277\350V\322\277Wr\227?L\017\213\275B\305\322?\0061\357\276\226\213\300?\262\205\302\276z\321m>\242\372\200\277\253t\262\276S\277\373?$\366\202\277X\270\010\277\314\200\233\277\311~\377\276\356\005\277\277\224i\250?\266\277\213?\203\236.?\276~L\277B\214w?yC\031?`\256\367\277\"\037&=c$\302?|\262+\276\275\374\322>P}v\277\025\267-\277\204\314\343?\270Xs>Z\n\322>\370\325\n\277u@\336\275Xj\365\277\206~_\277\270\000\327?3\271\211\276c\032\271\276P\371\317\277,\\\177\277n\025\226?o\\\320\2771f\243=E\301\251>\253\336\254?Y1\036\277\200U\234?s\336\313\277\350\353L?\362)9\277\241\031\374\277y\017\216\277#P-?|:H?\214\306\205\277\301\324\330?\320iU?\021\005\337\277\246\331\305\276\361?T\277\262\304\202\276\376t@\277\004\311\245\277a\026\331\277f0\353\276\302F\335\277\340\354\017>\031r\306?\\\204\340?\020\320\037>\257\263\264?\234#\352\276\332\365<\277L\200\322\277\314\0224?\263\330\354?\300\0050\274\275\0004\277\345\344\253>\221}\302\277]\361\207\277;\306]\276.\031&?\372\360;?\037ba?\"\241\271?\315\326b?\326\266)\277C\244\265>P\323\324>\342/\236\277*\240\014=\037H\241?\315?T?\026\227c?\2230C\277@\340\310?\207\237\356>\324v\315?\334\003\233\274\204\232\222\277\336\311\343\277\022\215\342>e@R\277OG\233?q\005\276\277\177H\361?\037:\244>\371D\035>\202\351\220>K\241\336?4\335D>vGS\277\261\t\246\277\211\370\233\277\305[\332?\355^P\276\242\314D\275\262\241\225\277g\233\342?\033\324;?S\271\254\277\3402\260?3\023\206?\300R\302\276\331\033\272\277`\037\231?S\004)\277\004\334v\277\037`\033>{~\300?.|\373\276\020\223\372?\017\314\265?\232\356\237?\004\246\334?\343\321\355?w\217B\277j.h?\241\350\252?Z\305\247?l_\254?WV\224\276Y\345\010\276u\\\367\277\256\032\363\277=7v?%\326n?N\351w>k5\333?\357j\312?\027\314\201?\303\305\\>\323\374%\2774\250\214>\222M\367\277WL\320?\024\337K?mf\255\276\222\324\034\277\344\255\316\276\036e;?\027\333\250\277\341\354w\277\340\341 \277A\204\017?t,\245\277\255=\253?$\026\276?\231@\272\276\374\3707\277\244V\250\276\300\247o?#X\237\277\023/\016\277!r\n\277\256\032\237?\n\371\271\277Pd\223\277m(\243?\245\371&\274\255\260\265\276\376V\332\277\025\231q?\314 \n?\320j\356?1\305\211\277\302\357\227\276\027\351\311?+t\374\277\376\023\377\277w)`?\216*\375=j\004\274\277\372\377\321\277\205\220\230\277\030\336\272?\033\016\226?X\017q\277t^\314?\200s\236?g\333\223?K\020v?\341u\252\277SB\022?\031J\006\277\331?\223>\007&\222?\201H\260\276\200\364\312\2778\020\301\277,\377\270\277\377f\252>\200\332\343\277\247>\037>\2379\271\277\276\313X\277Q\323\222?a%\317\277\241\304\350\277\223\211\343\277\342\230\375=I\013\361\2774\210\233>\270\360\234?\324\024\302\277\311y\201\277\005\235\230\276c\340\230\277\212\341\243?\307\243\370?]\263\331\277\212\r\264\277\301\224\002\277\265<\265\277\343\315\375\277C \317\276\364>\335\277\361\037\334?\337\016a\277\030\373\000\277Q\262\247?c\247\"?\301\223\007\277\\\002\263\277VP\206\276*\211\272\277^\013\261\276+]\035\275>h\301\277]\242\n\277g\016\361\277\312\020\334?\372\241\326\277\264\252!?\241(0\275\214\013\366\275@U\362\277\367\024%\277&\352\005\277\223z\331\277$D\352\277\364\026\316?\232\221>?\225\t\274>\264\026\001\276\333b\322?!<z\277\252h\256\276GY\242?\377\373I\277\301\032\207\2776]9?\t(\370>\371Pq\27780w?Sr\214?M\200\372?\377\003\001?\334 \377\276K\n\317\277\225\002T\277\352\326h\277\3030\252?\225\224W\277\355\337\305\277\3312\204\276\246T\241\277\257E\006\277;<\365>\331\024\345?!\313U\277\'k\235?]m\"?\025I\202\277j\315\314>\343d\212\277M)\317?I\354\363?I\006\"?\275e\214\277\254h>>\376\327\212\2771UN\275\3408\204?\031\366\036\276k\207\226\277\257\316\364\277\007\331A\276\313!S?\313\241n?\270\275\306?3\220\340\276\205\275\267?\362\253\210\277*7\340\275(\212\217?u\375$\277\360\264\250\277c\225\362\277\t\024\027\275\271\261\252?\224\366\006\277,\311\013\276\2008\006?\021E\237\277b|\326\2776\302\234>\372(\032\276\274\242\205?\213\257\r\277$\036\364\277o}\333\277R\373\270\275U\234f\275g]\t?b\266\261\277\323\375s\275\261J\213?\037w\372\277\357\353\021\276@_\363? \323C\276\377\235\335?\360>\201>\274\016\235?a\177a>\022\242\037?u@\331\277\273\230\224?p\313\222?\211R,?M\002\216>}\004\305>\365\357\374?\331\332\211>\340\272&\277\340\367\014?g\"\033\277\315\004\207\276&\214&\277li\250>FC\233?\n\250\305?0\210\315?\353\374\316\277\3679\245\277E\302\272\277\006[\305?\354m\260?\367\201\033>(\374\317>\357 \342?_\213i?\363a\376\276\300|\032>\200D\231?\264l\000\2773\310\222\277\323D\312\277\326\004@?\321?\314\277\314/\224>\340\367\351?\233Ub>\241\367\372>{\204\360\273\246\256\203\277S\373#\277\275r\351?\302\330\240?\313V\252\277w\211\305\277\360G\351?\233\273\024\277\276\212\366\277sX\336\277\345\241\236??\313\010?;V\232\276\033\001\341\276\232\245\331\277\003\335v?\321\'\315\277\\\310n?\333\033v?\352\370\260?\275\000$\277\271y\244?O\243\217?1\250>?\227\207J?U\333\326?\010\274)\276\376&0?\275I\372?\3740\274?N\206_;\342\200|?\243\324Y\277v&\020\277I\331\357\277\351\'\253\277r\260\023?2\357\331\277\274\016e?\317\336z>v, \277\325\032\210\277@N\202\276\232\016\323\277\253<\315?\202\315W\277\223D\241\277}\233\352\277\363\330\205>\334\316\322\277yN\377\2778!!\277\312ZC\277\313\024\204?\0336\240?\332\306\210?\323R\341>\255\357\310\276\252\3300\277Li\202\277y\020\240>\237\336\373\276\303\r\177\276\326\313=?\206\204\253?\363\333\355?\344+W\277\265\366\362=\315\240\364\276\250I\330\276En\325\277wMw>\254\324\331\277\360\351\312\277S\263\352?\305\331\344?\232\275\030\275\242{\254?\252\352\225?C\217\244\277\322V\245\276L\214\037?\247\031B?\374)\005\277\240\331\313\277\266N\345=#\265I\277\370\363\364?\272\"o?\243\360\360\277\315P\\\276\351\335k\277=[\033\277\377(\255?v\n\t?\317q\351?OP\345?\214\246\363\277\344\251\361?f^:?\004!\034\277\225\347\'?\013\345\266=1\177\327?\260\n\205\277E\241\224\2771\215\334\277\205T\356?)&\353?\253\n4\275\t6!\277\205w}\277\013w\313?V\342\337\277\270A\203\276-\202\203?RzV?\311\177\375\277z\327\337\276\034A\271\277\036\213\205\277cG\206?\355H\275?\206\021\201>A\273\222\2770W\232\277\325\332\\\277\253\0218\277\372\220&\275\320\270\203>W\230\332\277\343?\362\277\343O\352?5\355\243?v\301\274\277\303*\324?\253\311\376\277\371\007\330\277\327\004\266?U\314\364\277W\274H?\351\243\305?\367\335\200\277\034W\343\2771\227\337?\005\340\t?w\343\274?\275\315\225\275\303\207\353?|Y#?\242\023\332?U\335\326?\313\361$>4\013r>\255\t2?\343\246\236=\036\031\303?6c\360\277\240\355|?\325\353\226\277\200\204\244\277\232b\323\275\375\214\025\277E1/?\rY\231\277z\336\362\277\000\036\253\276MX{?[4\027\277\210i\363?d\314)\275-\321\363\277\036U\271>\363\356\366\277q&\353\277\223X+?\227sG?\230J\337\276\3572\221>R\266\237?\317\344K>\227%\354?.\026\000=\337Y\363\277\316D\366>\014dN\277\003\265\234?\240{\343\277\205\350==\303\205#\277A\322y\277\022\320\335>\262\376\237?\262\301H\277/\035~\276\017P\007?\303(8?\233\3477?dQ\323\277\005`\240?\014Q\215>~\204z\277e\025\347\277\316!\366?\025q\231>\220\343\213\277>\233\n\277p\250\371\277\274\022\300?\023\027\004>\024\361\250?%\230\360?\306wb>\246S\253\277\343\016\200\275\231\315k\277\367l\235?\027Wj\275_\360\353?bP\363\277\342+\036\277\337\307\260\277\007\n)>\237 \360\275s\031\301\277\354\374|?\304Q\242\276\252H\373?\367\004\246\277\326O\372>\374O\317\277\345\010\375\277R\304\236\276\275\236$>\245\212\336?m\322/\277\317\376#\277\323\020\241\277\300\033%\277\253\271L\277\206\245\361?d\037\225?\301\017\236\277\341\335H<z3\311\276\004\223\354?\320\362\350\277\327\353L>\304\277\264?9,\351\277\037\031\334?\007\264\213>\236W\256\277\253`\206\277\352x\200\277\365\265\267?\323\216\276\276m6\245\276\272\370\260?\327\246\221\277\205\361b?ucl\277\016E\371\277\205\267f\276\363X\365\277\230\014\356\276\034\325\330\276:\315x\277\254\301\360\277\312\303\320\277\023\\\357\277\347\265t\275v\014\306?\234\300\227>UH\335?\014\356\344\276\013k\361\277*\312w>v\306\237>\251\327\233\277P]a?\262\241\355=R\263\364?&pH?6\337\251\277\270\210\270>|\226G?!\352\350?\345\246\243\277X\252\260?\303\360\233\277\037\032\216\277dy\311?\345)\262\277\201\323&?8j\262\275{\372\227\277\236\036y\277\235\207\235\277\302=\324?\357<\221?\234n\223\2776F\376\277\223\247\345?\311+\000?tD \277\374\210\224?m\267B?p\254\266? =\321\277\362!A?\203\377\204=\257E\364\277e\277\321?\201\036\n?\211n\234?.\366\322\276r@\217\276\020\306\215><\244\354\276\\\252\342?\334+\346?;\241\"?k\003\206\277\230D\356?]\227\370\277\216P\351?-U\242\277b\271\366<\277\360\274>X\373\245>&}\203?\266\257\202?\177F\212\276\277\037\214>,\305\260\275\351\006\242?\0042(>\331\242y\277E8\232?\351\351\321\275\236\245\364\277\032\273\364\277\2737\277?\247p\362?\243o\300\277\324k\231\276\344@\336\277l>\250\276\010\235\256?K\014]\275\332H\232\277\002\006\232?=0\331?\231H\237?\317\027\353?\214\254\007\277\234\263\224\277&\201D?\244\036\252\274\213~\373>\322\036\220\277\016\241\207?\340\377\220?\205{=>~\345\336\2772=\325\277\247\014\257?\200\263\010>\232\306\214\277QZ+\277\353\270\010\277\r/\252\276UU_\275\242E&\277\242j\360?{\213\252\276\356*\277\276\021=\343<f\024\270?`T\314>\351\213\345\276\207\274\350\277g\001\201?y\237\227=\213)\343\277o/f\277w\nU\276b\"\211\277.\210S?f\024\267>\252b\357\277;\203\216?_%\366\277_\037\366?\233\000\253\277HI\261?\232,\215?\227>\354\277!\367\353\277M=\357\275\355\035\272<\324e\243\277\336Q\367\275\337\234q=\304h\234\276\305X\255=\025M\203\277joi?\253\210\354\277_\314\332?\025)\363\277\242\353!?\204N\303?;[g\277\303h\230?\202Ip\276\337[l\277\3011\t\277\331\320\265?O\246\277\277\207\360\273?\310\356O>P\354\376\277\347\302X\277\207g\240\277\345\326\311\276\005e\035?U\006\036?\272\367\324\277\016\370\257>\215\321\007?\035\005\241\276\333U\313\277\370\232\300\277\335\242\320?L\017\205<\216\316\204\277H\374\365?\024^\244?g\237\277?Ad\007\277\337\374\035\276;L\364\277kP\262?\263i\377?<`\263>Ej\024?T\340L>\266\006\205?\001\261n\277\010]s?\331Ng?\207Y=>\020\022\242?\212\201\255?C\255/\277<X\332?\204\264\206?\321 ~\277\336\030\371?\331\001\215\277S\213\031?5\010\360>\245\005\320?\023\233k?t.\302? }\016<$[\340\276 \006\007?\263\370\262\277\243&\275>+B\221\277\036|\322?\\\364G>\177m\316\276\226H\334>\227Q9?\313*\302\277\226\370R\276\274\n\202\27781\361>,\231\370\276\371\250\362\277\256\t\332>\266\364\263?W\312\373>\356\0041?K\245%\276\312\240 \274\322|\014>\335\020\034?\372A\333\277\002\214\240>\247\251\r?\025 \301?\271\334\216?W\214^\276\253I\203\277\320\032\312>\345\362\312?W!\303\277^\367\037?Y\244\247\277Wv \277\346\245k?\311\361\205\277\017\177\007\277E\271\255\277\275\215\240\277\377\341,\276Hz\354\277\202=\346?\271U\265\277\314\030=<\337\354\257?\316\013\001>^}\363?\337{\361\276)m\332?,\335\317?]\023g?\'=\206\277\037\372f?\206\013\256?7\364\372?\334(X=\257h\266\277\245\255\363?o\030\317\277\034\033\363>\300\031\035?\016gK\277\253(\345?!.\352=\345\"\202>m-\033?\004\257\333\277\037u\352>\t\335\367\277\240?%?\3110\336\277\276\251z\276\345\373\307\276&:b\277>\274\235>\273\271\005?\377\3407?z\331\226\277Nr\364?\021\211)>$\322\237?\210\n\253=\347\n\316\276jb\335?ju\330?\023,\244\277\001\215\236?\357s\301\2775\341\313\276\312\222\327?\343\364\341\277\365\0019\277\202\201\207\277A\376\247\277\024&\377?\230p\355?\244j?\277Mz7\277%I\260\275\263\266\203?\270~\337\277\340AU\277[vz\277\201u\217?]6Z\277\370\302\n\275\235L\247?\365 \262\277?V\302\277\2226H\277\241\336\301?\002\364\225\277\314\262M?\373\262\340\275_~.\277\332\263\266?\351\034#?\323\2663\277.\020@\272\210L2\277\222/\243?\352w\312>\323\024\t\277\243\302\347\277\031\302\246?U\026\334>{\r\204\277\"\034\376?\335\316\211>\005\214\362\277\214\004\257?\0167\323?\037I\235\277\244\311l?\005%f>\274\334\007=\035\344\341?w\203\223\276\217\322\215\277\247\007z<u=\212?\251\365\273?kp\017\275\010\376\217\277\245\002\354?j\347\221>\367\270-<\303d\257\277\366\034m?\300r\256?B%\322\277\241\372\362\277\371\334\354\276\326\001\346?a\340\202\2777)\330?\351\231\343\276d,k?8\317\311\277\251\310\216\277\240\t\247?\302WF\277\021\232\264\277L\252\263?\0323\212\277\240\321\035>\332\277\374\277\025(\354?\241\256\204\275GT\341?\243\001;\277\242\023\262?\272\374\r<\231\201\332?\322\370\334>\244\354\373\277\354\030\375\277\342\023\260\277\263\000\241>\354\004\302?\3206\201\277\274s\345\276\027(\266\277\351z\237?F\222\233\277\325_\372\277\2612\370\277\205?\203?0\256P\274\3627e\277\341b\345?\363~N\277\214h\224?an\277\277$\211\240\276\364\310z>\371T\373?\200\250T\277\001\332\325?}2\236?)\277\001?F\233\261\277\024f\225?\320j\205?BE\341=\247\0321? C\331\275\251\347\200\277b\031\216>\374g\263>\347\317\326\277FQ\271\277\260\035\r\277ag\373\276\241\323\334\277(\023\376?4a&\2778\304\377?S6\246\277bz\247>\010\247\351\277\311\372\371\277g\010>\276\310<\217?\245<\270?E\305n\2771(\200\277jY<\2765\326\225\277N\257#\277\251\300*\277\352=*\277\201\211V\276KK$=L\306\305\277,\242\216?\374z\304\277\324\021\377?\356\241\373\276|\020\353?7E\311?\365\036\210\276\243a\255\277\004:\207\277\252\367\235?\2522`?\342\237\207\277\331\3614\276\226\236\027?\324\007_\277mk\200\277\261x\275?\013\266\224?E{\027\277\232#\333\277\323B\337?H\n\265>&\254\367\277\201\256\220?\232\370$=\377\346%\276p\243\342<os\253?.m\315\277\201\220\344\277\351\261\203\276a\3568\277dp\302?\262G[\277\373.7\276\034AD\277\323\220\364\2774J\014\277\nVb?\023\212\334=\013B\347\276\364H\313?e\373\310\277s\032\007\277\311\302\013\277\t\250\341?\353\2535=\027\375m?b\215\350?\213\221\253?\222\337\214?\010^\020?\242b\236>\237\355\270\277\213\300P=e\256\372\277;Am?\275\255\334\277\235X\321?\334[\247\276\370\306\334?rr\302?\316B~>\342\363\273\277\347C\001>\327\3560\277\324`\377\277I\220}?\363v=?@\340;?\323Hd?e\321\307\277\203\0036?[\'\215\2777\236\361\277\247\r\320?\373\351\337\277\277\372\331\277c\243\364\277\013@\'?\002\212\347?\255\177\273\276(\006W?\265\357\210?*G\006\277f\213\017?D\263\306\277\027\305\223?[\'\263?l\0171\277aL\376\274\252\313\221\277\312\002\300?\255`\235>\300\335l?\250\364Q\2765R\014\277\225\177\264\277X\350\375?\001x\376\277\"\275I?\345]\030?\010\352\311\276\272\256\002?\237\376&?\275\004\003=\247#m<\335u\305\277\270\353Q\2777E\327=g\344x\277\241;@\276\334DD?\216Z\335>.\241\267?\247\360\252\277\212\265\245\277\275\372g?B\366T\277\366\014\213\277n\204K\277.n\264\277\362\325\276?\006L\033?;\236\206?\337_\261\277\031n\373\276\264m\201?k\033y?\205\037\312?\236\342\360\275\330\362\375?\327\316\024\276\272#\220?\241\3275\277\364\263\352?_\337\305\276\261,\203\277\327\334t\276\331\370\350>\3359\346\2767>\337=\244\275\270?\276\217\002?\250\022\357?)\230\263=\323\267Y>=\223\351\276(\312<\276\224\355S=\001\322\335?\372\204\302>D2\330?\233E\265\276*N\225\277\331\024\261\277H\177&\277\345rx\277\370/+\277\340\236\220?J\322\261?s\220Q?\333&\207?$\273F\277\221\227\312\276\336\033A\277?\223\224?\2064\313\277\"\254\301\277\200&\306\277#\275g?^\272j?\027\225\213?\200\346\321?\272*\233\277\352\371\256\277\361\n\276\277V\000\302?~>\245?&\010\010?\277\353\362\276\204-C\277~\016\364\277\323\005\302<:w\223?\022\320\326?d2{?dT\357\277\272\240\376\276\t\254\200?\315\251\214?\235P\253\276@\346\365\277\023,\373\277\257I\310?\006\230\236?\267\237h?M\320\346?\301\001\322?\001W\371\277\307\211\266?Q-g>\306\242\020?\236\t\223?\013\017\346\277\214\342\316?\360hr?M^\337>\352\206\277?\007g\025\277\220\262i\277\266s\221?q\340\232?\373\316\321?\360m\205>\204\346\211\276\343P\231\277\362H\233=\033\016\266\277\263\332\341\277\031.J?$fM\277\324\235\031\277K\210\001?\"O\251?\256\210_\277\273\233\334\277\375\306\237?\000\311\231\277\250I\364\277&\2429\277i\t\234?x\353\351\277\223\030\347<\230\3422?]`\342?\242l9?I\3654?\303\035\204\277\251\016\314\277<\033\305\2770\331\300?\220*U\277!\377\347?;\332\330?\347?\377\277\256\223\367\277Z\215\213\277\215\246@\275\025\025\016\277\230\033\336\277Y\374\346\277\274\275X\276M\202\233\277\205@;\276\351\346->_\202.?B\246\227?5\253\317>\343`\222?\276\255\376?\324\226\357\277\253R>?\251D\202>\306R\330?\353\354\202\277\274wT?0\375\t?\316lk\277\271\2424\275U\367^\277\364\222\333?#\213\254\276\234Z\025?\276^\306=c\327C\277\360E\274\277Su\360\277im\211\277\235\342\305\277,/\215?T\262\301\276\240`\351\277\230M\030\277\210\236\337?C\021\362\277\306\215~>\326&\271>i\r\347\276o\005??`;\273\277^\363\260?\361\346\343\276\276Q!\277:<P\277q\356\200\277\3623 \276n\327:\276\342\240O\276\350\241\341\276\377\201\346\277\370\032\272?~\234\333?+R\033?\306R#?\310\277]\277)o\252\276\232\250\236>\004\342\317?3\221\227>\350\327\361\277\241\350\347\277\354\340\336?2~R\277\376\000\335\277\356\352\215?<AN\277\241\261\271?\327\236\300\276\032,\201?\033hF\277sG\030\277\3517\301\276\270l\r?\372\367O\276\241\362\010?\241\375\037\276I\363\265\277\022W\316?W\263\232\276\252\260\315\277\036\354N?\351t\346\277\330|\023\277\342\215j\277\217\216\354\277q5\301\277\211\217\301?\365;X?\217\223\203\277w\014V\277\n\227X\277\307\"*>\341\225\302?\343:\253\277\000\332\270\277\271\350\230?97\315\277vX\310?6{\352?nQ\\\276\360\270\333?\034\357\343\275$\264\372\277\354\354\251>\232\205\234?Y\373\346\275\n\221\263?\340F\216?C%T\274<-\366\277xJ\343\277S?\313>\350\357\323\276\3369?=\r\216\207\277\212\374\330?u\307^\276H\215u\277\345\214d\276\005\3261?\253\203\335?\025\357\003?\245\272\262?\323_\324\276A\204\234?JYZ?\002\266\010\277\374:\310\277\274\332j\276\312\2647\277\252\366\342?[\355\"?\024\241\220?\\hW\277\374\360\003><2\275?+0J\277\337\350\307?\227\320j?1\237\313>\236\272\350?Tj\272\277\332\233\351?\3370\341?rZ\331\277\0361\253\276\010L\264>P\2326?j\325\301\276\373g\266=s\353\304?&\001\333\276mb\200?\224\\/?\023\246\325\277\'\203J\277q-o?y\265^?\312+\216\277cY\343\276\374z\365>d8\354?Z-\326>Bqg=\253+\006\277Z.\305\277\004\031\345\277`\304\311?\331,\325\277\024\305\257?X\037\266?\266\216\375\277A.\001\277\005\246\345\277\021\352{\2767\212L>\366[\340?<\214\227\276\253\206\264?\013\303\333\276E6\321?\247\"\246\277\203\274\320\277\'7u\277\274J\372?=\340\300\277\377\241\305\277o@:\276\274Q\255\277:s\335?(K\321\277\004\037\357\276P\266k\277S\247Y?\317\207\325>\\\374\n>\232^\311\277\310\227\303>\272\356\336\276\326d\331\277\277:\304?\315\335\367\277\020\311\224>\313\314\200=,p\014\277\027sk>\327\333\234\277!]\235\276\026\266\303=%\374b>,\000 \277*Z\035?r\353\226\277g\364\366\277\324h\222\276\240l\231?\027m\316?\205\231\200>\314h\360\277\335\331\342\277\266\024\203?L\261\230?;\224\354?osO\2779\234\243\277\271\273\206\277\366\035\227?\025\337\261?~B|\276Or\025?O\272\200?\364\271\203?\346d\342\277\006\303\271?\013q\251\277\222\254\350\277\343\255w?\\\007\351?\024i\226?\201\206\304\273e\312a\275\"Mu\277&\314\177?w\250\214\276\036F\217\277\230r\211\276\272\021\244>\315\210\325\277C\312\372\277\341;\224\277\276Q8?\333\'\242\277G\266\232?\201\210q\277\260\370}\277\321\234\336\277\247ke>\016\313\314?%U\354?\003\235z>\224\256o?[Z\036?\342)N?\024\250\'?[\213f>\266(\310=\022w\205\277H\373\360?\326:z\276\216D\350\277;\003x?\036\313\344\277\367\214\361\277&\354\300\277\312J\177>\225H\257?\'\2557\277d\360\345><\020\t?\020\345\343?\227\201\260\277\365\004\236\276\t\341l=\200\366\252?a\336\213\276z\272\272\277\347\177\334?>f+\277\024\314\204\2779.\242\277\367\250\016\277\245!\232?y\334\014\277J\002\343?-\237\334>@|7\277\276i\324\275\311K\357?S\203\314\276\364\267\370\277\332>\246?@0\022?\330P\256\276\025\244\354?}\323\320?uI\240>\305\200\r?\037K\232\277pU\375?\341Z ?\330\217p<\277u\335\277\r\342\236\277\353\207N\277/2K\277V\307\320?s\276\300?\320\034*?\007\313\345\277R\001\335?\256<H\277{\037\317\277b\022\372?\010<\302?\217\005\271?\302\334\211\276\212\351\245\277\025\305\312?8\260\204?\006C\032\277\312\311\225\276\"\313\014\277\022\177\331?\006\320f\277\257M\013?\333\257\327\277\245\272!?\356!\316\277\271\037\313?$\337@\277A\031\312?\006`\272\276*\003\226>\265_\336?\242\332\342?\312\352X\277Lo(?2\344\217>\377&\214\277\204,\353\277\266\020\373?\373H\227?\241\037\220?\216\354\257?<p\017?\006\025\330?\333\222\033?\325|\374\277\343N\302?(!\260>\277\226\017\274<\243\025?^>\213\277w@\277\275aA\200?\360to?\344\324\200\277\001\201\223\277\324p\371?\246\204\355\277\317\202\273\277@=\211=>\036\340\275\304a\360?\272p\353?\376K\201>\000m\233\276\326\3617?)8\213?\377\322y\276U\236\267>\344\200\346?\327\353\241\277\216\245\360\277\327yg\277,F\027?_`\"\277\301\006\205>\365\003\354\277\355A\255\277\027\351\032\277\321`\322?$I\"\277\013\326x?\006\024`>\337\010\344=\365\353\237?\325\302\271\277\331\377\347?DC\301?W\254\245\277\001\356\343?w\306\200?\274p\230>3@\361\277K\261\340=3{\330?\370\347\212\277\014\212%?\304/\322?\370\t\203>\tz\343\277\246C\233\277<=\353>\n\'\354\275\217\257\307?\210L9?%4\230\276B\315\017\277Vs\306?<\207\241\277z\'\346\277(\212@?\016\\\200\277\251\025_\277\307\\\224?\t\216.\277\255\272\"\276\224\346 ?\023\261\330?\211\245\351\277\367\240\322?wS\234?\211\344\240?\002R\261?;2\275?)\224\335=w\313\210?{\350\265?\252MZ\274?\262\023\277B\306\232\277h\270A\277\226fh\277\240\233\231>\3331y\277\0303\235\276\3209=?\021\324\250\27733\351?\322\276\276?x\241\376\277YZP\277CZc\277\305L\330?\215{\177\275\275\220\030?F\225\250?g\321q\276\247%M?e\\\367>,\026\206\277\222\332\263\277^1\000\275\266H\375\277\376\324*?uh\350\277g\004\324>8\004\310?\201\354\311?\371\236\240?\016\332?\277.<\227?\365\356\005>w:\272\277#\265\320?\375\324%\277\023\314\276?\241\n\027\277\266\206\003?om\214\277\320\213\027\276\213\233w\277\241\010\241\275\212O\213\276\3130Q?\343\037\306?X\325\205?\317\365\357\274\212\261\302\277U\345\220\276\0339\\\277r\021\247\277\343\370\200>G\200\245?T\016-?;(\022?\203A\334\277z\247\315?\332R\376\277@\006\371\2777@\253?\265\324\336>\333\247,\277Q\356\217?\326\367\352\277)n\206\277\217\253\236?\233|\257?h\376\020\277\001\216o\275\247\241\241?\007/\214\274k0\300?>\3129\277\214\240\036?\035<\276\275\361\273&?-Q\263?\372}\252\277R\245%?\326\034%\277\347r\356?L\317v\277\263|\233<\370\332b\277\361\236\305\275\277:\310\2772\344\"\277\222\270\305?\231b\211\273\224\031\222?\271\203\374?\335\210\316?\361\371A>s{>\277\017A\304?\331\366\335\277\233\336\232?x\365\001\277\365\220`\277\006|\332\277\034\000\365=\341\024\246?\270\340\\?\350\370=?\336M\227\276\277;N?K\337\344\276\332S\325>o\355\212\275|T\367?\001\353.\276[\007??\212\226\362\277\312\327\206\277\301y\203?%\344\021?{\016\220?n\311\247?\\\335\022?L\354\233\277\022\334\303=O\r\352?\355\371\333?\355\306\034?\207\254\027\277\300\305\305>\005F\300\276\236T\201\277I\236\210\277.\327\264?\rD\302\276\202\\\374?\247\237s?\377;\320>\365xq\274\273\305\233\276e=\222\2779O\344\277!~\257?B\354\320\277\341X\367>np\356?\222\326\022\277\253\3245\275\355\347m\277/Y\353?\276\302\350<\243g\374\277\222`\351\277\03483\277\260\300\302\277\257|\255\277\245v\264?JZ\010\277-\307\"?\2166\333?\344\023T>\333\262\261>\326\007\331?\016\232\274\277\220\324\332\2778\235\346\277\215\360\203\277\2664\320\277\346^v\277\004\307\321\277\304\3771\277\303b\320\277\324\317\334\2773s\\\277|\326\356\277y\222\253?C\243\214>\326\203\335>>^\202\277\260x\230\277\260\332\267?\373A\220?wZ\256=\323\361\017\277\252pS\277O\345\222?y\313B\277\301\231\261?\232\247\215\277\300\224/\277\"\207\261\275\300\276\313?Es\366=\216s\273?\260\234\344\276\310\361\340?\207\005F?~\341\223?\323\n\366\275/\330\363?\217\340\345?\336\211(?\332VY\277k\003\332?\"k\016>*\310\252\277\323\374\200\277\005\376U\277\266\r\251?\373\314\256\277\314A\243?\226\030g?\371\355\375\277\351\336-=\367\220^>\301$\272\277\266\372\373\277\\T\231?\'9\370?7\220\272\276\t.7\275\326\352_?~\214\242?\0074\315\277\016\010\365\277\235\246\310\277\2725\235\276\246D\325\277Y\336\330\277Q\364\256?~\200i\277{\324\303?\322\221\244\276\306\214\217?\221\333\037\277#H\373\277\363Y\232\277-q\217?\203v\311?\320\025R\277t\307\277?M\340\316?0\027\362\276\214\260\006\277\244\003\333\276?\324\274\277\361\320J?\023W-?\275\353\313?\223\251\306>G\236\037?\217\213E\277&\372\354?}\013\253?\325\244H\2771\032H?\273\257\342?\264\367\267?\036\177\021?*=\306\277bD\336?J\202i?\250V\206\276~O\207\277I\203\307?\222\250\251\275]\237\343\276\320\207\376\276\213+\210\277\356)\373?+MO>l\222\353\277i\033J\277\366q\215?Mn\t?a\242[\277$\342\227\277\217\316\364\275Yx\260?\225\317\204?\305\017a>\242\242\367>\257C>>6\226h?\034\346\313?zM\364\277\016\235\341?Z\003\215?\020v\340>\316\013\000?+4\266\275+=E\277P\357\322>\022k\333?\rK\247>)\215\270>\274O\025?63<\277\246K\221\277\356b\205\277\245\366P\277\004T\243\277m~\360?e\377\253\276\230\r\226?n1\304\277\257\315 ?\031W\355\277\227\367\323?y\321\036?\224\366A\277\021_X?\t4\263\277y\223#>\374\177-?\311\235U?\022w:\277\022\256\214\276\256\3723>?G\365>-\313\003\277\267\377F\277w|\212?\200\271\300?\000#d?S\206\030\277<1\215?\303\256\326?\026\030>\277\372\265O>\366Q\025?\216[\257?\330\316\356>\272;\262=\002\002\350?x[&?\223\373\205?\006\001\214<\3070~>F`\207?\000\241\350?-i\315?\347\020\272\276\300\3018>\324T\307?\257P\\\277l\001\227\277\215]\220=f\021\223>\031\260\340\277\031\316\377\277D,]?\277\271\376?1\341\340\277[\221\304?\343pf\277+g=\277\204\314\345?\233\245\266\276\000\277\260?\017\203\307\277\216_\252?Om4?\321c\320?\352\334o\275\271\252\024>\251\032\242\276k\266\337\277@\3537>\270\356\263\273G\372\361>\375\242\254?\214|\303>\0019\206\277\261\017c\277\324\037\225?v\371\375?\301\265\347?\236\263\355\277\222E\333\277\014\370\200?\217\356+?\265\272\032>\245*\206\276\246\033X?\350\347\r\275V*\350?G0j?\022V\237>E\377~?\206\251E\277\325\247R\277\2218\354>\370\003\023\277F\232\263\273\217\312/\277\373\221:\277\345\264\207\277H@M\277\016J\330?\306\242\255\277\0023u?\236jT?\366\035\303\276h$\352\277\361\230\313?\013\203\360?\365\264\321?u\2020>%@\205>\206\265\337\276w4\340\276\377OO\277*A\314\277f(\001\275I\320(\277\347\262\314>\342B9\277\366\257\250?\370\320O\277_\213>?x\014o?\316OD\277\244\326\005\277\035\332\273\277\274\356w?\321b\246>\000\242\271=SG\031?;\305\321>\300\212\254?\365\204\376\277^\312\371\276\003\205\213\277\\\277\214?\300?\340\277k\330`\277\263e%?\035\014\320>\026Z\200?g\343+?\224\323\246?s\354\254?\004\243\312?\317\035\215\277\020;\027\277\"\261\005\277\267B\242\277eM\366\276m\273\n<z\241\331?\\\024\320\277\303\004\363\277\343F<?\373\362\341?\352\007\226\277\224E\020?\342n\202=\275\024\307\276K0\274?\202\207=\276\342\326\352?DV\261?\0317\357\277\217\244\220?\333CO\275\350\032\350?LI\270\277p9\322\2775\212\316=a\236\020\277OEV\277*\361L\276o\033\331\276\204 \356?\t\375\230\276QC\351\277BS\211>\203\365\243\277c\017\362?m\201\352>x\251\231\272\006d\252\277\025\330\274?\222\240\216?t\362]?~\003\351?^\200\006\277\243\355\206\277\242\310i?\373}\376?\263\006\377?\314\224\357>\324\245\234\276\023\371\356\275\026\361\253\276e|g\277\276\nO?\014\236Q?\304\021\t\277\203\020\242>\360\n\331?\371\004\310?94\337?\004f\265\277\216\306\352\276\370\026\374>M\260\277?\376P\005\277\3663V?2\253\300\275\216\3033\276\020\305\000?\360\260\360\277P\006\205?\340\362}\277\307\203\340?\251+\356>\252\203@?\031\214\337?\002\003\320\277\237\221\333?\223\221\341\277\363R \277ml?\276:<\200?a8\230?H[\342\277]\253\017\277c1\341?`\2331\276\312/*?\323g\351>\342@\335\277\323\322\315\277\352t\337\275\322\335\373\277\006\326\205?|\371\007\277}\277\006?2\270\213?\n\263!\277\221\010\270\277\231B\333?1\035n?\177 \255\277.d\361?\374.\230?\226\326\204\277\031\034s\275c\030\320?\025@a\277+\206\263?\036\314\037\277\021Et?g\230\353\277\275\037\363\277\371\244}?\371_\361\277y;\003?\306\313\316\277\365>\270\277c\367\330\277\230\255q?B|\022<\022W/\277O-\207\277\232\331\251?\271\236 >\272\376\335\277\302\272\364\277\255f\264\277D\"m?-<y?\323R\037?!\204\270>\26149?\031*n\277\335\035\225?\277\307,\277@\014\222?B7\347?\373>\034?\350v\t\277\215\305\240\277\257\202\270?\271\334\205\276\270\223\363?\203\250u?\316k\326\277\257\331\274\277\342M\233>\211}\205?\n\234\246\276V\270\275?\341\2142>\266R\325?L;\335\275\324\025N?t)\'=\321\327\374?\363\372\327?\220\305\224\277\367+w?\310i\214\277.\315V?\347Q\377\277\263v\300\276:;\204?\344\n\311>_\006\216\277\256rJ?1\353\232\275\340\324\360?\004h\307\2774\227\267?\005c \277p\3617?\322g\304?l\\\351\276\210It?\023Y\237>\254l\003\277\034\214\352?..\264?K\034\272\277\\q\217?(\016\376?\234\201n?\035a\222>I\353\263?\014L\371?\367\274\306\277\305\276\241?\004\355\221\277h\212\322?3\277s\277\234S]\277^k(\277L\234a?\004\303\232\277F\271J>\016\034\327\276P\246\237\277\222\200\211?~^->\212M\350\277\223W\252\277\356\351\004?s\355\342\276\304\235\305\277\"k\324>\035X\241\277]T\033\277W\314L?\023W\227\277E@\336?\007\214\264?\215\374\331\277R\033\267?\236\027\256\276\344)h\277\rw\257?(;\224?\316\247\275\277\021n+\276:\2511?\003\331\320\277G\313\\\277g0\315\277\360\205\324?wJ\025\276)\367r\275\004\370\231\277\001IT\276q,\330\277\262\300\302\277\236.\362?@a\333\277_\346J\276\251\220\335?>\331\207\277F:\362\277\236\030\367\277\247/\226?b\211\023?\t\010\241?\255\\T\277\366\257\241\277x\362~\277\204\364\031?\240\213\271\277\204\232\315\277z/\317\277\320\255\231\277\316<f?D\305\352\2763\367\240?\327\327\274\277\375\r\364?6j\323?}\000Y=\344\277\340\276\275I)?\016\256\225\277\255\365z?:Ns\277\025_\243?\202\016\025\277e;\231\277\372h\315\277\026\320\343?\2631\232\277rc\223\277\243c\030\275\333\r\371?\304yF\277M\365\206>\032\247\254?\263\n\312>-\013\"\277\330\004\303\277,\352\301\277\272\270F\277\312~\200\275\363Y\354\277\0055V\275\325\215\320\277\006a\377?l\250\206?\265\372\213\277J\264\351\277\361\261\360?\346(\362?\362\'\277>]E\313?\335\020-\2763\336/?\256\206\374?\001Z$>\177\367\314<\315\204\240\277\024\270\337\277\214h\336?\\\205f\277Z\332^\275\274\270\230\276\255\244\236=%\355\316\277^\343\271\277\320\342\365\277a\373\t?\265\340\251?\351C\255?\344\320\267\277\222\215!>}\324\363\277\",\025?\022v\202\277\366:\271?\366U\025\277\264EN\277\364\226\016\276\311j0\277\367\262\362\277M\303\253\277}\331\221\277\37292\277\322\364\023\275\023_\221?#\326\321>\347\222\215?z\035\037\277\305\374\001>-\342\377?\306\037\244\277\306;\341?F\324\342>15S\275\344J\241\2770\325{\277o\357\031?|\365_?\364\376\013>L\326\335\277\271\315??z\222_\276kk\347\277Yi\n\2730\276\371?2\t\204?\365\340[?\370\306\245?B\013\204?\332\363\372?\200>\250\277\004\213\367?qt\330\277\231b\350\275\032_\303\277M,\230?Jj\001\277\005\033\251>\252\217+>\360\344\203?\255%\276>G^\357>\262\225\342\277\217oJ\277\352@+=I\2224?\214_\271\272\350\357g?\322\301\313=\310H\274\277\340\325\206\277\3728\303?\306\214\332?4\257\301\277\263e\370?C\260\247=L\021\377\277\013\342\265\276\273\035\301>b\336\225\277\347\300\343\276\240\254\334>\217\031\332?\255\360\330\277\243\315c>\240\002\216\277\344/\342?\310\0102?CC\363\276\243a\237?\212\"\346?\223K\370\275~\313\312?[\244\341?\034J\030\277\217\266\230>8\200\233?\035\331\310?\217{\207?\275Y\003\277c\341\037>8}\320\277.\240h?8Rk\277\253K\242?w\nX\277s=\373\277\263%\356\275\240l.\277\341Z\224?\300\355K>[\330\342>\000\005\\\276\037p\227\277\006\024P>+\335\265?\342>\334\277\'\353\313?A\0000?\\\262\300\276\006\017\244?\220\343\244\277\360K\004>\243\350\322\277x\240\227>\374\370\265?\232d\305\277\220x@?\365B\306\277$\362L=\313\335{\277:\321\357?\367\260\362?\177\277\324\277cO\316?\204\262\367?\016|\230\277\311\220\263?\260f\301\274\317F|\277\256\r\371?\010\336\\\276N\352\362\2774\375\336?\362\332V\277\031\340W?\216vM\275\026\013\t?\271\336\364\276\272\256\331?9q\t=b3\265?!\320\247\277q\005\'\277\004\356\022\2770\032\272?\321\206\262\277\235[\023=E\314\\?<\252\350\277\347:F?\255\027\200\276<#r?LM\263>\315\250\324?b5m\277\240\336\244?]\332\225?\226\r\277\277\314,\303\277d\200\230\276hs\013>\206\005\001?\367\226\375>c\337\026\275\317\275r\277\177\345\337?\372\376P\277T\246r?\204\232_\277\024\\:?\336\354\254\277\327\031\363?H\2221>w\256\014\277fx\320?\312\232\226?\004\351\354<\034Sq?B\222\023?5~\262\275\345~\347\277M@\377\275<w\273?\217j\271?\246\313\321?Un\231?)}\340\277\212\337s?UP\366?\317\177\217?\222\006\370>\317fr\277\213\260\356<\253\205\274?-\201\271?|\373\251\277\303[\356\277\217|\370\275Y\254\345?I\3410=\203Y\265?I\344\310?,\367\260\277\260fp?\263\033\217?0\351\274\277\347\001\272\276\273\026\020?\030!x>\276>\273>\316\020p\277\347\267O\276\341\2213?\330\177\232?\341\200\221?Y\200\327\277\243\177\234?\360/\275?lX\201?\370\034\323?_`\376\277\232|\023?\010\303\321=\344e\204?\207\010\362\276\023T_?Q8;?\277Ur?\241\036\301\277\000k\323?\2100\210\277\233\207\343\277\216Z\276?\307H\375\277e\347\307?\224G\263?\212\306\217\277\026Y\"\277\327*\375?\351\017\314\277\265$\002?K\260\356?\033\010\247?\213\177\220\277{m\270?\236\263\220>\014\211\242\277)\034\023\276\0317\337\277\206t\207\276c\001\234\277\206\326\'?\224\027T?\277\277R\277c!\344?M\250>?\307\227\302\276\354G\347>\215t\252=\007Q\350?oQ\255?\204z\252=GDb\277P#\256;/\001\003>;\271i\277=\342\231\277^L\235?p\257\341?\024+\351>\360\376\214\277zn\257?`a\263\277\216\314\200\277x^\301?w+;\277L\226\370\276\3207\320?4?\026\277?\202\216?\263\216\375?\307\225\365?_X|?&\251\333?\215\036\207\277CN_\277\320Q\034\277\\\227 ?\313\301\325\277I\027\222?p\036\010\2764h\325?\246\3030?\206_\335\277\241\326\275?G\300\224\276Q?F?Q\253\252\276i\\\351\277(\243\300?\300z\277?R\372\203\277\236\342\223\277\3106J\277\177\270\310?\374\025K\275\033\316\310\277\006\274\261\277E\272\315=\326\335\315\277[\021\205?[\356\315?\337\303\271\277\"9\356?5\362\310\274Du\265>l\276\345=+\235B?\377\376\250?\002\005m?\223\366\234?\323\314H\277*\303\271?\324e\261?\371\317\207\277\237\314\377\277\217\273e?\273\235L?\374\217\231\277\243\370\377?\305\346\013\276\320\203\350\277\335*\226\277\350\261\374\276Q\367\256\276\013b\225\277<\257\227?\325\005\335?\257\272\237?\245n\276?\274\357\322?@\351\215?g\332\214\277u\350\342=\2017\365\276\270]\211?\276c\362?v\'\017\277\313\367\246?\364\264\214\277edC\277\327t\"?\356*\224\277:S\257?\262/\324\276K\002\031?\\\035\350?(\273\207?me\320?\271u\257\277j\363\271\276\r~,?{\207\006\277\2422\272\277\t\3122?z\224\263\277\0357\252\276\027\230\001?\261\324\220\277\356\246O?\271\263+\2777\032\244?\212C\245\276\005\373W?\263I\366\2776\225<?\030\237\232\277\375`\361\277\257\231\215=\364\334a?*\316~\277]EH?\016\231\212?\0079\302\277\032\310\232?E\227\212?\220\014\224\277\304po?\201J_?qH\331?~4p\277^\352\223?t\324\214?\225m4\276\252\031<\275\231\357\363>67\211?\252\231\355\276\365=\304\277\362\330\250>\006\260X\277\317)\330?v\371\200?x\253\201\277\205=\344\275\014|\347\277S\216\201\277\014\341\334?\227\213\265>\014\003\366?\026 \225=B\315\366?\220M\177\277N\005\325?\010O\351\277h\256\223>sB \277%\033.\277\010\344\022=\373\t\226\277t\331\236?J^\350?m\233m\277H\220\005\277A\331C\2771\252\357>\306M\252\277\265\010\231\277P@\205\276\273\211\256\276\366a\337\277\027h\274\277\310\275\271\277(\010j?@x\350\277\267\356B>\255.\351\277TI\301\277\227\315\033\277\177\305\031?\320\214\232?E9\365\277j\245\374\277\305;/\277s\255\201=-\314\222?\0058\027?6g\242>3W\353>\363\213\357\2779b\350\276\317\'\n?\335|\361?\273\036\312\277\266y\371\277\324\207\326?%\323\226?\n\274\352?\275\035`\276\255\304[?\006j7\277l\214\270?\254|g>\022;E\277\2245e>\020\364E\277ur \277\240\036\300\276\267\374\270\276\305\250\257\277\312\352\227?\367\034\233>\340V\356?\n\004\241?\302?\211?\275\314\247?V\261\374\277\341t\346\277Cvh\277\234/V?\362\274\242\277\304\030\272?\303\312\373\277\202\252\366?\317G\234?\005\267;?)\216#?|K\352\277:@\241?N\275E>\330\210\377>\306\202\001\277\360\007\253?-(\300?\332\272\357=\303\005\330\277\027`\237\277\204\202\346\277u\303\256\277^h\256?<\000\030\277x\006\214?q\312\347?Y+\231?\010\242\222\277\336\211\237\277\364qx\277^\302\322>\254\000\313?\356f\234\277\241\022\372\277\345\262\274? O\244?kU\206\277\260\240\363?\226\263\211?\273#\307?\323\001\266?4\222<>\365\341\257\277\310\267j\277b\316y?\266 \210?\361;\025?1#\340>\002W\247\277\010\240\324\276y\235\221\277\355\220\214\277\034\226\032?\362\263\245\276\255R\217>\tg\245\277\273P\231\277\354B\206\275@\346\364\2768\037\215\277:\306\270?\247\337\212\277\317/\227?\211)\256\276\352\333\213\277\020\277\331\277~\031\263\277\036\225;?B~y\277Q\tw?\355\002\265?\361A\322?1\032\362\276\234\3715\275\\Z\024=/\254\333\277G\346\323\277T\"\273\277V\310_\277$j\274?\237\234\366?-s\216?\376\306\201?\240\375\201?\324G\314\277\331r\267\276\370\257\222>i\244\324?\324\265M?4\236\200?1\312\364\277R\251\217\277\020\\\351\277\224\023\362\277\r\264\215>$\356\311\277\314\251\261>\334M{?G\230\365\277\312o&?Q.\337?\034O\033\2773.v?\374tV\277m\257\243?I\216\n>\236d8\277r\311\363\277\241A\341\277\005\274z\277\002oO?l\232\343\277\236\r\314?\234/\271?5\221\340?I=\322\277\324+\336\276\316b\234?#\006d\275e\256m?\247\013\207\275K\003\236\276\270\317\t?\252!\344\277\334\303\324?\230i\320\277\204\010\302\277\216\227\360?\306\341\216\277G%l?c\227r\276\315\374\272?\016\020\'\276>\346\027?a\027\246\277\362\240\240?\264\370\025?\234M\035?\303B3\277\355E\265?x\025\302?\354\257\377\277|x\245\277\013\352\251>\377:\326?x\227\345\277&j\221\275@\216h\277bH\270\277/\001\255\277\t\347\322?\223&\311?\233\211\322\2778=\001\275H\3047?$D\252\277\362\177P\277\256\003\256?y\356\252\276t\\\345\277k\025\241;`\006\037\277]o\000?;\230I?\245\n\254?E\344-?/\330\230?c9\313?\344\262\375?\367\004\204\277\277aN>2\353\310>(fH<\302\237\345>\277\204\201?\264&\267?x\253\203\277<<.?\230T\361?\310\372\377\277\002s\373\277\n\277\027?\337\017U>|\317\210<C6d?\221\233\371?\213\027f\276\337\265\316\277T\275\334?\230;V\2776\376\351?;\343\312\277\343\352\377?Q\312a?\204\t\005\277\031\255\244\277 \370\311?\272\263S\277\260\215\330?Z\224\214?\005\247\332\276\302\264\303?)\257\265?o\207b?\254&v\276.\303\321\2765v\313\276>Io\277\022\324>\277P\"\031?\331E\235\277\350\035\222?^\315\226\277\374c\247\277\t\364\276\277M\325\323?r?\275?\222\335\262?#\320\312?\342\241\244\277\267\027\'?\247\200#\276\207\216W\276\024\024\261\277Zg\250\277\300\214\213>\344\233\302\277@\223\220;\021\330K?5?\263?\301\220\001\277\341\210\376?\263\032\204\277\344X\232?\312*\355\277\251\317\226?\265\320\360=\201\322\300?+\010\262\276q\301L>\231Aa\277V\362\030?\023\022{\277.\017\366\277H\365\251\276\236}F\277\233\020\313?D\266\361?I\300\014\276\027r\032?~\t\323?\312\271x\277\266\002\352\277h>t\277\265\320\033\276\243\010\351?\010\345\035>\\\t\221?J\241\371\277\177\014\367?\342~\311=?\036\325>\301\r\360\277S\200\372\275\365\340\375\277t\222\217>\224\335\004\277\327\277\300\277\206\212\265\277\240\224\231\277\275\377\320?\316\373\201\277\306\267\354\277\2442A\276\243k\364\277\031D\203\276\246\274\317\277\'\264\376\276\2569\344\277\252\330\267?=\273\357\276\022] \277\210m\302\277\252\227\367?&\227\035\277\376\273\340\276\325\260\231\276c\025\333\275n\216\352\277Y\213\347?\374A\333\277:9=?\2376\340?\333J\326\277\026\033r?s\032\217\277\254\320!\277\263\251\243\277\377\017\367?\033\267V\277\3135\037\277\026\ts\276\205\320\315>V4\315?\337G$?v=\254\277\302\316\256>q\206\334\277\327#\237?\312X\224=\371H??\201ZM\277:\004\202\277\201\nA\277Q\360\037?c\177\355\277\226\276\017\277\032x\n\277P;\354?q\323\031\277\025s\210\277\023\314e>\360\245\262\277\007\017\335=|\225H?5B\377\277\177\214\267>\223Y\200\277\265\004\362\277u\027\237?\211\332\222\277\261\263Y?p\336\263?t\223\217\275\340\007\266?T\275b?/f\343\277\310\361\357\277\357\332$?\206\224w?\353\370\352?\tB\010\277)l\006?@%\364?3\315\323\277n\3743?\364t\032\276Xi\204?(/T?,\236\'\2775\222\211?\3140t?\357\363\212?\320\261\246?{\227$\277\2730\242\277V.\360\275\317\375\366?\341@\177\277\365\216\247?NZ\206>\222\211\243\277\244g\357?u\307\354?vk\213\277\345\255\332?\355\274\370?V\357\351\276\314\3434\276\201\n\027>~\202\260\274\343\002\350?\240\331<?\376\371\322\277\225\305>\277\016IQ=\213\362\337?s\202.\277Q\267\266?\250\374\324?a\020\357\275&\376!\277\302\351\366\277\373\326\253>\212\374\267\277\3648\206>\302n\327?O;\240?\3642\313?\212\177\375\2773k\323\276;\355t?\010\263F?\335Qh\277\377\240\226\2758\225\274?H\320)\277\217\356\245\276\201\241e>nC\335?\n\362\237\277u}\216\276\353]\010\277\202R\234\277\346\225\232\275(\354\372>\037l\227\277kO\331>\335\036&>g\242%?\007\204\336\277(\351\242>Q7\341\277\347\234W\277b\'\222?\016\201\025??hI\276\004@M\277\243^U\277U\262\310\277Y\304:\277\256yY\276\325\244\224?\363\345o?O\255\353\277\007\236\">\215]\337\277y\257i?z\263X?\006\002\352\277\207}\306?QlB\277\002\374\273\277\250\344\024\277\347\032\274?\362\270\367\277\303v\226?\277:\014?\371K*\277q\0176\276\224~ ?\247Hu\277:\325\217\277\025\314,>z\230\361\276~n\356\276~\026\020\277\277\002%\276l\027\376\276\243&?\277e\374\267\277\000\300\311\277\240\356\243>\3747\357?|\306\236\277\303\242;?\222\364\377=3\000\326?\337\311\305\277V\260y\276{\236/?w\260\t\277\260\254V\277\336\030V\277\312\321L<\274C\313\277o\323\264\276rZ!\277\2703\324?G\'p?\263\377\303\277\331N\235?T\360\276?\2652\253?\213\344\211>\262\312\254\277\nRL\277=\275\367\277\376\276c\275\001\371\302\277\255\331\301?\312\331\221>\217\003\367\276s\214\003>\036\322\237?n\000\214:\177\371\375?\032\373\177?\374\353\253?\364Q\236\277k\000\255\277\241\340\321\276B[O?\323D\231\277p$^?\243Zp\277\226Tl\276l\304\203\277*\307\200>\321\320\376?=\243\'>V=T\277\025\337\321?\021\374-?\217.\244?\223g\357?l\374\263\277\216w\325\277-6\306?+\007\232?K\367i\277\025\307\330\275K\020\335?HCH\277 \273h\277QKN\277N\020\246\277\301\260\334>*T\271?\234\371}\276><C\277:X\250\275\332\304\337?\021B\250\276\030\342\356?\277\235\270?\3602\302?\2357\023\277\333\232y=7\326\342?\375\n\320?\241\rl?\327\2555?\204@d?\223\224\241?#\316\317\277m\333\004\2771\325\035?\275\2562\276&x[\277\014Z\322\276\034\330B?J\200\337?Z\361\023\277%u)\277\224\255\215?<>|?4\270h?\311\207A?\030+\265?\320\306\351?3}\275\276w\352\274\276\251<\332?\035\257\225\277\254\360\272\276\t\317\275\2778\244\254?\300\334Z\277X\222\377\277\221\321\261>-\243\270\277\016\304\355?m\315i\277\342\310\267?\024\335\177?\030{\326\2770\010\314?\321\316\214?\010\345\310\276~\240\327\277\326\\\343\277\372\030l?\203W\225\277\202\035\323?\034%\361\2769\177\330?C\371^\277@O\264?\272\370\336\277K\027\"\277\037^\346>\024\030\272?x\375\225\277\307\201\303>\344W\344\277Hk\004?;\363\326?\342/\234\277\304\203\252\277\342\244\336=\355N!?\264\335\220\277\362l\231?\257\237Q?\020\275\350\277\236_!>\316X\260\277X.\346?mQ\223\277 \372\034\277\233\334\\\276#>\265?C\024j?T\242\216>5#\275\277\203\262;\277\343\340\330?\t\010\273?\212\276`?\330z\353\277\341E\203=\271\274\311?&\305\261?\023\031\207\277.\263:?b\266\217\277\334\010\206?\247*\321\277SC8\277dnO>}<\307>\266\025\352?\300\177\366\2769\\s?\275G>\2771\022\n?\037K\215\277\260\221\324\276\007\253\313?\0362\333?Wn\264\277F0\021\276U\253\300\277d\306\346?,\304\323>\352-l?C\223\243?\334\365\233\277\315\320\013\277\030L\333\277\234\232b\276\271(\021\276\263:H\277\230\245E\277$\302\211\276\270r\344?X\225z\276\216\370\214\277P;\227?\253\307T?\372\2052?|\211\224\275\010\3679?\355\265u?\351\320\370?^^U>\332\340\022?\304\372\032?\253j\264\277;\r2\276\257\005\232?\325\234\267>\037I\337?\262\237\027\277\202J\341?BU\264\277\273\303\357\277\322\213D?dp\203\274\372ig?9\337\371\276o]\250?\300\335\222>7y\276>\334d\'?6\227\205?\022\205\302\277\220<\245?\207\3152\277.\'X\277\206\363\204?\364c\321\276R\263\335?04\237?,\306n\276\"Y\320>\260\223\214?I\366\225\277Y\001\340\2777\256Q?\026\000\210\277R\363\327\276H\005\267?G]=?\3614D?\014\360\345\276\327h!\276\'\344\365?\357U\307\277\316Z\246?\240\305\266\277s@\335?E>\376?>\363\244\277\334\330\350\275\032\342\256?\rw\223\277\022q\035\277\027\241\320\277<\261\257>pY\327\277\024\222\312>rL\242>I\204$\277\0010\200?@g\365\277\000\322Z?q\337\257?\262\345\347?\037\334\230\276\341\335?>\324kf\276\201i\345\277I\016 ?ij\350\277\247\337\353\276\312\365%=\"\256v\277\306m\340\277|\010\236?\351A\246?\013R\362?\306)\244?T\353\271>BW#?\330\246\027\277\013\371\201\277\213\243\366>Ck\350>\216\016\322?\030\324\355?\334g\261\277S\016\210>\266\223\364?\3768\247\277(Q}\277\262\007\224?\346fx>\354r\240\277WLF?\2107\272?9j\224\277\013 4>\022\232T\277\264\356D\277*\305\227\276\341Z\345;\255\323\363?\3212\367?\375\266\024\277\266\006\360\277\327JB\276\364e\024?\037<v>\022\314\321<5\202\207>2\263\336?.\nr\2777n\371\277y\021\037?\375\n\373=.\352K\277\343\365\330\277\030\214\200\277d\213\266\2771y\016?\321\374z\277,\031Y>\266\262\240\277\307\247\035\277\013\037\363\277\257\267\257?=-\246?\237\321\364?\333\337\026?\363r\215\277\357\303\312\277\202\262\317?\022\007\344\277*\230\314\277\re\207\277\243\020\267?\262R\345?\320\333\027\277\201E\214\276\241\'\340\277o[\214\277\037!\244\277z+\276\277DZs\277F\016\310?\324z\252?\252{\362?/\211\226?j\014\327>\t\200\306\277kr\211?\311:\251?\005\266\333\277\204V\215\2772\235x?w\216\253?\to\225\277\226\273\234\277X\343\233\277\2371\357?\203\241Q?\203O\334?-\\\303\277\031\207\217\275\343\353\242\276\266\332\376?\214$\300\277YZ<\277\001{\316?\204\257\344?\241\376x\276\205g\310?\214r\356>\364\236\270\277\277\3067?~_\230\277(\340\353?\001=#?yN\254\276\235\013\323\2774\312V?R\216\365\277\326! \277z,]?\3525G\277\204\324\312?\227\200\031? \300\337\276\304I\241\277\313\335\'?\"\360\331\277\317\177\320?\235ft?\36404?\251|\270\277\025\003\313\277K\215\300?\2541&?\345\202\331>F\311y?\032\361\304?h\264`\277\276\346\253\276l\231\376\277\336\373\337\27736\300\276a\242\377\277\026`\375\277^\336s?\326\203j\277C:_\277\245\275\353?\261\233\366>\232\003\215?-\317\341?\r\266.?~\304\217?\214M\356>\201Of=\302\211\351\277\320\273\326\277\305\254\353\277\335a\300\277F)\n\277\003V\271\276!\254@\277\352\373\235?9\352O?\020\205`?\360\307\245\274\007\312\370?\234c\252?A\266\305?\227\033\265\277\246/\366\277=\307\307?\311\373\320?l\205\364?\023m\276?Zug>\234\017\343?\2015;?\353\325F\277L\024t>\270k\336\277\037\033\216?H\313n\276i\327\322>L\263\226\275D5\252\277&\005J\275\037\316\263\277\327\324*?\034!\376=\363\245N?\276\2517?\275\271\361?\370\214\305\277\224b\305?l(\331?\233\356\206\277Unx\2778\3029>\225z\216?\275G\272>o\231S\277\304\017\257\276\346\223^\277\304\202\235>\337\326\260\276\257T\250\277\322\233\243\277\212\371?\277\347\345,?B{\300?\031!\302?S\016h?6\026\255<\347Y6\277\203\252f\277\314p\030\2767\335R?\032\377\347\277q\302\232?e\353\220?\3744\212?\351A\255?\336H\334\277\304\022D?\006^\216?\337\336\367?.zo\277H\036\211\277\363\344\274\277\371,\276?\"t\265?\\\373\232<L\217\342?wy\330?\\^\371?c\251\324\277j,\305\276\255<\247?\317\336\353\277\354[\255\276)\265\340?\250\257o?p\r\233?O1\366\276\370\246\033?T\332\001?\275\031(\277\001\313a\276\327CA>\t\023\277\277@\233z?a\202o\277\361\205\322\277e\204\034?\260\254~\277u\233W>\240N\220?Jw\361\277u\031\257\276\200\001\347\277\307U0>2\305\237?\320~<?\276\301\346?\272x\206\277\2279\\?\250\013\260\277\334\275\n\277\217=\345\276REy?m3x?\022\270{>\365\227\356?\343\360\353\276A\021\273?\002\017\311?\366t\243\277\271\232w?j \272\277\271\265\221?\310_\373?\2670T\277\331\274u<e7D?P<\232?\355M\362\277`<\305>\262B\356?\301\347g?\372\206\272\277\327B\321\277\017Y\324?O\244\353\277k\345\216?W$o?\350\210\333=\345\313\237?\353\213\353\2774\265\217?\037\366\346\276\r \201=\227Bj\2773\232\006\277\007\235f>n\346\272\277\2729\326?\354U\273?Q \224\277yT>?\231\3019\276rH\271\277\374F\324?\007?[\276b\220\320?<M]\277\207w\257?\327i\273>%\214;>\0209\362?!\317\362\277\2128\361?VG\204?\r\242\322\276\305a\357\277#\350\245\277\n=\262?j\324\203>f\336\237\277\022\332\r\277-s`\277\350\267O\276\036\324\360\277\277rU\277\246\301\354?\311\250?\277h\373\353==\201\275>\244\036\340?\274\372\264=\016\202\225?+\000Y\277\032\221\244>\263j\303>a\374\254\276q\216\302>\374I]\277\034B\276\277\340\352\263?Q\001I\277\344/\322\276\\\037\364\276uA\354=\004\377\007?\263\347\215>\377\0146?\265\231m\277\305\270\256=.^\355?\307\n\367?yOF?\364\374b>Q\233\227\277\361x~?\320\n}\276\037\375\243\277\\v\265\277\034\227\202\276\345k\370>\"5\201\277\246\344\251?\210x\252?V\001\255?\0345\221\277,H%?\316\2102\277J1\342\277\036]\222\277\320\305\232?o\024\355\277\326S\355?\340\177\217\277\310\234m\277\0220\212?\317\240/\277\023\344\350?\334\301s?\205\207\242\276\211J\220?\227B4?H\366\013?\274\315\361>\243\026\206\277\357\207\222\277\005\226\236>\240\036\216>c=)?>\364\332>P\343\305?1B}?\312)+\277F@\231>\244F\325\276\314\345q>\221\025\310?P/\202?\323\353\014?(\351|?4\014e?\317\r\274\275\223\361\213\277\352\304@\276\3227\237\277\350\267(?QL\206\277\373\213G?w\007\007\277$\232\324\277\3331\"\277\267\210\276\277\324v\263\276\204\256\305?\\7\342\277C\365I\277\312D\202?\304\035\335?>\260\247?O\226\246\276\030\203\300?\216\263$\277\376\205\177\277M\371\320\277\003G\017?e\224\355?)\266J\276\362\260\240?a\341\301>^Y\300\276\341\"\372\276\234l\247?I\302\244?\202\300\234\277C\234:\277\357L\226\277\r\323l?\321\034Q\277(\343\301?\366?\336\277\261\323\261\277I\354\314?p\244\351?\327\341F?\325\332\324\277\3107\025<\227%\177\277\244\261\356>)\372\316?l%\013\277\317]\272\277\214\350%\276\373K\343\274o\354\237\27718\364?_\262\273\275\244\364\333?\2056\263?\000\'\334\276\314F\343>|\224??o@\262?\323\371\271\276\374\t5\277R\300\326\275F\247\246\277\2371\201\277\300:\312\276\n\227\336\276P\207+\276\377q\324?\242\207\231\277\031\313v?]\n\352\277\310|\227?\370[8?o,\251\277\201\023\255\277\030Z\213?\"c\234?@\327\366\277\250\261\277\275\230\310\302\276\264\304\363?fm\224?\351)\032\277\345U9\277\264\201\271\277\022\344\307\277\310:\271\277L\304\316?I\274\310\277\270\237\202\276N\244\257\277\350\241s\277\276\r\241? \244\244?Hk\335\277\337&\264?\007\255\302?\303\374\374?iN\312\277\333\221\311?&-\275\276\271\033\177?|4l\277\034\236f\275M\214\275\277\216\260\350?\265\315\376?Y\370\342>\304\2323?\336\3515?\263\2619>\333|e\277v\033\311\276\332\337$?\230v\235\277\031\016\351\275\021+\234?\265\033\307\276\242\356\347?\260y\004\277<\222$\277PP\302?\3108[\277\366\301\306\277o[\205?\036\354\375?\360bp>zi\255\277$L\\\277\nO\225\277\337)\210\277\276\002Q\276\364<\200\276JDY\277C\035\267?\317\032\321\277~g\215\275\n/[\277\231\307I\277\212\037\245>U\251\226\277\027\020\271\277\206\320\261\276^i\310\276f\336\367\277r$\211\277\343y\322\276\261\355\226?\026\231\360\277\225\003\252\277\376\325\204?\326C\236\277)t\243?\223\035\000?\036\003\252\276\026\271\317?\357\023\362\277\264J\334\276\010$\274\275W\226:\277\267\347\004?\034\331\211\277(\313\206>\322$\341\277\234\263\300?G\336\005?\331u\203\277\251\350@>)6y\277j\307q?V>\367?\274\\\201\277\324\"\366>U\376\320\274)\005\203>j\367\274\2779\256\266=\025\333\366?\026\367\356\277\341\200\226\275\005Q\271>\304\000I?\017\336\341?\215\363\346\276\236s(?q\214\241\276\'\351\251\277c\227\036\276I\331\231?K\372I=z\352\213\275\026\024\361\277\210G\302?_\320\302\277\267y\207\277u2)\277\375E\235\277=\225\267\274\221?\306?\265\346\226\277\324|\002>a\365\311\277\265\242\347\277\025\373\031?\207G\311?\230\023\336\277\264\273\256\277\266\032\270>f\311\243\277@\237\217\277W\345H\276\204\261\323\277B\213\032\277&]\320\276q\226\244\277\336B\342>\232\022\252>\366\376\257?P\024\247\277\251@\226?\233\273\311>\200A\312?\352O\245?\357\277\265\277\222\341\234?\307q\343>\030l\372\277\242\316(?1\3767\277Di\277?\005\352\257?ZE\313?\270-\237\277\360\316\245?\020X\330\276d\276b\277\021\243\215\277\3233Z\276\0202\271\277t\310\314?A\331\254?\326|{>$\017\264\277{\375\306?\336\210\374>E`\237?\002\342>>\n\244\342?\215\004M?\201\370\323\276L\016\231?#\t\017=\3600\333\277\020\240\217?|\363]?T\254\214?~\344\240?\312\260\217\277\324z\376\277\264\260v?\344\223\336\277\225\260A\27724\310?F\227\263>8\222P>\343\032\202?\272T\225\277\002\250\213?\232\333f\277Dx\221\277\037\366&\277O\314\303?9\231\373\277\222\027\305\276\266Z\203\277\005$\003?\232h\222?%\215\212\276%\233\257?\203O\336\277\336W\304\277\357\007\342\277\014\326\207?\263Wa?6\330\275>\322\255\217\277qm\240\277w\335\267?\212\351\344\277!s\342\277.\211\347\277\243fc?\361\357\374>o\341\216\277\271\335\260<\r:\343\277\204\016b\2772%\214?\235\005\312\277C\301\234\276r\332x\277\261\214\370>d:\340>\026\317\234\277\202\341Z?\216\213*?\304{\334?\0368\277?\221vG?8r\327?I~\206\277\255\325x>\243\n\222\277\345\301%\277\245\313\204?\241)\340\277\265%\253\277\002;\243\276\342\027\253\277\300\372\226\277V\314f?\230M\342\276\241NM\277\013\371e?\216\026\032\277\343\377y\277\323q\330\277\203\223L?\355\360\257?S^t?{Q\372\277\306\270\230\276\226U\221>9B\345?\322\003\277?\371\222\342?\361\301\232\276\224\267\204\277\t\253\354\277\201\177\357\2756\332\373?*\270\324\277\3037\034?\317\225]\277\361J\356\276\006qz>~q\200?\234s\372\277\026\312\271?x\304\371=tI\217\277\254\235\177?p\367\322?K\351<\277\371l\300?\"A\357\277\274\366\323\276\374\327\311\277N\266\207\277g\333\t>\177q\262?\302\004$?` \321?\024?\313?\347\262\237\276e\331\264?\005:\366\277\256\367\317>\351\352\346?\013\221\"\277m\225\313\2761\345k>2*\r\277\317\003\245?l`\356\277A\304\351?\0061\377\277+\255{?\021\332\253\277LO\254?f\265\357\277\331\036\331?\021Zl?\331\334\203?\211\360C\277\245\273\277\277\366\001\345?\213v\261?*6\260?\202\035\331\277~^\201?\351\257\324?\352\032I?\302\337\316\277$\027\237\277\177T\344?\026\307\201?\017K\021\277-\027\204>\017T\240\277_C\235?\333b\232>\026;W\277\005\232\037?" + } + } + } +} +node { + name: "gen_quant_npy" + op: "FakeQuantWithMinMaxArgs" + input: "gen_quant_npy/inputs" + attr { + key: "max" + value { + f: 1.9997752904891968 + } + } + attr { + key: "min" + value { + f: -1.9998407363891602 + } + } + attr { + key: "narrow_range" + value { + b: false + } + } + attr { + key: "num_bits" + value { + i: 8 + } + } +} +node { + name: "fake_quant_inputs" + op: "FakeQuantWithMinMaxArgs" + input: "placeholder_0" + attr { + key: "max" + value { + f: 1.9997752904891968 + } + } + attr { + key: "min" + value { + f: -1.9998407363891602 + } + } + attr { + key: "narrow_range" + value { + b: false + } + } + attr { + key: "num_bits" + value { + i: 8 + } + } +} +node { + name: "fake_quant_wts" + op: "FakeQuantWithMinMaxArgs" + input: "const_1" + attr { + key: "max" + value { + f: 1.9936614036560059 + } + } + attr { + key: "min" + value { + f: -1.9891220331192017 + } + } + attr { + key: "narrow_range" + value { + b: false + } + } + attr { + key: "num_bits" + value { + i: 8 + } + } +} +node { + name: "conv" + op: "Conv2D" + input: "fake_quant_inputs" + input: "fake_quant_wts" + attr { + key: "T" + value { + type: DT_FLOAT + } + } + attr { + key: "data_format" + value { + s: "NHWC" + } + } + attr { + key: "dilations" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "explicit_paddings" + value { + list { + } + } + } + attr { + key: "padding" + value { + s: "SAME" + } + } + attr { + key: "strides" + value { + list { + i: 1 + i: 1 + i: 1 + i: 1 + } + } + } + attr { + key: "use_cudnn_on_gpu" + value { + b: true + } + } +} +node { + name: "result" + op: "FakeQuantWithMinMaxArgs" + input: "conv" + attr { + key: "max" + value { + f: 10.0 + } + } + attr { + key: "min" + value { + f: -10.0 + } + } + attr { + key: "narrow_range" + value { + b: false + } + } + attr { + key: "num_bits" + value { + i: 8 + } + } +} +versions { + producer: 498 +} diff --git a/reference_model/CMakeLists.txt b/reference_model/CMakeLists.txt new file mode 100644 index 0000000..0ba8afb --- /dev/null +++ b/reference_model/CMakeLists.txt @@ -0,0 +1,76 @@ +cmake_minimum_required (VERSION 3.4) + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +project(tosa_reference_model LANGUAGES CXX) + +set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +if(CMAKE_CXX_COMPILER_ID STREQUAL GNU) + set(CMAKE_CXX_FLAGS "-Wall -Wno-ignored-attributes -Wno-format-truncation") +else() + set(CMAKE_CXX_FLAGS "-Wall -Wno-ignored-attributes") +endif() + +set(FLATBUFFERS_DIR "../thirdparty/flatbuffers/") +set(SERIALIZATION_DIR "../serialization") + +set (CXX_SOURCE + src/main.cpp + src/tensor.cc + src/graph_node.cc + src/subgraph_traverser.cc + src/func_debug.cc + src/func_config.cc + src/ops/op_factory.cc + src/ops/tensor_ops.cc + src/ops/activation_funcs.cc + src/ops/ewise_binary.cc + src/ops/ewise_unary.cc + src/ops/ewise_ternary.cc + src/ops/comparison.cc + src/ops/reduction.cc + src/ops/data_layout.cc + src/ops/scatter_gather.cc + src/ops/image.cc + src/ops/type_conversion.cc + src/ops/data_nodes.cc + src/ops/custom.cc + src/ops/control_flow.cc +) + +add_executable(tosa_reference_model ${CXX_SOURCE}) + +target_include_directories(tosa_reference_model + PUBLIC + $<INSTALL_INTERFACE:include> + $<BUILD_INTERFACE:${CMAKE_CURRENT_SRC_DIR}/include> + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/src + ${FLATBUFFERS_DIR}/include + ../thirdparty/eigen/ + ../thirdparty/eigen/unsupported/ + ${SERIALIZATION_DIR} +) + +target_link_libraries(tosa_reference_model + PRIVATE + flatbuffers + tosa_serialization +) + +install (TARGETS tosa_reference_model DESTINATION bin) diff --git a/reference_model/src/arith_util.h b/reference_model/src/arith_util.h new file mode 100644 index 0000000..554a7a2 --- /dev/null +++ b/reference_model/src/arith_util.h @@ -0,0 +1,194 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + * Filename: src/arith_util.h + * Description: + * arithmetic utility macro, include: + * fp16 (float16_t ) type alias + * bitwise operation + * fix point arithmetic + * fp16 type conversion(in binary translation) + * fp16 arithmetic (disguised with fp32 now) + */ + +#ifndef ARITH_UTIL_H +#define ARITH_UTIL_H + +#include <fenv.h> +#include <math.h> +#define __STDC_LIMIT_MACROS //enable min/max of plain data type +#include "func_debug.h" +#include "inttypes.h" +#include <cassert> +#include <iostream> +#include <limits> +#include <stdint.h> +#include <typeinfo> + +using namespace std; + +inline size_t _count_one(uint64_t val) +{ + size_t count = 0; + for (; val; count++) + { + val &= val - 1; + } + return count; +} + +template <typename T> +inline size_t _integer_log2(T val) +{ + size_t result = 0; + while (val >>= 1) + { + ++result; + } + return result; +} + +template <typename T> +inline size_t _count_leading_zeros(T val) +{ + size_t size = sizeof(T) * 8; + size_t count = 0; + T msb = static_cast<T>(1) << (size - 1); + for (size_t i = 0; i < size; i++) + { + if (!((val << i) & msb)) + count++; + else + break; + } + return count; +} + +template <typename T> +inline size_t _count_leading_ones(T val) +{ + size_t size = sizeof(T) * 8; + size_t count = 0; + T msb = static_cast<T>(1) << (size - 1); + for (size_t i = 0; i < size; i++) + { + if ((val << i) & msb) + count++; + else + break; + } + return count; +} + +#define MAX(a, b) ((a) > (b) ? (a) : (b)) +#define MIN(a, b) ((a) < (b) ? (a) : (b)) +// Compute ceiling of (a/b) +#define DIV_CEIL(a, b) ((a) % (b) ? ((a) / (b) + 1) : ((a) / (b))) + +// Returns a mask of 1's of this size +#define ONES_MASK(SIZE) ((uint64_t)((SIZE) >= 64 ? 0xffffffffffffffffULL : ((uint64_t)(1) << (SIZE)) - 1)) + +// Returns a field of bits from HIGH_BIT to LOW_BIT, right-shifted +// include both side, equivalent VAL[LOW_BIT:HIGH_BIT] in verilog + +#define BIT_FIELD(HIGH_BIT, LOW_BIT, VAL) (((uint64_t)(VAL) >> (LOW_BIT)) & ONES_MASK((HIGH_BIT) + 1 - (LOW_BIT))) + +// Returns a bit at a particular position +#define BIT_EXTRACT(POS, VAL) (((uint64_t)(VAL) >> (POS)) & (1)) + +// Use Brian Kernigahan's way: https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan +// Does this need to support floating point type? +// Not sure if static_cast is the right thing to do, try to be type safe first +#define ONES_COUNT(VAL) (_count_one((uint64_t)(VAL))) + +#define SHIFT(SHF, VAL) (((SHF) > 0) ? ((VAL) << (SHF)) : ((SHF < 0) ? ((VAL) >> (-(SHF))) : (VAL))) +#define ROUNDTO(A, B) ((A) % (B) == 0 ? (A) : ((A) / (B) + 1) * (B)) +#define ROUNDTOLOWER(A, B) (((A) / (B)) * (B)) +#define BIDIRECTIONAL_SHIFT(VAL, SHIFT) (((SHIFT) >= 0) ? ((VAL) << (SHIFT)) : ((VAL) >> (-(SHIFT)))) +#define ILOG2(VAL) (_integer_log2(VAL)) + +// Get negative value (2's complement) +#define NEGATIVE_8(VAL) ((uint8_t)(~(VAL) + 1)) +#define NEGATIVE_16(VAL) ((uint16_t)(~(VAL) + 1)) +#define NEGATIVE_32(VAL) ((uint32_t)(~(VAL) + 1)) +#define NEGATIVE_64(VAL) ((uint64_t)(~(VAL) + 1)) +// Convert a bit quanity to the minimum bytes required to hold those bits +#define BITS_TO_BYTES(BITS) (ROUNDTO((BITS), 8) / 8) + +// Count leading zeros/ones for 8/16/32/64-bit operands +// (I don't see an obvious way to collapse this into a size-independent set) +// treated as unsigned +#define LEADING_ZEROS_64(VAL) (_count_leading_zeros((uint64_t)(VAL))) +#define LEADING_ZEROS_32(VAL) (_count_leading_zeros((uint32_t)(VAL))) +#define LEADING_ZEROS_16(VAL) (_count_leading_zeros((uint16_t)(VAL))) +#define LEADING_ZEROS_8(VAL) (_count_leading_zeros((uint8_t)(VAL))) +#define LEADING_ZEROS(VAL) (_count_leading_zeros(VAL)) + +#define LEADING_ONES_64(VAL) _count_leading_ones((uint64_t)(VAL)) +#define LEADING_ONES_32(VAL) _count_leading_ones((uint32_t)(VAL)) +#define LEADING_ONES_16(VAL) _count_leading_ones((uint16_t)(VAL)) +#define LEADING_ONES_8(VAL) _count_leading_ones((uint8_t)(VAL)) +#define LEADING_ONES(VAL) _count_leading_ones(VAL) +// math operation +// sign-extended for signed version +// extend different return type (8, 16, 32) + (S, U) +// Saturate a value at a certain bitwidth, signed and unsigned versions +// Format is as followed: SATURATE_VAL_{saturation_sign}_{return_type} +// for example +// SATURATE_VAL_U_8U(8,300) will return uint8_t with value of 255(0xff) +// SATURATE_VAL_S_32S(5,-48) will return int32_t with value of -16(0x10) +// note that negative value can cast to unsigned return type using native uint(int) cast +// so SATURATE_VAL_S_8U(5,-40) will have value 0'b1110000 which is in turn 224 in uint8_t + +template <typename T> +constexpr T bitmask(const uint32_t width) +{ + ASSERT(width <= sizeof(T) * 8); + return width == sizeof(T) * 8 ? static_cast<T>(std::numeric_limits<uintmax_t>::max()) + : (static_cast<T>(1) << width) - 1; +} + +template <typename T> +constexpr T minval(const uint32_t width) +{ + ASSERT(width <= sizeof(T) * 8); + return std::is_signed<T>::value ? -(static_cast<T>(1) << (width - 1)) : 0; +} + +template <typename T> +constexpr T maxval(const uint32_t width) +{ + ASSERT(width <= sizeof(T) * 8); + return bitmask<T>(width - std::is_signed<T>::value); +} + +template <typename T> +constexpr T saturate(const uint32_t width, const intmax_t value) +{ + // clang-format off + return static_cast<T>( + std::min( + std::max( + value, + static_cast<intmax_t>(minval<T>(width)) + ), + static_cast<intmax_t>(maxval<T>(width)) + ) + ); + // clang-format on +} + +#endif /* _ARITH_UTIL_H */ diff --git a/reference_model/src/debug_modes.def b/reference_model/src/debug_modes.def new file mode 100644 index 0000000..51b151d --- /dev/null +++ b/reference_model/src/debug_modes.def @@ -0,0 +1,20 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Defines the debugging printing modes + +DEBUG_MODE(CONFIG,0) // Configuration parsing/initialization +DEBUG_MODE(GT,1) // Graph traverser +DEBUG_MODE(OP,2) // Operation diff --git a/reference_model/src/debug_types.h b/reference_model/src/debug_types.h new file mode 100644 index 0000000..bd93f19 --- /dev/null +++ b/reference_model/src/debug_types.h @@ -0,0 +1,57 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + * Filename: src/debug_types.h + * Description: + * Defines fundamental debugger datatypes for the functional model + */ + +#ifndef DEBUG_TYPES_H_ +#define DEBUG_TYPES_H_ + +#ifdef __cplusplus +extern "C" +{ +#endif + + // Debug verbosity mask + typedef enum func_debug_verbosity_e + { + DEBUG_VERB_NONE = 0x00, + DEBUG_VERB_INFO = 0x01, // Informational debugging messages + DEBUG_VERB_IFACE = 0x02, // Interface debugging support + DEBUG_VERB_LOW = 0x04, // Low, medium, and high levels of debug printout + DEBUG_VERB_MED = 0x08, + DEBUG_VERB_HIGH = 0x10 + } func_debug_verbosity_e; + + // Generated debug modes enumeration + typedef enum func_debug_mode_e + { + DEBUG_NONE = 0x0, +#define DEBUG_MODE(NAME, BIT) DEBUG_##NAME = (1UL << BIT), +#include "debug_modes.def" +#undef DEBUG_MODE + DEBUG_ALL = 0xffffffffffffffffUL + } func_debug_mode_e; + +#define DEBUG_INST_ALL 0xffffffffffffffffUL + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/reference_model/src/func_config.cc b/reference_model/src/func_config.cc new file mode 100644 index 0000000..bd1ce32 --- /dev/null +++ b/reference_model/src/func_config.cc @@ -0,0 +1,632 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include <ctype.h> +#include <signal.h> +#include <stdarg.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> + +#include "func_config.h" +#include "func_debug.h" + +#define MAX_NAME_LEN 128 +#define MAX_DESC_LEN 128 + +#ifndef ARG_ERROR +#define ARG_ERROR(...) \ + fprintf(stderr, "ERROR: "); \ + fprintf(stderr, __VA_ARGS__); \ + fprintf(stderr, "\n"); \ + return 1; +#endif + +// Parameter base name string table +const char* config_base_name_table[] = { +#define DEF_UNIT_START(UNIT) +#define DEF_UNIT_END(UNIT) +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) #NAME, +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) #NAME, +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) #NAME, +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) #NAME, +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR +#undef DEF_UNIT_OPTION +}; + +// Parameter description table +const char* config_param_desc_table[] = { +#define DEF_UNIT_START(UNIT) +#define DEF_UNIT_END(UNIT) +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) #DESC, +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) #DESC, +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) #DESC, +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) #DESC, +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_UNIT_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR +}; + +// String table and enum for the option hierarchy level/sub-levels +// (no leaf options). Attribute at the top level have "BASE" as their +// enum value and an empty string for the value. +const char* config_hier_str_table[] = { + "", +#define DEF_UNIT_START(UNIT) #UNIT, +#define DEF_UNIT_END(UNIT) /**/ +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) /**/ +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) /**/ +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) /**/ +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) /**/ +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_UNIT_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR +}; + +typedef enum config_hier_enum_t +{ + BASE, +#define DEF_UNIT_START(UNIT) CURRENT_UNIT, +#define DEF_UNIT_END(UNIT) /**/ +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) /**/ +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) /**/ +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) /**/ +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) /**/ +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_UNIT_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR + + MAX_CONFIG_HIER +} config_hier_enum_t; + +// Mapping from a leaf parameter index to the +// position in the hierarchy. +config_hier_enum_t config_hierarchy_map[] = { +#define DEF_UNIT_START(UNIT) +#define DEF_UNIT_END(UNIT) +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) BASE, +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) BASE, +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) CURRENT_UNIT, +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) CURRENT_UNIT, +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_UNIT_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR +}; + +#define CONFIG_PARAMETER_COUNT (sizeof(config_hierarchy_map) / sizeof(config_hier_enum_t)) + +// Dynamically generated at initialization +char** config_param_str_table = nullptr; + +// Initialize the configuration data structures +int func_model_init_config() +{ + // Initialize string table (builds the hierarchical names) + config_param_str_table = (char**)calloc(CONFIG_PARAMETER_COUNT, sizeof(char*)); + ASSERT_MEM(config_param_str_table); + + for (uint32_t i = 0; i < CONFIG_PARAMETER_COUNT; i++) + { + size_t len = strlen(config_base_name_table[i]) + 1; + if (config_hierarchy_map[i] != BASE) + { + ASSERT_MSG(config_hierarchy_map[i] <= MAX_CONFIG_HIER, + "Configuration parameter\'s hierarchy is out of bounds"); + len += strlen(config_hier_str_table[config_hierarchy_map[i]]) + 1; + } + config_param_str_table[i] = (char*)calloc(len, 1); + ASSERT_MEM(config_param_str_table[i]); + ASSERT_MSG(len < MAX_NAME_LEN, "option expanded name is too long: %s", config_base_name_table[i]); + + if (config_hierarchy_map[i] != BASE) + { + snprintf(config_param_str_table[i], len, "%s.%s", config_hier_str_table[config_hierarchy_map[i]], + config_base_name_table[i]); + } + else + { + snprintf(config_param_str_table[i], len, "%s", config_base_name_table[i]); + } + } + + return 0; +} + +int func_model_set_default_config(func_config_t* func_config) +{ + // Set default values in the global configuration data structure + bzero(func_config, sizeof(*func_config)); + +#define DEF_UNIT_START(UNIT) +#define DEF_UNIT_END(UNIT) +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) func_config->NAME = (DEFAULT); +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) strncpy(func_config->NAME, (DEFAULT), (LEN)-1); +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) func_config->UNIT.NAME = (DEFAULT); +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) strncpy(func_config->UNIT.NAME, (DEFAULT), (LEN)-1); +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_UNIT_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR + + return 0; +} + +int func_model_config_cleanup() +{ + uint32_t i; + + if (!config_param_str_table) + return 1; + + for (i = 0; i < CONFIG_PARAMETER_COUNT; i++) + { + free(config_param_str_table[i]); + } + + free(config_param_str_table); + config_param_str_table = nullptr; + + return 0; +} + +int func_model_config_set_option(func_config_t* func_config, const char* name, const char* value) +{ + // Increment an index variable on each parameter position + // so that we can index both the position struct through the macro and the + // array of parameter names through a simple array of strings. + int param_idx = 0; + char* endptr; + + // TODO: does not handle strings yet. Can set magic values on FMT to + // choose a string copy vs strtoull +#define DEF_UNIT_START(UNIT) +#define DEF_UNIT_END(UNIT) +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) \ + if (!strcmp(config_param_str_table[param_idx], name)) \ + { \ + func_config->NAME = (uint64_t)strtoll(value, &endptr, 0); \ + if (endptr == value) \ + { \ + ARG_ERROR("Cannot parse option: %s = %s", name, value); \ + } \ + return 0; \ + } \ + param_idx++; + +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) \ + if (!strcmp(config_param_str_table[param_idx], name)) \ + { \ + if (strlen(value) >= LEN) \ + { \ + ARG_ERROR("Option value is too long: %s = %s", name, value); \ + } \ + strncpy(func_config->NAME, value, (LEN)-1); \ + return 0; \ + } \ + param_idx++; + +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) \ + if (!strcmp(config_param_str_table[param_idx], name)) \ + { \ + func_config->UNIT.NAME = (uint64_t)strtoll(value, &endptr, 0); \ + if (endptr == value) \ + { \ + ARG_ERROR("Cannot parse option: %s = %s", name, value); \ + } \ + return 0; \ + } \ + param_idx++; + +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) \ + if (!strcmp(config_param_str_table[param_idx], name)) \ + { \ + if (strlen(value) >= LEN) \ + { \ + ARG_ERROR("Option value is too long: %s = %s", name, value); \ + } \ + strncpy(func_config->UNIT.NAME, value, (LEN)-1); \ + return 0; \ + } \ + param_idx++; + +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_UNIT_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR + + // No match! + ARG_ERROR("Cannot find option: %s", name); + + return 1; +} + +int func_model_config_get_option_by_name(func_config_t* func_config, const char* name, uint64_t* val) +{ + // Increment an index variable on each parameter position + // so that we can index both the position struct through the macro and the + // array of parameter names through a simple array of strings. + int param_idx = 0; + +#define DEF_UNIT_START(UNIT) +#define DEF_UNIT_END(UNIT) + +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) param_idx++; + +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, FMT, DEFAULT) param_idx++; + +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) \ + if (!strcmp(config_param_str_table[param_idx], name)) \ + { \ + *val = func_config->NAME; \ + return 0; \ + } \ + param_idx++; + +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) \ + if (!strcmp(config_param_str_table[param_idx], name)) \ + { \ + *val = func_config->UNIT.NAME; \ + return 0; \ + } \ + param_idx++; + +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_UNIT_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR + // No match! + return 1; +} +int func_model_config_get_str_option_by_name(func_config_t* func_config, + const char* name, + char* value, + const uint32_t len) +{ + // Increment an index variable on each parameter position + // so that we can index both the position struct through the macro and the + // array of parameter names through a simple array of strings. + int param_idx = 0; + +#define DEF_UNIT_START(UNIT) +#define DEF_UNIT_END(UNIT) +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) \ + if (!strcmp(config_param_str_table[param_idx], name)) \ + { \ + strncpy(value, func_config->NAME, len - 1); \ + return 0; \ + } \ + param_idx++; + +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) \ + if (!strcmp(config_param_str_table[param_idx], name)) \ + { \ + strncpy(value, func_config->UNIT.NAME, len - 1); \ + return 0; \ + } \ + param_idx++; + +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) param_idx++; + +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) param_idx++; + +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_UNIT_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR + // No match! + return 1; +} + +int func_config_print_config_help(FILE* out) +{ + fprintf(out, "%-40s %s\n", "Option", "Description"); + fprintf(out, "%-40s %s\n", "------", "-----------"); + + for (uint32_t i = 0; i < CONFIG_PARAMETER_COUNT; i++) + { + fprintf(out, "-C%-40s %s\n", config_param_str_table[i], config_param_desc_table[i]); + } + + fprintf(out, "\n"); + + return 0; +} + +int func_model_print_config(func_config_t* func_config, FILE* out) +{ +#define DEF_UNIT_START(UNIT) +#define DEF_UNIT_END(UNIT) +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) fprintf(out, "%-40s = " FMT "\n", #NAME, func_config->NAME); +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) \ + fprintf(out, "%-40s = " FMT "\n", #UNIT "." #NAME, func_config->UNIT.NAME); +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) fprintf(out, "%-40s = %s\n", #NAME, func_config->NAME); +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) \ + fprintf(out, "%-40s = %s\n", #UNIT "." #NAME, func_config->UNIT.NAME); + +#define FOF_HEX "0x%llx" +#define FOF_DEC "%" PRIu32 +#define FOF_DECU64 "%" PRIu64 + +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_UNIT_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION_STR + + return 0; +} + +static const char* programname; + +void func_model_print_debug_masks(FILE* out) +{ + fprintf(out, "\t List of components:\n"); +#define DEBUG_MODE(string, value) fprintf(out, "\t\t" #string "\n"); +#include "debug_modes.def" +#undef DEBUG_MODE +} + +int func_model_print_help(FILE* out) +{ + fprintf(out, "TOSA Reference Model help\n\n"); + + fprintf(out, + "Usage: %s [-c] [-C <name=value>] [-d <Debug Mask>] [-h] [-i <uscriptfile>] [-l <verbosity>] [-F " + "<flatconfig>]\n", + programname); + fprintf(out, "\t-c - Print list of config options\n"); + fprintf(out, "\t-C <name=value> - modify config option <name> to <value>\n"); + fprintf(out, "\t-d <Debug Mask - set component debug mask\n"); + func_model_print_debug_masks(out); + fprintf(out, "\t-F <flatconfig> - parse <flatconfig> as file of config options\n"); + fprintf(out, "\t-h - show this help message and exit\n"); + fprintf( + out, + "\t-i <input_tensor_name>,<filename> - set input tensor <input_tensor_name> to the values from <filename>\n"); + fprintf(out, "\t-l <verbosity> - set log verbosity\n"); + fprintf(out, "\t-o <debuglog> - set debug log file\n"); + fprintf(out, "\n"); + + func_config_print_config_help(stdout); + + return 0; +} + +static const char* get_arg_text(int& index, const int argc, const char** argv) +{ + if (strlen(argv[index]) > 2) + { + return argv[index] + 2; + } + + if ((index + 1 == argc) || (argv[index + 1][0] == '-')) + { + fprintf(stderr, "No option value found for option %s\n", argv[index]); + return ""; + } + + index++; + return argv[index]; +} + +// Read the command line arguments +int func_model_parse_cmd_line(func_config_t* func_config, func_debug_t* func_debug, const int argc, const char** argv) +{ + int i; + programname = argv[0]; + for (i = 1; i < argc; i++) + { + // All command line arguments must begin with -X where X is a recognized character + if (strlen(argv[i]) < 2 || argv[i][0] != '-') + { + func_model_print_help(stderr); + ARG_ERROR("Command line argument at position %d not valid: %s", i, argv[i]); + } + + switch (argv[i][1]) + { + // Model parameters may be overridden with the -Cname=value switch + case 'c': + func_config_print_config_help(stderr); + return 1; + + case 'C': + { + const char *name = nullptr, *value = nullptr; + + // Break the string into name and value parts + name = get_arg_text(i, argc, argv); + value = strchr(name, '='); + + if (value == nullptr) + { + func_model_print_help(stderr); + ARG_ERROR("Cannot parse -C argument at position %d: %s", i, argv[i]); + } + + *const_cast<char*>(value) = 0; + + if (func_model_config_set_option(func_config, name, value + 1)) + { + func_model_print_help(stderr); + ARG_ERROR("Cannot parse -C argument at position %d: %s", i, argv[i]); + } + break; + } + + case 'd': + case 'D': + { + func_debug_set_mask(func_debug, get_arg_text(i, argc, argv)); + break; + } + case 'F': + { + // Read a flat configuration file + if (func_model_parse_flat_config_file(func_config, get_arg_text(i, argc, argv))) + return 1; + + break; + } + case 'h': + func_model_print_help(stderr); + return 1; + + case 'i': + { + // shortcut for '-Cinput_tensor=' + if (func_model_config_set_option(func_config, "input_tensor", get_arg_text(i, argc, argv))) + { + func_model_print_help(stderr); + ARG_ERROR("Cannot set input tensor config value"); + } + break; + } + case 'l': + { + // Debug verbosity/logging level + func_debug_set_verbosity(func_debug, get_arg_text(i, argc, argv)); + break; + } + case 'o': + { + func_debug_set_file(func_debug, get_arg_text(i, argc, argv)); + break; + } + default: + func_model_print_help(stderr); + ARG_ERROR("Unrecognized argument at position %d: %s", i, argv[i]); + } + } + + return 0; +} + +int func_model_parse_flat_config_file(func_config_t* func_config, const char* filename) +{ + const int MAX_LINE_LEN = 1024; + + FILE* infile = nullptr; + char line_buf[MAX_LINE_LEN]; + int line = 1; + + infile = fopen(filename, "r"); + + if (infile == nullptr) + { + ARG_ERROR("Cannot open config file: %s\n", filename); + } + + while (fgets(line_buf, MAX_LINE_LEN - 1, infile) != nullptr) + { + char *name = line_buf, *value = nullptr, *comment = nullptr, *ptr = nullptr; + + // Remove comments + comment = strchr(line_buf, '#'); + + if (comment) + *comment = 0; + + // Break the string into name and value parts + name = line_buf; + + // Remove leading whitespace + while (*name && isspace(*name)) + name++; + + // Empty line? + if (*name == 0) + { + line++; + continue; + } + + value = strchr(name, '='); + + // Missing value + if (value == nullptr) + { + ARG_ERROR("Cannot parse parameter in %s at line %d: %s", filename, line, line_buf); + } + + // Remove the = + *value = 0; + value++; + + // Trim off any whitespace at the end of the value + ptr = value; + while (*ptr != 0 && !isspace(*ptr)) + ptr++; + *ptr = 0; + + // Include a nested file + if (!strcmp(name, "include")) + { + if (func_model_parse_flat_config_file(func_config, value)) + return 1; + line++; + continue; + } + + if (func_model_config_set_option(func_config, name, value)) + { + func_model_print_help(stderr); + ARG_ERROR("Cannot set parameter in %s at line %d: %s", filename, line, line_buf) + } + + line++; + } + + fclose(infile); + + return 0; +} diff --git a/reference_model/src/func_config.def b/reference_model/src/func_config.def new file mode 100644 index 0000000..004cf36 --- /dev/null +++ b/reference_model/src/func_config.def @@ -0,0 +1,90 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + * Filename: src/func_config.def + * Description: + * Defines the model parameters/options for the functional model. + */ + +// Placeholder values for the Functional model Option Formatting (FOF) fields +// +// FOF_DEC is decimal +// FOF_HEX is hexidecimal +// +// Floating point values are not supported yet, but there is no fundamental reason +// why we can't have them. +#ifndef FOF_DEC +#define FOF_DEC 1 +#endif + +#ifndef FOF_HEX +#define FOF_HEX 1 +#endif + +#ifndef FOF_STR_LEN +#define FOF_STR_LEN 1024 +#endif + +// Options are defined as follows: +// DEF_OPTION() defines a top-level option +// Arguments: +// option_field_name: a C-syntax field name in the struct +// description: a short string that describes the purpose of the option (printed out with help) +// C type: the type of the option (typically a uint64_t, uint32_t, etc) +// Format field: the FOF_* type used to figure out how to format/print the option +// Default value: the default value assigned to the option, if it isn't assigned by an configuration file +// or command line override + +// For defining hierarchical options (example hierarchy is 'cle', use the following formula). +// All options within the hierarchical space must be grouped together: +// + +// #define CURRENT_UNIT cle +// DEF_UNIT_START(CURRENT_UNIT) +// DEF_UNIT_OPTION(CURRENT_UNIT,...) +// ... +// DEF_UNIT_END(CURRENT_UNIT) +// #undef CURRENT_UNIT +// +// The CURRENT_UNIT argument is required as a parameter in these definitions because +// macro processing rules only allow stringification of macro parameters. Unfortunately, +// Other tokens that are NOT passed in as macro parameters cannot be stringified. + +DEF_OPTION_STR(operator_fbs, "Flat buffer syntax file", FOF_STR_LEN, "../serialization/tosa.fbs") +DEF_OPTION_STR(subgraph_dir, "Subgraph directory to load", FOF_STR_LEN, ".") +DEF_OPTION_STR(subgraph_file, "Subgraph file to load", FOF_STR_LEN, "") +DEF_OPTION_STR(input_dir, "Input directory path for dumps/files", FOF_STR_LEN, ".") +DEF_OPTION_STR(input_tensor, "A list of pairs <name0>:<npy0>,<name1>:<npy1>", FOF_STR_LEN, "") +DEF_OPTION_STR(output_dir, "Output directory path for output dumps/files", FOF_STR_LEN, ".") +DEF_OPTION(eval, "Evaluate the network (0/1)", uint32_t, FOF_DEC, 1) +DEF_OPTION(validate_only, "Validate the network, but do not read inputs or evaluate (0/1)", uint32_t, FOF_DEC, 0) +DEF_OPTION(output_tensors, "Output tensors to a file (0/1)", uint32_t, FOF_DEC, 1) +DEF_OPTION(tosa_profile, "Set TOSA profile (0 = Base Inference, 1 = Main Inference, 2 = Main Training)", uint32_t, FOF_DEC, 1) +DEF_OPTION_STR(output_tensor_prefix, "Optional output tensor prefix", FOF_STR_LEN, "output_") +DEF_OPTION(dump_intermediates, "Dump intermediate tensors (0/1)", uint32_t, FOF_DEC, 0) +DEF_OPTION_STR(fp_format, "Floating-point number dump format string (printf-style format, e.g. 0.5)", FOF_STR_LEN, "0.5") +// Example of a hierarchical option +//#define CURRENT_UNIT arch +//DEF_UNIT_START(arch) +//DEF_UNIT_OPTION(arch, ifm_width, "input feature map width(x dim)", uint32_t, FOF_DEC, 10) +//DEF_UNIT_END(CURRENT_UNIT) +///#undef CURRENT_UNIT + +// START Do not delete +// Required for keeping the FOFs clean +#undef FOF_DEC +#undef FOF_HEX +// END Do not delete^^ diff --git a/reference_model/src/func_config.h b/reference_model/src/func_config.h new file mode 100644 index 0000000..f941300 --- /dev/null +++ b/reference_model/src/func_config.h @@ -0,0 +1,55 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef FUNC_CONFIG_H_ +#define FUNC_CONFIG_H_ + +// Parameter value structure +#define DEF_UNIT_START(UNIT) \ + struct UNIT##_t \ + { +#define DEF_UNIT_END(UNIT) \ + } \ + UNIT; +#define DEF_OPTION(NAME, DESC, TYPE, FMT, DEFAULT) TYPE NAME; +#define DEF_OPTION_STR(NAME, DESC, LEN, DEFAULT) char NAME[LEN]; +#define DEF_UNIT_OPTION(UNIT, NAME, DESC, TYPE, FMT, DEFAULT) TYPE NAME; +#define DEF_UNIT_OPTION_STR(UNIT, NAME, DESC, LEN, DEFAULT) char NAME[LEN]; +struct func_config_t +{ +#include "func_config.def" +#undef DEF_UNIT_START +#undef DEF_UNIT_END +#undef DEF_OPTION +#undef DEF_OPTION_STR +#undef DEF_UNIT_OPTION +#undef DEF_UNIT_OPTION_STR +}; + +// Forward declaration +struct func_debug_t; + +int func_model_init_config(); +int func_model_set_default_config(func_config_t*); +int func_model_config_set_option(func_config_t*, const char* name, const char* value); +int func_model_print_config(func_config_t*, FILE* out); +int func_model_parse_cmd_line(func_config_t*, func_debug_t* func_debug, const int argc, const char** argv); +int func_model_parse_flat_config_file(func_config_t*, const char* filename); +int func_model_config_cleanup(); +int func_model_config_get_str_option_by_name(func_config_t*, const char* name, char* value, const uint32_t len); +int func_model_config_get_option_by_name(func_config_t*, const char* name, uint64_t* val); +int func_model_print_help(FILE* out); + +#endif diff --git a/reference_model/src/func_debug.cc b/reference_model/src/func_debug.cc new file mode 100644 index 0000000..f5f045e --- /dev/null +++ b/reference_model/src/func_debug.cc @@ -0,0 +1,436 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include <ctype.h> +#include <signal.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <sys/types.h> + +#ifndef _MSC_VER +#include <execinfo.h> +#include <sys/prctl.h> +#include <sys/ptrace.h> +#include <sys/wait.h> +#include <unistd.h> +#endif + +#include "func_debug.h" + +#define MAX_FRAMES 100 + +#ifndef _MSC_VER +pid_t func_print_backtrace_helper(int num_tries, int sig); +#endif + +void func_print_backtrace(FILE* out, int sig) +{ +#ifndef _MSC_VER + for (int i = 0; i < 2; i++) + { + const pid_t child_pid = func_print_backtrace_helper(i, sig); + if (child_pid < 0) + { + perror("Backtrace generation failed on fork"); + break; + } + + int status = 0; + waitpid(child_pid, &status, 0); + if (WEXITSTATUS(status) == 0) + { + break; + } + } +#endif +} + +#ifndef _MSC_VER +pid_t func_print_backtrace_helper(int num_tries, int sig) +{ + const pid_t child_pid = fork(); + + if (child_pid) + { + return 0; + } + + const pid_t ppid = getppid(); + + printf("Attaching debugger to pid %d\n", ppid); + // Check if we're in a debugger + if (ptrace(PTRACE_ATTACH, ppid, 0, 0) == 0) + { + // If we reach this point, no debugger is present + // Undo effects of PTRACE_ATTACH + waitpid(ppid, NULL, 0); + ptrace(PTRACE_CONT, 0, 0, 0); + ptrace(PTRACE_DETACH, ppid, 0, 0); + + dup2(STDERR_FILENO, STDOUT_FILENO); + + char parent_pid[20]; + snprintf(parent_pid, sizeof(parent_pid), "attach %d", ppid); + fprintf(stdout, "Caught signal %d (%s)\n", sig, strsignal(sig)); + + execlp("gdb", "gdb", "--batch", "-n", "-ex", + // Don't print startup messages for each thread + "-ex", "set print thread-events off", "-ex", parent_pid, + // Turn off pagination + "-ex", "set height 0", + // Print a backtrace for the current thread + "-ex", "thread $_thread", "-ex", "bt", + // Print a backtrace for the main thread (uncomment the next two lines, if desired) + //"-ex", "thread 1", + //"-ex", "bt", + // Print a backtrace for all thread (TMI) + //"-ex", "thread apply all bt", + NULL); + + // If we reach this point, it is bad. Attempt to print an error before exiting. + perror("Backtrace generation failed to invoke gdb"); + exit(1); + } + + // Debugger present. Exit here. + exit(0); + + return 0; +} +#endif + +void func_backtrace_signal_handler(int sig) +{ + func_print_backtrace(NULL, sig); + exit(1); +} + +// Note: this overwrites other signal handlers. May want to make this +// more friendly sometime +void func_enable_signal_handlers() +{ + static const int sig_list[] = { SIGABRT, SIGSEGV, SIGILL, SIGFPE }; + + if (getenv("FUNC_NO_SIG_HANDLERS")) + { + return; + } + + for (size_t i = 0; i < sizeof(sig_list) / sizeof(int); i++) + { + struct sigaction act; + + bzero(&act, sizeof(act)); + act.sa_handler = func_backtrace_signal_handler; + + if (sigaction(sig_list[i], &act, NULL)) + { + perror("Error calling sigaction"); + } + } +} + +const char* func_debug_mode_str_table[] = { +#define DEBUG_MODE(NAME, BIT) #NAME, +#include "debug_modes.def" +#undef DEBUG_MODE +}; + +#define DEBUG_MASK_COUNT (sizeof(func_debug_mode_str_table) / sizeof(const char*)) + +const char* func_debug_verbosity_str_table[] = { "NONE", "INFO", "IFACE", "LOW", "MED", "HIGH" }; + +const uint32_t func_debug_verbosity_mask_table[] = { DEBUG_VERB_NONE, DEBUG_VERB_INFO, DEBUG_VERB_IFACE, + DEBUG_VERB_LOW, DEBUG_VERB_MED, DEBUG_VERB_HIGH }; + +#define DEBUG_VERBOSITY_COUNT (sizeof(func_debug_verbosity_str_table) / sizeof(const char*)) + +// Initialize the debug mode +int func_init_debug(func_debug_t* func_debug, uint64_t inst_id) +{ + // Set the default debug settings + bzero(func_debug, sizeof(func_debug_t)); + func_debug_set_mask(func_debug, DEBUG_NONE); + func_debug_set_verbosity(func_debug, DEBUG_VERB_NONE); + func_debug_set_inst_mask(func_debug, DEBUG_INST_ALL); + func_debug->func_debug_file = stderr; + func_debug_set_captured_warnings(func_debug, 0); + func_debug_set_output_unbuffered(func_debug, false); + func_debug->inst_id = inst_id; + + return 0; +} + +int func_fini_debug(func_debug_t* func_debug) +{ + if (func_debug->record_warnings) + { + func_debug_set_captured_warnings(func_debug, 0); + } + +#ifndef _FUNC_INCLUDE_WINDOWS_SUPPORT_H + if (func_debug->is_gzip && func_debug->func_debug_file) + { + pclose(func_debug->func_debug_file); + func_debug->func_debug_file = NULL; + } +#endif + + return 0; +} + +int func_debug_set_file(func_debug_t* func_debug, const char* filename) +{ + int filenameLen = strlen(filename); + + // Open the debug output file + ASSERT(filename != NULL); +#ifndef _FUNC_INCLUDE_WINDOWS_SUPPORT_H + if (filenameLen > 3 && strcmp(filename + filenameLen - 3, ".gz") == 0) + { + char cmd[256]; + + snprintf(cmd, sizeof(cmd), "gzip > %s", filename); + func_debug->func_debug_file = popen(cmd, "w"); + func_debug->is_gzip = 1; + } + else + { +#else + { +#endif + func_debug->func_debug_file = fopen(filename, "w"); + } + + if (!func_debug->func_debug_file) + { + perror(NULL); + FATAL_ERROR("Cannot open debug output file: %s\n", filename); + return 1; + } + if (func_debug->is_output_unbuffered) + { + setvbuf(func_debug->func_debug_file, nullptr, _IONBF, 0); + } + + return 0; +} + +void func_debug_set_verbosity(func_debug_t* func_debug, const char* str) +{ + if (!strcasecmp(str, "RESET")) + { + func_debug_set_verbosity(func_debug, DEBUG_VERB_NONE); + return; + } + + for (size_t i = 0; i < DEBUG_VERBOSITY_COUNT; i++) + { + if (!strcasecmp(str, func_debug_verbosity_str_table[i])) + { + func_debug_set_verbosity(func_debug, func_debug_verbosity_mask_table[i]); + return; + } + } + + FATAL_ERROR("Invalid debug verbosity: %s", str); +} + +void func_debug_set_verbosity(func_debug_t* func_debug, const uint32_t verb) +{ + uint32_t new_mask = verb; + + switch (verb) + { + case DEBUG_VERB_NONE: + new_mask = DEBUG_VERB_NONE; + break; + case DEBUG_VERB_INFO: + new_mask = DEBUG_VERB_INFO; + break; + case DEBUG_VERB_IFACE: + new_mask = DEBUG_VERB_IFACE; + break; + case DEBUG_VERB_HIGH: + new_mask |= DEBUG_VERB_HIGH; + // Intentional fallthrough + case DEBUG_VERB_MED: + new_mask |= DEBUG_VERB_MED; + // Intentional fallthrough + case DEBUG_VERB_LOW: + new_mask |= DEBUG_VERB_LOW; + new_mask |= DEBUG_VERB_INFO; + new_mask |= DEBUG_VERB_IFACE; + break; + } + + func_debug->func_debug_verbosity = new_mask; +} + +void func_debug_set_suppress_arch_error_mask(func_debug_t* func_debug, const uint32_t suppress) +{ + func_debug->func_suppress_arch_error_mask = suppress; +} + +void func_debug_set_mask(func_debug_t* func_debug, const uint64_t mask) +{ + if (mask == DEBUG_NONE) + func_debug->func_debug_mask = mask; + else + func_debug->func_debug_mask |= mask; + + // Set a minimum verbosity level + if (func_debug->func_debug_verbosity == DEBUG_VERB_NONE) + func_debug->func_debug_verbosity = DEBUG_VERB_INFO; +} + +void func_debug_set_inst_mask(func_debug_t* func_debug, const char* mask) +{ + uint64_t val; + + val = strtoul(mask, NULL, 0); + + return func_debug_set_inst_mask(func_debug, val); +} + +void func_debug_set_inst_mask(func_debug_t* func_debug, const uint64_t mask) +{ + if (mask == 0) + func_debug->func_debug_inst_mask = DEBUG_INST_ALL; + else + func_debug->func_debug_inst_mask = mask; +} + +void func_debug_set_mask(func_debug_t* func_debug, const char* str) +{ + if (!strcasecmp(str, "all")) + { + func_debug_set_mask(func_debug, UINT64_MAX - 1); + return; + } + + size_t i; + for (i = 0; i < DEBUG_MASK_COUNT; i++) + { + if (!strcasecmp(str, func_debug_mode_str_table[i])) + { + func_debug_set_mask(func_debug, 1ULL << i); + return; + } + } + + func_debug_print_masks(stderr); + + FATAL_ERROR("Invalid debug mask: %s", str); +} + +void func_debug_print_masks(FILE* out) +{ + uint32_t i; + + fprintf(out, "Available debug masks:\n"); + + for (i = 0; i < DEBUG_MASK_COUNT; i++) + { + fprintf(out, "[%d] %s\n", i, func_debug_mode_str_table[i]); + } +} + +void func_debug_set_output_unbuffered(func_debug_t* func_debug, const bool is_unbuffered) +{ + func_debug->is_output_unbuffered = is_unbuffered; +} + +// Print warnings to the debug file or optionally store them in a buffer instead +// Note that the buffer is circular and can be overwritten if enough messages are +// written before removing a warning from the front. +void func_debug_warning( + func_debug_t* func_debug, const char* file, const char* func, const int line, const char* fmt, ...) +{ + va_list args; + va_start(args, fmt); + + if (func_debug->record_warnings) + { + // Record to the circular buffer + uint32_t len; + + len = snprintf(func_debug->warning_buffer[func_debug->warning_buffer_tail], WARNING_BUFFER_ENTRY_LENGTH, + "WARNING AT %s:%d %s(): ", file, line, func); + vsnprintf(func_debug->warning_buffer[func_debug->warning_buffer_tail] + len, WARNING_BUFFER_ENTRY_LENGTH - len, + fmt, args); + func_debug->warning_buffer_tail = (func_debug->warning_buffer_tail + 1) % WARNING_BUFFER_SIZE; + } + else + { + // Print to the debug file (e.g., stderr) + fprintf(func_debug->func_debug_file, "WARNING AT %s:%d %s():\n", file, line, func); + vfprintf(func_debug->func_debug_file, fmt, args); + fprintf(func_debug->func_debug_file, "\n"); + } + va_end(args); +} + +// Initialize the warning buffer capture +int func_debug_set_captured_warnings(func_debug_t* func_debug, uint32_t capture) +{ + uint32_t i; + func_debug->record_warnings = capture; + if (capture) + { + func_debug->warning_buffer_head = 0; + func_debug->warning_buffer_tail = 0; + + for (i = 0; i < WARNING_BUFFER_SIZE; i++) + { + func_debug->warning_buffer[i] = (char*)calloc(1, WARNING_BUFFER_ENTRY_LENGTH); + } + } + else + { + for (i = 0; i < WARNING_BUFFER_SIZE; i++) + { + if (func_debug->warning_buffer[i]) + { + free(func_debug->warning_buffer[i]); + func_debug->warning_buffer[i] = NULL; + } + } + } + + return 0; +} + +int func_debug_has_captured_warning(func_debug_t* func_debug) +{ + if (func_debug->record_warnings && func_debug->warning_buffer_head != func_debug->warning_buffer_tail) + return 1; + else + return 0; +} + +int func_debug_get_captured_warning(func_debug_t* func_debug, char* buf_ptr, const uint32_t buf_len) +{ + if (!func_debug_has_captured_warning(func_debug)) + return 1; + + strncpy(buf_ptr, func_debug->warning_buffer[func_debug->warning_buffer_head], buf_len); + + func_debug->warning_buffer_head = (func_debug->warning_buffer_head + 1) % WARNING_BUFFER_SIZE; + + return 0; +} diff --git a/reference_model/src/func_debug.h b/reference_model/src/func_debug.h new file mode 100644 index 0000000..2d47462 --- /dev/null +++ b/reference_model/src/func_debug.h @@ -0,0 +1,255 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef FUNC_DEBUG_H +#define FUNC_DEBUG_H + +#include "debug_types.h" +#include <assert.h> +#include <cinttypes> +#include <signal.h> +#include <stdio.h> + +void func_print_backtrace(FILE* out, int sig = SIGABRT); + +void func_enable_signal_handlers(); + +// Debug content container +#define WARNING_BUFFER_SIZE 16 +#define WARNING_BUFFER_ENTRY_LENGTH 1024 + +// STRINGIFY2 is needed expand expression passed to STRINGIFY +#define STRINGIFY2(s) #s +#define STRINGIFY(s) STRINGIFY2(s) + +// If TRACED_LOG is defined, add file:line to log messages +#if defined(TRACED_LOG) +#define WHERE "@" __FILE__ ":" STRINGIFY(__LINE__) +#else +#define WHERE +#endif + +#if defined(COLORIZED_LOG) +#define COL(col, fmt) "\x1b[3" col "m" fmt "\x1b[0m" +#define COL_FATAL(fmt) COL("1;41", fmt) +#define COL_WARN(fmt) COL("1;43", fmt) +#define COL_INFO(fmt) COL("2", fmt) +#define COL_IFACE(fmt) fmt +#define COL_LOW(fmt) COL("35", fmt) +#define COL_MED(fmt) COL("2;33", fmt) +#define COL_HIGH(fmt) COL("2;32", fmt) +#else +#define COL_FATAL(fmt) fmt +#define COL_WARN(fmt) fmt +#define COL_INFO(fmt) fmt +#define COL_IFACE(fmt) fmt +#define COL_LOW(fmt) fmt +#define COL_MED(fmt) fmt +#define COL_HIGH(fmt) fmt +#endif + +struct func_debug_t +{ + uint32_t func_debug_verbosity; // What verbosity level is set? (bitmask) + uint64_t func_debug_mask; // Which units have debugging enabled? (bitmask) + uint64_t func_debug_inst_mask; // Which instances have debugging enabled (bitmask) + uint64_t inst_id; // The instance id for multiple model instances + uint32_t func_suppress_arch_error_mask; // Which architecture error should be suppressed? (bitmask) + FILE* func_debug_file; // Output file + uint32_t record_warnings; + char* warning_buffer[WARNING_BUFFER_SIZE]; + uint32_t warning_buffer_head; // next unread message + uint32_t warning_buffer_tail; // next message to write + uint32_t is_gzip; + bool is_output_unbuffered; // should log files be opened with unbuffered I/O. +}; + +#ifndef ASSERT +#define ASSERT(COND) \ + if (!(COND)) \ + { \ + fprintf(stderr, COL_FATAL("ASSERTION AT %s:%d %s(): (%s)\n"), __FILE__, __LINE__, __func__, #COND); \ + func_print_backtrace(stderr); \ + assert(COND); \ + } +#endif + +#ifndef ASSERT_MSG +#define ASSERT_MSG(COND, fmt, ...) \ + if (!(COND)) \ + { \ + fprintf(stderr, COL_FATAL("ASSERTION AT %s:%d %s(): (%s)\n"), __FILE__, __LINE__, __func__, #COND); \ + fprintf(stderr, COL_FATAL(fmt) "\n", ##__VA_ARGS__); \ + func_print_backtrace(stderr); \ + assert(COND); \ + } +#endif + +#ifndef ASSERT_MSG_NODE +#define ASSERT_MSG_NODE(COND, fmt, ...) \ + if (!(COND)) \ + { \ + fprintf(g_func_debug.func_debug_file, COL_FATAL("ASSERTION AT %s:%d %s(): (%s)\n"), __FILE__, __LINE__, \ + __func__, #COND); \ + fprintf(g_func_debug.func_debug_file, COL_FATAL(fmt) "\n", ##__VA_ARGS__); \ + this->dumpNode(g_func_debug.func_debug_file); \ + func_print_backtrace(g_func_debug.func_debug_file); \ + assert(COND); \ + } +#endif + +// Assertion specific to allocating memory +#ifndef ASSERT_MEM +#define ASSERT_MEM(OBJ) \ + if (!(OBJ)) \ + { \ + fprintf(stderr, COL_FATAL("ASSERTION AT %s:%d %s(): (" #OBJ "): out of memory\n"), __FILE__, __LINE__, \ + __func__); \ + func_print_backtrace(stderr); \ + assert(OBJ); \ + } +#endif + +#ifndef FATAL_ERROR +#define FATAL_ERROR(fmt, ...) \ + fprintf(stderr, COL_FATAL("FATAL ERROR AT %s:%d %s():\n"), __FILE__, __LINE__, __func__); \ + fprintf(stderr, COL_FATAL(fmt) "\n", ##__VA_ARGS__); \ + func_print_backtrace(stderr); \ + abort(); +#endif + +#ifndef FATAL_ERROR_NODE +#define FATAL_ERROR_NODE(fmt, ...) \ + fprintf(g_func_debug.func_debug_file, COL_FATAL("FATAL ERROR AT %s:%d %s():\n"), __FILE__, __LINE__, __func__); \ + fprintf(g_func_debug.func_debug_file, COL_FATAL(fmt) "\n", ##__VA_ARGS__); \ + this->dumpNode(g_func_debug.func_debug_file); \ + func_print_backtrace(g_func_debug.func_debug_file); \ + abort(); +#endif +#ifndef SIMPLE_FATAL_ERROR +#define SIMPLE_FATAL_ERROR(fmt, ...) \ + fprintf(stderr, COL_FATAL(fmt) "\n", ##__VA_ARGS__); \ + exit(1); +#endif + +void func_debug_warning( + func_debug_t* func_debug, const char* file, const char* func, const int line, const char* fmt, ...); +#ifndef WARNING +#define WARNING(...) func_debug_warning(&g_func_debug, __FILE__, __func__, __LINE__, __VA_ARGS__) +#endif + +#ifndef WARNING_STDERR +#define WARNING_STDERR(fmt, ...) \ + fprintf(stderr, COL_WARN("WARNING AT %s:%d %s():\n"), __FILE__, __LINE__, __func__); \ + fprintf(stderr, COL_WARN(fmt) "\n", ##__VA_ARGS__); +#endif + +int func_debug_set_captured_warnings(func_debug_t* func_debug, uint32_t capture); + +int func_debug_has_captured_warning(func_debug_t* func_debug); + +int func_debug_get_captured_warning(func_debug_t* func_debug, char* buf_ptr, const uint32_t buf_len); + +// Is this debug verbosity and unit level enabled? +// Provide compiler hints that this is unlikely +// Two versions, depending on whether DEBUG_INSTANCE_EXPR is defined in a file or not +// +// For .cpp files whose units have discrete instance IDs, define DEBUG_INSTANCE_EXPR to evalute +// to the instance ID variable. The use of this define in header files is discouraged. + +#ifdef DEBUG_INSTANCE_EXPR +// Expression for whether the debugging verbosity + debugging unit is enabled for free-form printouts +#ifdef DEBUG_INSTANCE_EXPR_2 +#define DEBUG_ENABLED(VERB, LEVEL) \ + (__builtin_expect((g_func_debug.func_debug_mask == DEBUG_ALL || g_func_debug.func_debug_mask & (DEBUG_##LEVEL)) && \ + (g_func_debug.func_debug_inst_mask & (uint64_t(1) << (DEBUG_INSTANCE_EXPR))) && \ + (g_func_debug.func_debug_verbosity & (VERB)), \ + 0)) +// Debug printing macro +#define DEBUG(VERB, LEVEL, FMT, ...) \ + if (DEBUG_ENABLED(VERB, LEVEL)) \ + { \ + fprintf(g_func_debug.func_debug_file, "[%d:" #LEVEL "_%02d_%02d" WHERE "]: " FMT "\n", \ + (int)g_func_debug.inst_id, (int)(DEBUG_INSTANCE_EXPR), (int)(DEBUG_INSTANCE_EXPR_2), ##__VA_ARGS__); \ + } + +// Prints just the debugging prefix for properly marking free-form printouts +#define DEBUG_PREFIX(LEVEL) \ + fprintf(g_func_debug.func_debug_file, "[%d" #LEVEL "_%02d_%02d" WHERE "]: ", (int)g_func_debug.inst_id, \ + (int)(DEBUG_INSTANCE_EXPR), (int)(DEBUG_INSTANCE_EXPR_2)) + +#else // !DEBUG_INSTANCE_EXPR_2 + +#define DEBUG_ENABLED(VERB, LEVEL) \ + (__builtin_expect((g_func_debug.func_debug_mask == DEBUG_ALL || g_func_debug.func_debug_mask & (DEBUG_##LEVEL)) && \ + (g_func_debug.func_debug_inst_mask & (uint64_t(1) << (DEBUG_INSTANCE_EXPR))) && \ + (g_func_debug.func_debug_verbosity & (VERB)), \ + 0)) +// Debug printing macro +#define DEBUG(VERB, LEVEL, FMT, ...) \ + if (DEBUG_ENABLED(VERB, LEVEL)) \ + { \ + fprintf(g_func_debug.func_debug_file, "[%d:" #LEVEL "_%02d" WHERE "]: " FMT "\n", (int)g_func_debug.inst_id, \ + (int)(DEBUG_INSTANCE_EXPR), ##__VA_ARGS__); \ + } + +// Prints just the debugging prefix for properly marking free-form printouts +#define DEBUG_PREFIX(LEVEL) \ + fprintf(g_func_debug.func_debug_file, "[%d:" #LEVEL "_%02d" WHERE "]: ", (int)g_func_debug.inst_id, \ + (int)(DEBUG_INSTANCE_EXPR)) + +#endif // DEBUG_INSTANCE_EXPR_2 + +#else // !DEBUG_INSTANCE_EXPR + +// Expression for whether the debugging verbosity + debugging unit is enabled for free-form printouts +#define DEBUG_ENABLED(VERB, LEVEL) \ + (__builtin_expect((g_func_debug.func_debug_mask == DEBUG_ALL || g_func_debug.func_debug_mask & (DEBUG_##LEVEL)) && \ + (g_func_debug.func_debug_verbosity & (VERB)), \ + 0)) +// Debug printing macro +#define DEBUG(VERB, LEVEL, FMT, ...) \ + if (DEBUG_ENABLED(VERB, LEVEL)) \ + { \ + fprintf(g_func_debug.func_debug_file, "[%d:" #LEVEL WHERE "]: " FMT "\n", (int)g_func_debug.inst_id, \ + ##__VA_ARGS__); \ + } + +// Prints just the debugging prefix for properly marking free-form printouts +#define DEBUG_PREFIX(LEVEL) fprintf(g_func_debug.func_debug_file, "[" #LEVEL WHERE "]: ") + +#endif + +// Macros for different verbosity levels +#define DEBUG_INFO(LEVEL, FMT, ...) DEBUG(DEBUG_VERB_INFO, LEVEL, COL_INFO(FMT), ##__VA_ARGS__) +#define DEBUG_IFACE(LEVEL, FMT, ...) DEBUG(DEBUG_VERB_IFACE, LEVEL, COL_IFACE(FMT), ##__VA_ARGS__) +#define DEBUG_LOW(LEVEL, FMT, ...) DEBUG(DEBUG_VERB_LOW, LEVEL, COL_LOW(FMT), ##__VA_ARGS__) +#define DEBUG_MED(LEVEL, FMT, ...) DEBUG(DEBUG_VERB_MED, LEVEL, COL_MED(FMT), ##__VA_ARGS__) +#define DEBUG_HIGH(LEVEL, FMT, ...) DEBUG(DEBUG_VERB_HIGH, LEVEL, COL_HIGH(FMT), ##__VA_ARGS__) + +int func_init_debug(func_debug_t*, uint64_t inst_id); +int func_fini_debug(func_debug_t*); +int func_debug_set_file(func_debug_t*, const char* filename); +void func_debug_set_mask(func_debug_t*, const char* str); +void func_debug_set_mask(func_debug_t*, const uint64_t mask); +void func_debug_print_masks(FILE* out); +void func_debug_set_verbosity(func_debug_t*, const char* str); +void func_debug_set_verbosity(func_debug_t*, const uint32_t verb); +void func_debug_set_suppress_arch_error_mask(func_debug_t*, const uint32_t suppress); +void func_debug_set_inst_mask(func_debug_t*, const char* mask); +void func_debug_set_inst_mask(func_debug_t*, const uint64_t mask); +void func_debug_set_output_unbuffered(func_debug_t*, const bool is_unbuffered); + +#endif diff --git a/reference_model/src/graph_node.cc b/reference_model/src/graph_node.cc new file mode 100644 index 0000000..b57b9dd --- /dev/null +++ b/reference_model/src/graph_node.cc @@ -0,0 +1,226 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "graph_node.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +GraphNode::GraphNode(const Op& nodeType_, const uint64_t id_) +{ + nodeType = nodeType_; + nodeId = id_; + inputs.clear(); + outputs.clear(); + inputNames.clear(); + outputNames.clear(); + clearNodeMarked(); + evalCount = 0; + clearOnNextNodeList(); + setRequiredOperands(-1, -1); + setRequiredRank(-1); +} + +GraphNode::~GraphNode() +{} + +int GraphNode::addInputName(std::string& name) +{ + inputNames.push_back(name); + return 0; +} + +int GraphNode::addOutputName(std::string& name) +{ + outputNames.push_back(name); + return 0; +} + +int GraphNode::addInputTensor(Tensor* tens) +{ + ASSERT_MSG(tens, "GraphNode::addInputTensor: no tensor provided"); + inputs.push_back(tens); + return 0; +} + +int GraphNode::addOutputTensor(Tensor* tens) +{ + ASSERT_MSG(tens, "GraphNode::addOutputTensor: no tensor provided"); + outputs.push_back(tens); + return 0; +} + +int GraphNode::checkTensorAttributes() +{ + // Placeholder + return 0; +} + +int GraphNode::eval() +{ + // Placeholder evaluation function + evalCount++; + + // this should be set by derived op + for (auto ct : getOutputs()) + { + ct->setIsValid(); + } + + return 0; +} + +int GraphNode::hasAllInputsReady() const +{ + for (size_t i = 0; i < inputs.size(); i++) + { + if (!inputs[i]->getIsValid()) + return false; + } + + return true; +} + +int GraphNode::hasAllOutputsReady() const +{ + for (size_t i = 0; i < outputs.size(); i++) + { + if (!outputs[i]->getIsValid()) + return false; + } + + return true; +} + +int GraphNode::dumpNode(FILE* out) +{ + int i; + fprintf(out, "Node type: %s ID: %lu Eval Count: %d On next node list: %d Is marked: %d\n", EnumNamesOp()[nodeType], + nodeId, evalCount, onNextNodeList, isMarked); + + i = 0; + for (Tensor* ins : inputs) + { + fprintf(out, " Input[%d] ", i++); + ins->dumpTensorParams(out); + } + + i = 0; + for (Tensor* outs : outputs) + { + fprintf(out, " Output[%d] ", i++); + outs->dumpTensorParams(out); + } + + return 0; +} + +int GraphNode::dumpNode(std::ostream& out) +{ + int i; + + out << "Node type: " << EnumNamesOp()[nodeType] << " ID: " << nodeId << " Eval count: " << evalCount + << " On next node list: " << onNextNodeList << " Is marked: " << isMarked << std::endl; + + out << " Inputs:"; + for (std::string& name : inputNames) + { + out << " " << name; + } + out << std::endl; + + i = 0; + for (Tensor* ins : inputs) + { + out << " Input[" << i++ << "]: "; + ins->dumpTensorParams(out); + } + + out << " Outputs:"; + for (std::string& name : outputNames) + { + out << " " << name; + } + out << std::endl; + + i = 0; + for (Tensor* outs : outputs) + { + out << " Output[" << i++ << "]: "; + outs->dumpTensorParams(out); + } + return 0; +} + +int GraphNode::printNodeValidationError(const std::string& msg) +{ + std::cout << "Operator validation error: " << msg << std::endl; + ; + dumpNode(std::cout); + + return 0; +} + +int GraphNode::validateRequiredOperands() +{ + if (requiredInputCount >= 0 && inputs.size() != (size_t)requiredInputCount) + { + printNodeValidationError(std::string(EnumNamesOp()[nodeType]) + " operator must have " + + std::to_string(requiredInputCount) + " input(s)"); + return 1; + } + + if (requiredOutputCount >= 0 && outputs.size() != (size_t)requiredOutputCount) + { + printNodeValidationError(std::string(EnumNamesOp()[nodeType]) + " operator output must have exactly " + + std::to_string(requiredOutputCount) + " output(s)"); + return 1; + } + + return 0; +} + +int GraphNode::validateRequiredRank(const Tensor* t) +{ + if (requiredRankMin >= 0 && requiredRankMax >= 0) + { + if (t->checkRequiredRank(requiredRankMin, requiredRankMax)) + { + printNodeValidationError(std::string(EnumNamesOp()[nodeType]) + + " operand has illegal rank=" + std::to_string(t->getRank()) + " not in range [" + + std::to_string(requiredRankMin) + "," + std::to_string(requiredRankMax) + + "]. tensorName: " + t->getName()); + return 1; + } + else + { + return 0; + } + } + + if (requiredRankMin >= 0) + { + if (t->checkRequiredRank(requiredRankMin)) + { + printNodeValidationError(std::string(EnumNamesOp()[nodeType]) + + " operand has illegal rank=" + std::to_string(t->getRank()) + " not equal to " + + std::to_string(requiredRankMin) + ". tensorName: " + t->getName()); + return 1; + } + } + + return 0; +} diff --git a/reference_model/src/graph_node.h b/reference_model/src/graph_node.h new file mode 100644 index 0000000..5b4a767 --- /dev/null +++ b/reference_model/src/graph_node.h @@ -0,0 +1,354 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef GRAPH_NODE_H +#define GRAPH_NODE_H + +#include "attribute.h" +#include "quant_info.h" +#include "tensor.h" +#include "tosa_generated.h" +#include <iostream> + +#define DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, RANK, DTYPE) template class TosaReference::OP<RANK, DType_##DTYPE>; + +#define DEF_INSTANTIATE_ONE_RANK_TWO_TYPE(OP, RANK, DTYPE1, DTYPE2) \ + template class TosaReference::OP<RANK, DType_##DTYPE1, DType_##DTYPE2>; + +#define DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, RANK1, RANK2, DTYPE) \ + template class TosaReference::OP<RANK1, RANK2, DType_##DTYPE>; + +#define DEF_INSTANTIATE_TWO_RANK_TWO_TYPE(OP, RANK1, RANK2, DTYPE1, DTYPE2) \ + template class TosaReference::OP<RANK1, RANK2, DType_##DTYPE1, DType_##DTYPE2>; + +#define DEF_INSTANTIATE_ONE_RANK_0_6(OP) \ + template class TosaReference::OP<0>; \ + template class TosaReference::OP<1>; \ + template class TosaReference::OP<2>; \ + template class TosaReference::OP<3>; \ + template class TosaReference::OP<4>; \ + template class TosaReference::OP<5>; \ + template class TosaReference::OP<6>; + +#define DEF_INSTANTIATE_ONE_TYPE(OP, DTYPE) template class TosaReference::OP<DType_##DTYPE>; + +#define DEF_INSTANTIATE_TWO_TYPE(OP, DTYPE1, DTYPE2) template class TosaReference::OP<DType_##DTYPE1, DType_##DTYPE2>; + +#define DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OP, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 0, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 1, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 2, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 3, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 4, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 5, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 6, DTYPE) + +#define DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OP, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 1, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 2, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 3, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 4, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 5, DTYPE) \ + DEF_INSTANTIATE_ONE_RANK_ONE_TYPE(OP, 6, DTYPE) + +#define DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OP, DTYPE1, DTYPE2) \ + DEF_INSTANTIATE_ONE_RANK_TWO_TYPE(OP, 0, DTYPE1, DTYPE2) \ + DEF_INSTANTIATE_ONE_RANK_TWO_TYPE(OP, 1, DTYPE1, DTYPE2) \ + DEF_INSTANTIATE_ONE_RANK_TWO_TYPE(OP, 2, DTYPE1, DTYPE2) \ + DEF_INSTANTIATE_ONE_RANK_TWO_TYPE(OP, 3, DTYPE1, DTYPE2) \ + DEF_INSTANTIATE_ONE_RANK_TWO_TYPE(OP, 4, DTYPE1, DTYPE2) \ + DEF_INSTANTIATE_ONE_RANK_TWO_TYPE(OP, 5, DTYPE1, DTYPE2) \ + DEF_INSTANTIATE_ONE_RANK_TWO_TYPE(OP, 6, DTYPE1, DTYPE2) + +#define DEF_INSTANTIATE_RESHAPE(OP, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 0, 0, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 0, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 0, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 0, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 0, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 0, 5, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 0, 6, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 0, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 5, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 6, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 0, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 5, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 6, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 0, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 5, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 6, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 0, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 5, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 6, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 5, 0, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 5, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 5, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 5, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 5, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 5, 5, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 5, 6, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 6, 0, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 6, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 6, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 6, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 6, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 6, 5, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 6, 6, DTYPE) + +#define DEF_INSTANTIATE_GATHER(OP, DTYPE) \ + /* gather op takes input and index rank as template argument */ \ + /* note output rank = input rank - 1 + index rank */ \ + /* and max rank allowed in tosa_reference is 6 */ \ + /* so only specific input and index pair is instantiated */ \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 5, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 1, 6, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 2, 5, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 3, 4, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 4, 3, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 5, 1, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 5, 2, DTYPE) \ + DEF_INSTANTIATE_TWO_RANK_ONE_TYPE(OP, 6, 1, DTYPE) + +#define INIT_ATTRIBUTE(ATTRIBUTE_NAME) \ + if (auto p = dynamic_cast<Tosa##ATTRIBUTE_NAME##Attribute*>(attribute_)) \ + { \ + attribute = new Tosa##ATTRIBUTE_NAME##Attribute(p); \ + ASSERT_MEM(attribute); \ + } \ + else \ + { \ + FATAL_ERROR("Can't initialize Tosa" #ATTRIBUTE_NAME "Attribute"); \ + } + +#define INIT_QINFO(QINFO_NAME) \ + if (auto p = dynamic_cast<Tosa##QINFO_NAME##QuantInfo*>(qinfo_)) \ + { \ + qinfo = new Tosa##QINFO_NAME##QuantInfo(p); \ + ASSERT_MEM(qinfo); \ + } \ + else \ + { \ + qinfo = nullptr; \ + } + +namespace TosaReference +{ + +// Nodes in the graph (e.g., tosa operators) are defined with this base +// class. +class GraphNode +{ +public: + GraphNode(const tosa::Op& nodeType, const uint64_t id_); + virtual ~GraphNode(); + + int addInputName(std::string& name); + int addOutputName(std::string& name); + + int addInputTensor(Tensor* tens); + int addOutputTensor(Tensor* tens); + + // Validate that the input tensors match properly + // in their types, attributes, rank, etc well enough to be + // processed. + // + // This function should be pure virtual (eventually) in order to force + // derivative operators to implement the check, but we'll initially + // provide a default function so that GraphNode can be instantiated + // directly for testing purposes. + virtual int checkTensorAttributes(); + + // Evalute the node/operator + virtual int eval(); + + int hasAllInputsReady() const; + int hasAllOutputsReady() const; + + int dumpNode(FILE* out); + int dumpNode(std::ostream& out); + + int setNodeMarked() + { + isMarked = true; + return 0; + } + + int getNodeMarked() const + { + return isMarked; + } + + int clearNodeMarked() + { + isMarked = false; + return 0; + } + + int getEvalCount() const + { + return evalCount; + } + + uint64_t getID() const + { + return nodeId; + } + + std::vector<std::string>& getInputNames() + { + return inputNames; + } + + std::vector<std::string>& getOutputNames() + { + return outputNames; + } + + std::vector<Tensor*>& getOutputs() + { + return outputs; + } + + std::vector<Tensor*>& getInputs() + { + return inputs; + } + + int getOnNextNodeList() const + { + return onNextNodeList; + } + + int setOnNextNodeList() + { + onNextNodeList = true; + return 0; + } + + int clearOnNextNodeList() + { + onNextNodeList = false; + return 0; + } + + tosa::Op getOp() const + { + return nodeType; + } + +protected: + // Print out a node validation error + int printNodeValidationError(const std::string& msg); + + int setRequiredOperands(const int in, const int out) + { + requiredInputCount = in; + requiredOutputCount = out; + return 0; + } + + int setRequiredRank(const int min, const int max = -1) + { + if (max == -1) + { + requiredRankMin = requiredRankMax = min; + } + else + { + requiredRankMin = min; + requiredRankMax = max; + } + + ASSERT_MSG(requiredRankMin <= requiredRankMax, + "GraphNode::setRequiredRank: requiredRankMin %d must be <= requiredRankMax %d", requiredRankMin, + requiredRankMax); + + return 0; + } + + int validateRequiredOperands(); + int validateRequiredRank(const Tensor* t); + + // Description of the node type (e.g., CONST, CONV2D, etc...) + tosa::Op nodeType; + + // A list of input tensor names + std::vector<std::string> inputNames; + + // A list of the output tensor names + std::vector<std::string> outputNames; + + // A list of the input tensors (after names have been matched up) + std::vector<Tensor*> inputs; + + // A list of the output tensors (after names have been matched up) + std::vector<Tensor*> outputs; + + // Unique node ID for debugging + uint64_t nodeId; + + // Flag used for graph analysis + int isMarked; + + // Number of times eval() has been called for this node + int evalCount; + + // Flag indicating that this node is ready and is on the + // next-node list. + int onNextNodeList; + + // Required input/output tensor counts for node validation + // -1 means any number is allowed + int requiredInputCount; + int requiredOutputCount; + + // Required rank ranges for input/output tensors + // -1 means n/a + int requiredRankMin; + int requiredRankMax; +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/main.cpp b/reference_model/src/main.cpp new file mode 100644 index 0000000..ec2fdc9 --- /dev/null +++ b/reference_model/src/main.cpp @@ -0,0 +1,295 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include <stdio.h> + +#include "flatbuffers/idl.h" +#include "flatbuffers/util.h" +#include "model_common.h" +#include "ops/op_factory.h" +#include "subgraph_traverser.h" +#include "tosa_serialization_handler.h" +#include <Eigen/CXX11/Tensor> +#include <iostream> + +using namespace TosaReference; +using namespace tosa; + +// Global instantiation of configuration and debug objects +func_config_t g_func_config; +func_debug_t g_func_debug; + +int readInputTensors(SubgraphTraverser& gt); +int writeFinalTensors(SubgraphTraverser& gt); +int loadGraph(TosaSerializationHandler& tsh); + +int main(int argc, const char** argv) +{ + // Initialize configuration and debug subsystems + func_model_init_config(); + func_model_set_default_config(&g_func_config); + func_init_debug(&g_func_debug, 0); + TosaSerializationHandler tsh; + + if (func_model_parse_cmd_line(&g_func_config, &g_func_debug, argc, argv)) + { + return 1; + } + + if (loadGraph(tsh)) + { + SIMPLE_FATAL_ERROR("Unable to load graph"); + } + + // load json first since it's easier debugging + SubgraphTraverser main_gt(tsh.GetMainBlock(), &tsh); + + if (main_gt.initializeGraph()) + { + SIMPLE_FATAL_ERROR("Unable to initialize graph traverser: \"main\""); + } + + if (main_gt.linkTensorsAndNodes()) + { + SIMPLE_FATAL_ERROR("Failed to link tensors and nodes"); + } + + if (main_gt.validateGraph()) + { + SIMPLE_FATAL_ERROR("Failed to validate graph"); + } + + if (g_func_config.validate_only) + { + goto done; + } + + if (readInputTensors(main_gt)) + { + SIMPLE_FATAL_ERROR("Unable to read input tensors"); + } + + if (g_func_config.eval) + { + + if (main_gt.evaluateAll()) + { + SIMPLE_FATAL_ERROR("Error evaluating network. Giving up."); + } + + // make sure output tensor is evaluated and show its value + int num_output_tensors = main_gt.getNumOutputTensors(); + bool all_output_valid = true; + for (int i = 0; i < num_output_tensors; i++) + { + const Tensor* ct = main_gt.getOutputTensor(i); + ASSERT_MEM(ct); + if (!ct->getIsValid()) + { + ct->dumpTensorParams(g_func_debug.func_debug_file); + if (DEBUG_ENABLED(DEBUG_VERB_HIGH, GT)) + { + ct->dumpTensor(g_func_debug.func_debug_file); + } + all_output_valid = false; + } + } + if (!all_output_valid) + { + main_gt.dumpGraph(g_func_debug.func_debug_file); + SIMPLE_FATAL_ERROR( + "SubgraphTraverser \"main\" error: Output tensors are not all valid at the end of evaluation."); + } + + if (g_func_config.output_tensors) + { + if (writeFinalTensors(main_gt)) + { + WARNING("Errors encountered in saving output tensors"); + } + } + } + +done: + func_fini_debug(&g_func_debug); + func_model_config_cleanup(); + + return 0; +} + +int loadGraph(TosaSerializationHandler& tsh) +{ + char graph_fullname[1024]; + + snprintf(graph_fullname, sizeof(graph_fullname), "%s/%s", g_func_config.subgraph_dir, g_func_config.subgraph_file); + + if (strlen(graph_fullname) <= 2) + { + func_model_print_help(stderr); + SIMPLE_FATAL_ERROR("Missing required argument: Check -Csubgraph_file="); + } + + const char JSON_EXT[] = ".json"; + int is_json = 0; + { + // look for JSON file extension + size_t suffix_len = strlen(JSON_EXT); + size_t str_len = strlen(graph_fullname); + + if (str_len > suffix_len && strncasecmp(graph_fullname + (str_len - suffix_len), JSON_EXT, suffix_len) == 0) + { + is_json = 1; + } + } + + if (is_json) + { + if (tsh.LoadFileSchema(g_func_config.operator_fbs)) + { + SIMPLE_FATAL_ERROR( + "\nJSON file detected. Unable to load TOSA flatbuffer schema from: %s\nCheck -Coperator_fbs=", + g_func_config.operator_fbs); + } + + if (tsh.LoadFileJson(graph_fullname)) + { + SIMPLE_FATAL_ERROR("\nError loading JSON graph file: %s\nCheck -Csubgraph_file= and -Csubgraph_dir=", + graph_fullname); + } + } + else + { + if (tsh.LoadFileTosaFlatbuffer(graph_fullname)) + { + SIMPLE_FATAL_ERROR("\nError loading TOSA flatbuffer file: %s\nCheck -Csubgraph_file= and -Csubgraph_dir=", + graph_fullname); + } + } + + return 0; +} + +int readInputTensors(SubgraphTraverser& gt) +{ + int tensorCount = gt.getNumInputTensors(); + Tensor* tensor; + char filename[1024]; + + // assuming filename doesn't have colons(:) + std::map<std::string, std::string> input_tensor_map; + std::string raw_str(g_func_config.input_tensor); + std::string name, npy; + bool last_pair = false; + + std::string::size_type pair_start = 0, pair_end, colons_pos; + do + { + pair_end = raw_str.find(',', pair_start); + if (pair_end == std::string::npos) + last_pair = true; + + colons_pos = raw_str.find(':', pair_start); + + name = raw_str.substr(pair_start, colons_pos - pair_start); + npy = raw_str.substr(colons_pos + 1, pair_end - colons_pos - 1); + + // Empty strings can make it to here + if (name.length() == 0 || npy.length() == 0) + break; + + input_tensor_map[name] = npy; + + pair_start = pair_end + 1; // skip colons + } while (!last_pair); + + if ((size_t)tensorCount != input_tensor_map.size()) + { + WARNING("graph has %lu input placeholders, but %lu initialized", tensorCount, input_tensor_map.size()); + return 1; + } + + for (auto& tensor_pair : input_tensor_map) + { + tensor = gt.getInputTensorByName(tensor_pair.first); + if (!tensor) + { + WARNING("Unable to find input tensor %s", tensor_pair.first.c_str()); + return 1; + } + + snprintf(filename, sizeof(filename), "%s/%s", g_func_config.input_dir, tensor_pair.second.c_str()); + + DEBUG_MED(GT, "Loading input tensor %s from filename: %s", tensor->getName().c_str(), filename); + + if (tensor->allocate()) + { + WARNING("Fail to allocate tensor %s", tensor->getName().c_str()); + return 1; + } + + if (tensor->readFromNpyFile(filename)) + { + WARNING("Unable to read input tensor %s from filename: %s", tensor->getName().c_str(), filename); + tensor->dumpTensorParams(g_func_debug.func_debug_file); + return 1; + } + + // Push ready consumers to the next node list + for (auto gn : tensor->getConsumers()) + { + if (gn->hasAllInputsReady() && !gn->getOnNextNodeList()) + { + gt.addToNextNodeList(gn); + } + } + } + + if (DEBUG_ENABLED(DEBUG_VERB_HIGH, GT)) + { + gt.dumpNextNodeList(g_func_debug.func_debug_file); + } + + return 0; +} + +int writeFinalTensors(SubgraphTraverser& gt) +{ + int tensorCount = gt.getNumOutputTensors(); + const Tensor* tensor; + char filename[1024]; + + for (int i = 0; i < tensorCount; i++) + { + tensor = gt.getOutputTensor(i); + if (!tensor) + { + WARNING("Unable to find output tensor[%d]", i); + return 1; + } + + snprintf(filename, sizeof(filename), "%s/%s%s.npy", g_func_config.output_dir, + g_func_config.output_tensor_prefix, tensor->getName().c_str()); + + DEBUG_MED(GT, "Writing output tensor[%d] %s to filename: %s", i, tensor->getName().c_str(), filename); + + if (tensor->writeToNpyFile(filename)) + { + WARNING("Unable to write output tensor[%d] %s to filename: %s", i, tensor->getName().c_str(), filename); + return 1; + } + } + + return 0; +} diff --git a/reference_model/src/model_common.h b/reference_model/src/model_common.h new file mode 100644 index 0000000..d6dab6d --- /dev/null +++ b/reference_model/src/model_common.h @@ -0,0 +1,28 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef MODEL_COMMON_H +#define MODEL_COMMON_H + +#include <iostream> +#include <stdio.h> + +#include "func_config.h" +#include "func_debug.h" + +extern func_config_t g_func_config; +extern func_debug_t g_func_debug; + +#endif diff --git a/reference_model/src/ops/activation_funcs.cc b/reference_model/src/ops/activation_funcs.cc new file mode 100644 index 0000000..bca9507 --- /dev/null +++ b/reference_model/src/ops/activation_funcs.cc @@ -0,0 +1,118 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "activation_funcs.h" +#include "quant_util.h" +#include "template_types.h" +#include <cmath> + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int Rank, DType Dtype> +int OpClamp<Rank, Dtype>::register_fcn() +{ + + switch (Dtype) + { + case DType_FLOAT: + { + InEigenType min = (InEigenType)attribute->min_fp(); + InEigenType max = (InEigenType)attribute->max_fp(); + this->fcn = [min, max](InEigenType a) -> OutEigenType { return a <= min ? min : a >= max ? max : a; }; + } + break; + case DType_AINT8: + case DType_INT16: + { + InEigenType min = (InEigenType)attribute->min_int(); + InEigenType max = (InEigenType)attribute->max_int(); + this->fcn = [min, max](InEigenType a) -> OutEigenType { return a <= min ? min : a >= max ? max : a; }; + } + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpReluN<Rank, Dtype>::register_fcn() +{ + + switch (Dtype) + { + case DType_FLOAT: + { + InEigenType N = (InEigenType)attribute->max_fp(); + this->fcn = [N](InEigenType a) -> OutEigenType { return a >= 0 ? (a <= N ? a : N) : 0; }; + } + break; + case DType_INT32: + { + InEigenType N = (InEigenType)attribute->max_int(); + this->fcn = [N](InEigenType a) -> OutEigenType { return a >= 0 ? (a <= N ? a : N) : 0; }; + } + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpSigmoid<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a) -> OutEigenType { return (1.0 / (1.0 + (expf(-1.0 * a)))); }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpTanh<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a) -> OutEigenType { return tanhf(a); }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +// template explicit instantiation +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpClamp, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpClamp, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpClamp, INT16); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpReluN, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpReluN, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSigmoid, FLOAT); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTanh, FLOAT); diff --git a/reference_model/src/ops/activation_funcs.h b/reference_model/src/ops/activation_funcs.h new file mode 100644 index 0000000..b051b9d --- /dev/null +++ b/reference_model/src/ops/activation_funcs.h @@ -0,0 +1,101 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_ACTIVATION_FUNCS_H +#define OPS_ACTIVATION_FUNCS_H + +#include "ewise_unary.h" +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ + +template <int Rank, DType Dtype> +class OpClamp : public UnaryNode<Rank, Dtype> +{ +public: + OpClamp(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : UnaryNode<Rank, Dtype>(Op_CLAMP, id_) + { + INIT_ATTRIBUTE(Clamp); + register_fcn(); + } + static constexpr int32_t QMin = GetQMin<Dtype>::value; + static constexpr int32_t QMax = GetQMax<Dtype>::value; + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + virtual int register_fcn(); + +protected: + TosaClampAttribute* attribute; +}; + +template <int Rank, DType Dtype> +class OpReluN : public UnaryNode<Rank, Dtype> +{ +public: + OpReluN(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : UnaryNode<Rank, Dtype>(Op_RELUN, id_) + { + INIT_ATTRIBUTE(ReluN); + register_fcn(); + } + static constexpr int32_t QMin = GetQMin<Dtype>::value; + static constexpr int32_t QMax = GetQMax<Dtype>::value; + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + virtual int register_fcn(); + +protected: + TosaReluNAttribute* attribute; +}; + +template <int Rank, DType Dtype> +class OpSigmoid : public UnaryNode<Rank, Dtype> +{ +public: + OpSigmoid(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : UnaryNode<Rank, Dtype>(Op_SIGMOID, id_) + { + register_fcn(); + } + static constexpr int32_t QMin = GetQMin<Dtype>::value; + static constexpr int32_t QMax = GetQMax<Dtype>::value; + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + virtual int register_fcn(); +}; + +template <int Rank, DType Dtype> +class OpTanh : public UnaryNode<Rank, Dtype> +{ +public: + OpTanh(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : UnaryNode<Rank, Dtype>(Op_TANH, id_) + { + register_fcn(); + } + static constexpr int32_t QMin = GetQMin<Dtype>::value; + static constexpr int32_t QMax = GetQMax<Dtype>::value; + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + virtual int register_fcn(); +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/comparison.cc b/reference_model/src/ops/comparison.cc new file mode 100644 index 0000000..402e152 --- /dev/null +++ b/reference_model/src/ops/comparison.cc @@ -0,0 +1,81 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "comparison.h" +#include "arith_util.h" +#include "quant_util.h" +#include "template_types.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int Rank, DType Dtype> +int OpEqual<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a == b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpGreater<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a > b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpGreaterEqual<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a >= b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +// template explicit instantiation +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpEqual, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpEqual, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpGreater, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpGreater, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpGreaterEqual, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpGreaterEqual, INT32); diff --git a/reference_model/src/ops/comparison.h b/reference_model/src/ops/comparison.h new file mode 100644 index 0000000..e75b1a6 --- /dev/null +++ b/reference_model/src/ops/comparison.h @@ -0,0 +1,71 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_COMPARISON_H +#define OPS_COMPARISON_H + +#include "ewise_binary.h" +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ + +template <int Rank, DType Dtype> +class OpEqual : public BinaryNode<Rank, Dtype, DType_BOOL> +{ +public: + OpEqual(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : BinaryNode<Rank, Dtype, DType_BOOL>(Op_EQUAL, qinfo_, id_) + { + register_fcn(); + } + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<DType_BOOL>::type; + virtual int register_fcn(); +}; + +template <int Rank, DType Dtype> +class OpGreater : public BinaryNode<Rank, Dtype, DType_BOOL> +{ +public: + OpGreater(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : BinaryNode<Rank, Dtype, DType_BOOL>(Op_GREATER, qinfo_, id_) + { + register_fcn(); + } + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<DType_BOOL>::type; + virtual int register_fcn(); +}; + +template <int Rank, DType Dtype> +class OpGreaterEqual : public BinaryNode<Rank, Dtype, DType_BOOL> +{ +public: + OpGreaterEqual(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : BinaryNode<Rank, Dtype, DType_BOOL>(Op_EQUAL, qinfo_, id_) + { + register_fcn(); + } + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<DType_BOOL>::type; + virtual int register_fcn(); +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/control_flow.cc b/reference_model/src/ops/control_flow.cc new file mode 100644 index 0000000..9d5db40 --- /dev/null +++ b/reference_model/src/ops/control_flow.cc @@ -0,0 +1,353 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "control_flow.h" +#include "subgraph_traverser.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +OpControlFlow::OpControlFlow(TosaSerializationHandler* tsh_, Op op_, uint64_t id_) + : GraphNode(op_, id_) +{ + tsh = tsh_; +} + +OpControlFlow::~OpControlFlow() +{} + +int OpControlFlow::evalBlock(TosaSerializationBasicBlock* block, + std::vector<TosaReference::Tensor*>& block_inputs, + std::vector<TosaReference::Tensor*>& block_outputs) +{ + std::string block_name = block->GetName(); + + DEBUG_MED(OP, "Evaluating block %s", block_name.c_str()); + + SubgraphTraverser gt(block, tsh); + + if (gt.initializeGraph()) + { + FATAL_ERROR("Unable to initialize graph traverser for block %s", block_name.c_str()); + } + + if (gt.linkTensorsAndNodes()) + { + FATAL_ERROR("Failed to link tensors and nodes for block %s", block_name.c_str()); + } + + if (gt.validateGraph()) + { + FATAL_ERROR("Failed to validate subgraph for block %s", block_name.c_str()); + } + + int num_input_tensors = gt.getNumInputTensors(); + int num_output_tensors = gt.getNumOutputTensors(); + + for (size_t i = 0; i < block_inputs.size(); i++) + { + DEBUG_HIGH(OP, "Input[%ld]: %s", i, block_inputs[i]->getName().c_str()); + } + for (size_t i = 0; i < block_outputs.size(); i++) + { + DEBUG_HIGH(OP, "Output[%ld]: %s", i, block_outputs[i]->getName().c_str()); + } + + ASSERT_MSG((size_t)num_input_tensors == block_inputs.size(), + "op block %s inputs[%lu] does not match with graph traverser's inputs[%d]", block_name.c_str(), + block_inputs.size(), num_input_tensors); + ASSERT_MSG((size_t)num_output_tensors == block_outputs.size(), + "op block %s outputs[%lu] does not match with graph traverser's outputs[%d]", block_name.c_str(), + block_outputs.size(), num_output_tensors); + + // set graph traverser's input = basic block's input + for (int i = 0; i < num_input_tensors; i++) + { + TosaReference::Tensor* tensor = gt.getInputTensor(i); + ASSERT_MSG(!tensor->is_allocated(), "block %s input tensors are unexpectedly initialized before", + block_name.c_str()); + + if (tensor->allocate()) + { + WARNING("Fail to allocate tensor %s", tensor->getName().c_str()); + return 1; + } + + if (tensor->copyValueFrom(block_inputs[i])) + { + WARNING("Fail to copy tensor value %s -> %s", block_inputs[i]->getName().c_str(), + tensor->getName().c_str()); + return 1; + } + + // Push ready consumers to the next node list + for (auto gn : tensor->getConsumers()) + { + if (gn->hasAllInputsReady() && !gn->getOnNextNodeList()) + { + gt.addToNextNodeList(gn); + } + } + } + + if (gt.evaluateAll()) + { + FATAL_ERROR("Error evaluating network. Giving up."); + } + + // make sure output tensor is evaluated and show its value + bool all_output_valid = true; + for (int i = 0; i < num_output_tensors; i++) + { + const TosaReference::Tensor* ct = gt.getOutputTensor(i); + ASSERT_MEM(ct); + if (!ct->getIsValid()) + { + ct->dumpTensorParams(g_func_debug.func_debug_file); + if (DEBUG_ENABLED(DEBUG_VERB_HIGH, GT)) + { + ct->dumpTensor(g_func_debug.func_debug_file); + } + all_output_valid = false; + } + } + if (!all_output_valid) + { + gt.dumpGraph(g_func_debug.func_debug_file); + FATAL_ERROR("SubgraphTraverser \"%s\" error: Output tensors are not all valid at the end of evaluation.", + block_name.c_str()); + } + + // set basic block's output = subgraph_traverser's output + for (int i = 0; i < num_output_tensors; i++) + { + TosaReference::Tensor* tensor = gt.getOutputTensor(i); + ASSERT_MSG(tensor->is_allocated(), "tensor %s is not allocated", tensor->getName().c_str()); + + if (block_outputs[i]->copyValueFrom(tensor)) + { + WARNING("Fail to copy tensor value %s -> %s", tensor->getName().c_str(), outputs[i]->getName().c_str()); + return 1; + } + } + return 0; +} + +OpCondIf::OpCondIf(TosaSerializationHandler* tsh_, TosaAttributeBase* attribute_, uint64_t id_) + : OpControlFlow(tsh_, Op_COND_IF, id_) +{ + INIT_ATTRIBUTE(CondIf); +} + +OpCondIf::~OpCondIf() +{ + if (attribute) + delete attribute; +} + +int OpCondIf::checkTensorAttributes() +{ + if (getInputs().size() < 1) + { + WARNING("OpCondIf: must have at least 1 operand"); + return 1; + } + + if (inputs[0]->getDtype() != DType_BOOL || inputs[0]->getRank() != 0) + { + WARNING("OpCondIf: invalid tensor dtype=%s, rank=%d", EnumNamesDType()[inputs[0]->getDtype()], + inputs[0]->getRank()); + return 1; + } + + cond = dynamic_cast<TosaReference::Tensor0<bool>*>(inputs[0]); + ASSERT_MEM(cond); + + then_block = tsh->GetBlockByName(attribute->then_branch()); + else_block = tsh->GetBlockByName(attribute->else_branch()); + + if (!then_block) + { + WARNING("OpCondIf: fail to resolve then_branch %s", attribute->then_branch().c_str()); + return 1; + } + + if (!else_block) + { + WARNING("OpCondIf: fail to resolve else_branch %s", attribute->else_branch().c_str()); + return 1; + } + + return 0; +} + +int OpCondIf::eval() +{ + bool cond_val = cond->getTensor()(0); + std::vector<TosaReference::Tensor*> block_inputs(getInputs().begin() + 1, getInputs().end()); + + if (cond_val) + { + if (evalBlock(then_block, block_inputs, getOutputs())) + { + WARNING("OpCondIf: Fail to evaluate then branch block %s", attribute->then_branch().c_str()); + return 1; + } + } + else + { + if (evalBlock(else_block, block_inputs, getOutputs())) + { + WARNING("OpCondIf: Fail to evaluate else branch block %s", attribute->else_branch().c_str()); + return 1; + } + } + + return GraphNode::eval(); +} + +OpWhileLoop::OpWhileLoop(TosaSerializationHandler* tsh_, TosaAttributeBase* attribute_, uint64_t id_) + : OpControlFlow(tsh_, Op_WHILE_LOOP, id_) +{ + INIT_ATTRIBUTE(WhileLoop); +} + +OpWhileLoop::~OpWhileLoop() +{ + if (attribute) + delete attribute; +} + +int OpWhileLoop::checkTensorAttributes() +{ + if (getInputs().size() <= 0) + { + WARNING("OpWhileLoop: must have at least 1 operands"); + return 1; + } + + if (getInputs().size() != getOutputs().size()) + { + WARNING("OpWhileLoop: inputs and outputs size must match"); + return 1; + } + + cond_block = tsh->GetBlockByName(attribute->cond_branch()); + body_block = tsh->GetBlockByName(attribute->body_branch()); + + if (!cond_block) + { + WARNING("OpWhileLoop: fail to resolve cond_branch %s", attribute->cond_branch().c_str()); + return 1; + } + + if (!body_block) + { + WARNING("OpWhileLoop: fail to resolve body_branch %s", attribute->body_branch().c_str()); + return 1; + } + + if (cond_block->GetOutputs().size() != 1) + { + WARNING("OpWhileLoop: invalid cond_block output size %lu", cond_block->GetOutputs().size()); + return 1; + } + + TosaSerializationTensor* cond_output_tensor = cond_block->GetTensorByName(cond_block->GetOutputs()[0]); + + if (!cond_output_tensor) + { + WARNING("OpWhileLoop: fail to resolve cond_block's output tensor %s", cond_block->GetOutputs()[0].c_str()); + return 1; + } + + if (cond_output_tensor->GetDtype() != DType_BOOL) + { + WARNING("OpWhileLoop: invalid cond_block's output tensor data type %s", + EnumNamesDType()[cond_output_tensor->GetDtype()]); + return 1; + } + if (cond_output_tensor->GetShape().size() != 0) + { + WARNING("OpWhileLoop: invalid cond_block's output rank %lu", cond_output_tensor->GetShape().size()); + return 1; + } + + return 0; +} + +int OpWhileLoop::eval() +{ + + TosaReference::Tensor0<bool> cond_output_ctensor( + std::string("cond_output"), DType_BOOL, std::vector<Usage>({ Usage_ACTIVATION }), + std::vector<Format>({ Format_UNKNOWN }), std::vector<int32_t>({}), false); + + cond_output_ctensor.allocate(); + std::vector<TosaReference::Tensor*> cond_block_outputs; + cond_block_outputs.push_back(&cond_output_ctensor); + + size_t num_input_output = getInputs().size(); + size_t eval_count = 0; + + while (eval_count++ < MAX_WHILE_LOOP_ITERATION) + { + if (evalBlock(cond_block, getInputs(), cond_block_outputs)) + { + WARNING("OpWhileLoop: Fail to evaluate cond block %s", attribute->cond_branch().c_str()); + return 1; + } + bool cond_val = cond_output_ctensor.getTensor()(0); + DEBUG_HIGH(OP, "Conditional block value: %d", cond_val); + + if (cond_val) + { + if (evalBlock(body_block, getInputs(), getOutputs())) + { + WARNING("OpWhileLoop: Fail to evaluate body block %s", attribute->body_branch().c_str()); + return 1; + } + + // assigning output tensors value back to input tensors value for next iteration + for (size_t i = 0; i < num_input_output; i++) + { + if (getInputs()[i]->copyValueFrom(getOutputs()[i])) + { + WARNING("Fail to copy tensor value %s -> %s", getOutputs()[i]->getName().c_str(), + getInputs()[i]->getName().c_str()); + return 1; + } + } + } + else + { + // in last iteration or the case it never evaluates body block + // assign input tensors value to output tensors + for (size_t i = 0; i < num_input_output; i++) + { + if (getOutputs()[i]->copyValueFrom(getInputs()[i])) + { + WARNING("Fail to copy tensor value %s -> %s", getInputs()[i]->getName().c_str(), + getOutputs()[i]->getName().c_str()); + return 1; + } + } + break; + } + } + + return GraphNode::eval(); +} diff --git a/reference_model/src/ops/control_flow.h b/reference_model/src/ops/control_flow.h new file mode 100644 index 0000000..14c11bc --- /dev/null +++ b/reference_model/src/ops/control_flow.h @@ -0,0 +1,72 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_CONTROL_FLOW_H +#define OPS_CONTROL_FLOW_H + +#include "graph_node.h" + +#define MAX_WHILE_LOOP_ITERATION 10000 + +namespace TosaReference +{ +class OpControlFlow : public GraphNode +{ +public: + OpControlFlow(TosaSerializationHandler* tsh_, Op op_, uint64_t id_); + ~OpControlFlow(); + + virtual int evalBlock(TosaSerializationBasicBlock* block, + std::vector<TosaReference::Tensor*>& block_inputs, + std::vector<TosaReference::Tensor*>& block_outputs); + +protected: + TosaSerializationHandler* tsh; +}; + +class OpCondIf : public OpControlFlow +{ +public: + OpCondIf(TosaSerializationHandler* tsh_, TosaAttributeBase* attribute_, uint64_t id_); + virtual ~OpCondIf(); + + virtual int checkTensorAttributes(); + virtual int eval(); + +protected: + TosaCondIfAttribute* attribute; + TosaReference::Tensor0<bool>* cond; + TosaSerializationBasicBlock* then_block; + TosaSerializationBasicBlock* else_block; +}; + +class OpWhileLoop : public OpControlFlow +{ +public: + OpWhileLoop(TosaSerializationHandler* tsh_, TosaAttributeBase* attribute_, uint64_t id_); + virtual ~OpWhileLoop(); + + virtual int checkTensorAttributes(); + virtual int eval(); + +protected: + TosaWhileLoopAttribute* attribute; + TosaSerializationBasicBlock* cond_block; + TosaSerializationBasicBlock* body_block; +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/custom.cc b/reference_model/src/ops/custom.cc new file mode 100644 index 0000000..5c4f29b --- /dev/null +++ b/reference_model/src/ops/custom.cc @@ -0,0 +1,40 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "custom.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +OpCustom::OpCustom(uint64_t id_) + : GraphNode(Op_CUSTOM, id_) +{} + +OpCustom::~OpCustom() +{} + +int OpCustom::checkTensorAttributes() +{ + return 0; +} + +int OpCustom::eval() +{ + FATAL_ERROR_NODE("not supported yet"); + + // Evaluation is trivial for constants + return GraphNode::eval(); +} diff --git a/reference_model/src/ops/custom.h b/reference_model/src/ops/custom.h new file mode 100644 index 0000000..b1085a5 --- /dev/null +++ b/reference_model/src/ops/custom.h @@ -0,0 +1,38 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_CUSTOM_H +#define OPS_CUSTOM_H + +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ + +class OpCustom : public GraphNode +{ +public: + OpCustom(uint64_t id_); + virtual ~OpCustom(); + + virtual int checkTensorAttributes(); + virtual int eval(); +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/data_layout.cc b/reference_model/src/ops/data_layout.cc new file mode 100644 index 0000000..32029b9 --- /dev/null +++ b/reference_model/src/ops/data_layout.cc @@ -0,0 +1,644 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "data_layout.h" +#include "quant_util.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int Rank, DType Dtype> +OpConcat<Rank, Dtype>::OpConcat(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_CONCAT, id_) +{ + setRequiredOperands(2, 1); + setRequiredRank(1, 6); + + INIT_ATTRIBUTE(Axis); +} + +template <int Rank, DType Dtype> +OpConcat<Rank, Dtype>::~OpConcat() +{ + if (attribute) + delete attribute; +} + +template <int Rank, DType Dtype> +int OpConcat<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same types and rank + // inputs[0] and inputs[1] should also match type and rank + if (inputs[0]->matchRankType(*outputs[0]) || inputs[1]->matchRankType(*outputs[0])) + { + printNodeValidationError("Concat operator input ranks and types must match"); + return 1; + } + + lhs = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + rhs = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[1]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + if (attribute->axis() < 0 || (size_t)attribute->axis() >= rhs->getShape().size()) + { + printNodeValidationError("Axis is beyond input tensor rank"); + return 1; + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpConcat<Rank, Dtype>::eval() +{ + + int32_t reversed_axis = Rank - 1 - attribute->axis(); + + for (int32_t d = 0; d < Rank; d++) + { + reverser[d] = Rank - 1 - d; + } + + TIn lhs_reversed = lhs->getTensor().shuffle(reverser); + TIn rhs_reversed = rhs->getTensor().shuffle(reverser); + + TIn reversed_result = lhs_reversed.concatenate(rhs_reversed, reversed_axis); + out->getTensor() = reversed_result.shuffle(reverser); + // out->getTensor() = lhs->getTensor().concatenate(rhs->getTensor(), axis); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +OpPad<Rank, Dtype>::OpPad(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_PAD, id_) +{ + setRequiredOperands(2, 1); + setRequiredRank(0, 6); + + INIT_QINFO(Pad); +} + +template <int Rank, DType Dtype> +OpPad<Rank, Dtype>::~OpPad() +{ + if (qinfo) + delete qinfo; +} + +template <int Rank, DType Dtype> +int OpPad<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same types + if (inputs[0]->matchRankType(*outputs[0])) + { + printNodeValidationError("Failure to match input and output type and rank"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + TosaReference::TensorTemplate<ETensor2<int32_t>>* paddings = + dynamic_cast<TosaReference::TensorTemplate<ETensor2<int32_t>>*>(inputs[1]); + + for (int i = 0; i < Rank; i++) + { + paddings_array[i] = std::make_pair(paddings->getTensor()(i, 0), paddings->getTensor()(i, 1)); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpPad<Rank, Dtype>::eval() +{ + InEigenType pad_value = 0; + if (this->qinfo) + { + pad_value = (InEigenType)this->qinfo->input_zp(); + } + + this->out->getTensor() = this->in->getTensor().pad(this->paddings_array, pad_value); + + return GraphNode::eval(); +} + +template <int InRank, int OutRank, DType Dtype> +OpReshape<InRank, OutRank, Dtype>::OpReshape(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_RESHAPE, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(0, 6); + + INIT_ATTRIBUTE(Reshape); +} + +template <int InRank, int OutRank, DType Dtype> +OpReshape<InRank, OutRank, Dtype>::~OpReshape() +{ + if (attribute) + delete attribute; +} + +template <int InRank, int OutRank, DType Dtype> +int OpReshape<InRank, OutRank, Dtype>::checkTensorAttributes() +{ + uint32_t minusOneCount = 0; + + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same types + if (inputs[0]->matchType(*outputs[0])) + { + printNodeValidationError("OpReshape: Input and output types must match"); + return 1; + } + + for (uint32_t d = 0; d < OutRank; d++) + { + if (attribute->shape()[d] == -1) + { + minusOneCount++; + } + } + + if (minusOneCount > 1) + { + printNodeValidationError("OpReshape: new shape has more than one -1 dimension"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + return 0; +} + +template <int InRank, int OutRank, DType Dtype> +int OpReshape<InRank, OutRank, Dtype>::eval() +{ + uint32_t remainingSize = in->getElementCount(); + + // If there is a -1 dimension, find the remainder in one pass over the output shape + for (int32_t d = 0; d < OutRank; d++) + { + if (attribute->shape()[d] != -1) + { + remainingSize = remainingSize / attribute->shape()[d]; + } + } + + for (int32_t d = 0; d < OutRank; d++) + { + array_shape[d] = attribute->shape()[OutRank - 1 - d]; + out_reverser[d] = OutRank - 1 - d; + + // Jam in the remainder here + if (array_shape[d] == -1) + { + array_shape[d] = remainingSize; + } + } + + for (int32_t d = 0; d < InRank; d++) + { + in_reverser[d] = InRank - 1 - d; + } + + // Eigen Tensor is col-major, and we're referencing row-major result + // need to reverse it to row-major before reshape, and perform another reverse afterward + + // input tensor rank 0 can't do .shuffle(), need to be handled otherwise + TIn in_reversed; + if (InRank > 1) + { + in_reversed = in->getTensor().shuffle(in_reverser); + } + else + { + in_reversed = in->getTensor(); + } + + TOut in_reshaped = in_reversed.reshape(array_shape); + + // output tensor can be rank 0, .reshape() and .shuffle() don't work, need to be handled otherwise + if (OutRank > 1) + { + out->getTensor() = in_reshaped.shuffle(out_reverser); + } + else + { + out->getTensor() = in_reshaped; + } + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +OpReverse<Rank, Dtype>::OpReverse(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_REVERSE, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(1, 6); + + INIT_ATTRIBUTE(Axis); +} + +template <int Rank, DType Dtype> +OpReverse<Rank, Dtype>::~OpReverse() +{ + if (attribute) + delete attribute; +} + +template <int Rank, DType Dtype> +int OpReverse<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same types + if (inputs[0]->matchRankTypeShape(*outputs[0])) + { + printNodeValidationError("Failure to match input and output rank/type/shape"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + ASSERT_MEM(in && out); + + if (attribute->axis() < 0 || attribute->axis() >= inputs[0]->getRank()) + { + printNodeValidationError("Reverse axis must between [0, input_rank - 1]"); + return 1; + } + + // transform list of axis into true or false list + // e.g. rank=4, axis=[1,2], reverse array would be [false, true, true, false] + for (int i = 0; i < Rank; i++) + { + reverse_array[i] = false; + } + reverse_array[attribute->axis()] = true; + + return 0; +} + +template <int Rank, DType Dtype> +int OpReverse<Rank, Dtype>::eval() +{ + out->getTensor() = in->getTensor().reverse(reverse_array); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +OpSlice<Rank, Dtype>::OpSlice(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_SLICE, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(0, 6); + + INIT_ATTRIBUTE(Slice); +} + +template <int Rank, DType Dtype> +OpSlice<Rank, Dtype>::~OpSlice() +{ + if (attribute) + delete attribute; +} + +template <int Rank, DType Dtype> +int OpSlice<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same types + if (inputs[0]->matchType(*outputs[0])) + { + printNodeValidationError("Failure to match input and output type"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + for (size_t i = 0; i < attribute->begin().size(); i++) + { + begin_array[i] = attribute->begin()[i]; + } + + for (size_t i = 0; i < attribute->size().size(); i++) + { + if (attribute->size()[i] != 0) + { + size_array[i] = attribute->size()[i]; + } + else + { + // Tensorflow assigns a zero size to dimensions that are kept + // Eigen expects size to be the full size of the dimension + size_array[i] = in->getTensor().dimension(0); + } + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpSlice<Rank, Dtype>::eval() +{ + out->getTensor() = in->getTensor().slice(begin_array, size_array); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +OpTileBase<Rank, Dtype>::OpTileBase(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_TILE, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(0, 6); + + INIT_ATTRIBUTE(Tile); +} + +template <int Rank, DType Dtype> +OpTileBase<Rank, Dtype>::~OpTileBase() +{ + if (attribute) + delete attribute; +} + +template <int Rank, DType Dtype> +int OpTileBase<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same ranks and types + if (inputs[0]->matchRankType(*outputs[0])) + { + printNodeValidationError("Failure to match input and output rank or type"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + if (attribute->multiples().size() != Rank) + { + printNodeValidationError("1D list 'multiples' must have size equal to input rank"); + return 1; + } + + for (int32_t d = 0; d < Rank; d++) + { + if (in->getShape()[d] * attribute->multiples()[d] != out->getShape()[d]) + { + printNodeValidationError("unexpected output shape"); + return 1; + } + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpTile<Rank, Dtype>::eval() +{ + // primary template shouldn't be called + FATAL_ERROR_NODE("OpTile rank=%i, dtype=%s: not implemented yet", Rank, EnumNamesDType()[Dtype]); +} + +template <DType Dtype> +int OpTile<1, Dtype>::eval() +{ + for (int32_t od0 = 0; od0 < this->out->getShape()[0]; od0++) + { + int32_t id0 = od0 % this->in->getShape()[0]; + this->out->getTensor()(od0) = this->in->getTensor()(id0); + } + + return GraphNode::eval(); +} + +template <DType Dtype> +int OpTile<2, Dtype>::eval() +{ + for (int32_t od0 = 0; od0 < this->out->getShape()[0]; od0++) + { + int32_t id0 = od0 % this->in->getShape()[0]; + for (int32_t od1 = 0; od1 < this->out->getShape()[1]; od1++) + { + int32_t id1 = od1 % this->in->getShape()[1]; + this->out->getTensor()(od0, od1) = this->in->getTensor()(id0, id1); + } + } + + return GraphNode::eval(); +} + +template <DType Dtype> +int OpTile<3, Dtype>::eval() +{ + for (int32_t od0 = 0; od0 < this->out->getShape()[0]; od0++) + { + int32_t id0 = od0 % this->in->getShape()[0]; + for (int32_t od1 = 0; od1 < this->out->getShape()[1]; od1++) + { + int32_t id1 = od1 % this->in->getShape()[1]; + for (int32_t od2 = 0; od2 < this->out->getShape()[2]; od2++) + { + int32_t id2 = od2 % this->in->getShape()[2]; + this->out->getTensor()(od0, od1, od2) = this->in->getTensor()(id0, id1, id2); + } + } + } + + return GraphNode::eval(); +} + +template <DType Dtype> +int OpTile<4, Dtype>::eval() +{ + for (int32_t od0 = 0; od0 < this->out->getShape()[0]; od0++) + { + int32_t id0 = od0 % this->in->getShape()[0]; + for (int32_t od1 = 0; od1 < this->out->getShape()[1]; od1++) + { + int32_t id1 = od1 % this->in->getShape()[1]; + for (int32_t od2 = 0; od2 < this->out->getShape()[2]; od2++) + { + int32_t id2 = od2 % this->in->getShape()[2]; + for (int32_t od3 = 0; od3 < this->out->getShape()[3]; od3++) + { + int32_t id3 = od3 % this->in->getShape()[3]; + this->out->getTensor()(od0, od1, od2, od3) = this->in->getTensor()(id0, id1, id2, id3); + } + } + } + } + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +OpTranspose<Rank, Dtype>::OpTranspose(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_TRANSPOSE, id_) +{ + setRequiredOperands(2, 1); + setRequiredRank(0, 6); +} + +template <int Rank, DType Dtype> +OpTranspose<Rank, Dtype>::~OpTranspose() +{} + +template <int Rank, DType Dtype> +int OpTranspose<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same types + if (inputs[0]->matchRankType(*outputs[0])) + { + printNodeValidationError("Failure to match input and output rank and type"); + return 1; + } + + if (inputs[0]->getElementCount() != outputs[0]->getElementCount()) + { + printNodeValidationError("Failure to match input and output total element count"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + perm_tensor = dynamic_cast<TosaReference::TensorTemplate<ETensor1<int32_t>>*>(inputs[1]); + + return 0; +} + +template <int Rank, DType Dtype> +int OpTranspose<Rank, Dtype>::eval() +{ + for (int32_t d = 0; d < Rank; d++) + { + perm_array[d] = this->perm_tensor->getTensor().data()[d]; + } + + out->getTensor() = in->getTensor().shuffle(perm_array); + + return GraphNode::eval(); +} + +// template explicit instantiation +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, FLOAT) +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, AINT8) +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, INT8) +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, INT16) +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, INT32) +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, BOOL) + +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, FLOAT); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, AINT8); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, INT8); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, INT16); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, INT32); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, BOOL); + +DEF_INSTANTIATE_RESHAPE(OpReshape, FLOAT); +DEF_INSTANTIATE_RESHAPE(OpReshape, AINT8); +DEF_INSTANTIATE_RESHAPE(OpReshape, INT8); +DEF_INSTANTIATE_RESHAPE(OpReshape, INT16); +DEF_INSTANTIATE_RESHAPE(OpReshape, INT32); +DEF_INSTANTIATE_RESHAPE(OpReshape, BOOL); + +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, FLOAT); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, AINT8); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, INT8); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, INT16); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, INT32); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, BOOL); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, BOOL); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, BOOL); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, BOOL); diff --git a/reference_model/src/ops/data_layout.h b/reference_model/src/ops/data_layout.h new file mode 100644 index 0000000..100bd6b --- /dev/null +++ b/reference_model/src/ops/data_layout.h @@ -0,0 +1,216 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_DATA_LAYOUT_H +#define OPS_DATA_LAYOUT_H + +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ + +template <int Rank, DType Dtype> +class OpConcat : public GraphNode +{ +public: + OpConcat(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpConcat(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + Eigen::array<int, Rank> reverser; + TosaReference::TensorTemplate<TIn>* lhs; + TosaReference::TensorTemplate<TIn>* rhs; + TosaAxisAttribute* attribute; + TosaReference::TensorTemplate<TOut>* out; +}; + +template <int Rank, DType Dtype> +class OpPad : public GraphNode +{ +public: + OpPad(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpPad(); + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + Eigen::array<std::pair<ptrdiff_t, ptrdiff_t>, Rank> paddings_array; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; + TosaPadQuantInfo* qinfo; +}; + +template <int InRank, int OutRank, DType Dtype> +class OpReshape : public GraphNode +{ +public: + OpReshape(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpReshape(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, InRank>; + using TOut = Eigen::Tensor<OutEigenType, OutRank>; + +protected: + Eigen::array<Eigen::Index, OutRank> array_shape; + Eigen::array<Eigen::Index, InRank> in_reverser; + Eigen::array<Eigen::Index, OutRank> out_reverser; + TosaReference::TensorTemplate<TIn>* in; + TosaReshapeAttribute* attribute; + TosaReference::TensorTemplate<TOut>* out; +}; + +template <int Rank, DType Dtype> +class OpReverse : public GraphNode +{ +public: + OpReverse(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpReverse(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + TosaAxisAttribute* attribute; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; + Eigen::array<bool, Rank> reverse_array; +}; + +template <int Rank, DType Dtype> +class OpSlice : public GraphNode +{ +public: + OpSlice(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpSlice(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + TosaSliceAttribute* attribute; + Eigen::array<Eigen::Index, Rank> begin_array; + Eigen::array<Eigen::Index, Rank> size_array; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; +}; + +template <int Rank, DType Dtype> +class OpTileBase : public GraphNode +{ +public: + OpTileBase(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpTileBase(); + + virtual int checkTensorAttributes(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + TosaTileAttribute* attribute; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; +}; + +// primary template for op tile +template <int Rank, DType Dtype> +class OpTile : public OpTileBase<Rank, Dtype> +{ +public: + OpTile(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : OpTileBase<Rank, Dtype>(attribute_, qinfo_, id_) + {} + +protected: + virtual int eval(); +}; + +// partial specialization for specific rank +#define DEF_OP_TILE_RANK(N) \ + template <DType Dtype> \ + class OpTile<N, Dtype> : public OpTileBase<N, Dtype> \ + { \ + public: \ + OpTile(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) \ + : OpTileBase<N, Dtype>(attribute_, qinfo_, id_) \ + {} \ + \ + protected: \ + virtual int eval(); \ + }; + +DEF_OP_TILE_RANK(1) +DEF_OP_TILE_RANK(2) +DEF_OP_TILE_RANK(3) +DEF_OP_TILE_RANK(4) + +#undef DEF_OP_TILE_RANK + +template <int Rank, DType Dtype> +class OpTranspose : public GraphNode +{ +public: + OpTranspose(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpTranspose(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + Eigen::array<int, Rank> perm_array; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<ETensor1<int32_t>>* perm_tensor; + TosaReference::TensorTemplate<TOut>* out; +}; +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/data_nodes.cc b/reference_model/src/ops/data_nodes.cc new file mode 100644 index 0000000..2ee4935 --- /dev/null +++ b/reference_model/src/ops/data_nodes.cc @@ -0,0 +1,172 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "data_nodes.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +OpConst::OpConst(uint64_t id_) + : GraphNode(Op_CONST, id_) +{ + setRequiredOperands(0, 1); +} + +OpConst::~OpConst() +{} + +int OpConst::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + return 0; +} + +int OpConst::eval() +{ + // Evaluation is trivial for constants + return GraphNode::eval(); +} + +OpPlaceholder::OpPlaceholder(uint64_t id_) + : GraphNode(Op_PLACEHOLDER, id_) +{ + setRequiredOperands(0, 1); +} + +OpPlaceholder::~OpPlaceholder() +{} + +int OpPlaceholder::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + return 0; +} + +int OpPlaceholder::eval() +{ + // Evaluation is trivial for placeholders + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +OpIdentity<Rank, Dtype>::OpIdentity(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_IDENTITY, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(0, 6); +} + +template <int Rank, DType Dtype> +OpIdentity<Rank, Dtype>::~OpIdentity() +{} + +template <int Rank, DType Dtype> +int OpIdentity<Rank, Dtype>::checkTensorAttributes() +{ + + if (inputs.size() != outputs.size()) + { + printNodeValidationError("Input and output tensor list lengths are not equal"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + if (in->matchRankTypeShape(*out)) + { + printNodeValidationError("Input and output tensor rank, type, or shape do not match"); + return 1; + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpIdentity<Rank, Dtype>::eval() +{ + out->getTensor() = in->getTensor(); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +OpIdentityN<Rank, Dtype>::OpIdentityN(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_IDENTITYN, id_) +{ + setRequiredRank(0, 6); +} + +template <int Rank, DType Dtype> +OpIdentityN<Rank, Dtype>::~OpIdentityN() +{} + +template <int Rank, DType Dtype> +int OpIdentityN<Rank, Dtype>::checkTensorAttributes() +{ + + if (inputs.size() != outputs.size()) + { + printNodeValidationError("Input and output tensor list lengths are not equal"); + return 1; + } + + for (size_t i = 0; i < inputs.size(); i++) + { + ins.push_back(dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[i])); + outs.push_back(dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[i])); + + if (ins[i]->matchRankTypeShape(*outs[i])) + { + printNodeValidationError("Input and output tensor rank, type, or shape do not match"); + return 1; + } + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpIdentityN<Rank, Dtype>::eval() +{ + for (size_t i = 0; i < ins.size(); i++) + { + outs[i]->getTensor() = ins[i]->getTensor(); + } + + return GraphNode::eval(); +} + +// template explicit instantiation +// note OpConst and OpPlaceholder are not templated + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, BOOL); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, BOOL); diff --git a/reference_model/src/ops/data_nodes.h b/reference_model/src/ops/data_nodes.h new file mode 100644 index 0000000..bec4669 --- /dev/null +++ b/reference_model/src/ops/data_nodes.h @@ -0,0 +1,86 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_DATA_NODES_H +#define OPS_DATA_NODES_H + +#include "graph_node.h" + +namespace TosaReference +{ + +class OpConst : public GraphNode +{ +public: + OpConst(uint64_t id_); + virtual ~OpConst(); + + virtual int checkTensorAttributes(); + virtual int eval(); +}; + +class OpPlaceholder : public GraphNode +{ +public: + OpPlaceholder(uint64_t id_); + virtual ~OpPlaceholder(); + + virtual int checkTensorAttributes(); + virtual int eval(); +}; + +template <int Rank, DType Dtype> +class OpIdentity : public GraphNode +{ +public: + OpIdentity(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpIdentity(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; +}; + +template <int Rank, DType Dtype> +class OpIdentityN : public GraphNode +{ +public: + OpIdentityN(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpIdentityN(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + std::vector<TosaReference::TensorTemplate<TIn>*> ins; + std::vector<TosaReference::TensorTemplate<TOut>*> outs; +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/ewise_binary.cc b/reference_model/src/ops/ewise_binary.cc new file mode 100644 index 0000000..4d4f8b9 --- /dev/null +++ b/reference_model/src/ops/ewise_binary.cc @@ -0,0 +1,586 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "ewise_binary.h" +#include "arith_util.h" +#include "quant_util.h" +#include "template_types.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int Rank, DType InDtype, DType OutDtype> +BinaryNodeBase<Rank, InDtype, OutDtype>::BinaryNodeBase(const Op& op_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(op_, id_) +{ + setRequiredOperands(2, 1); + setRequiredRank(0, 6); + + a_rank = b_rank = max_input_rank = -1; + a = b = nullptr; + a_rank0 = b_rank0 = nullptr; + result = nullptr; + + fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return OutEigenType(); }; +} + +template <int Rank, DType InDtype, DType OutDtype> +BinaryNodeBase<Rank, InDtype, OutDtype>::~BinaryNodeBase() +{} + +template <int Rank, DType InDtype, DType OutDtype> +int BinaryNodeBase<Rank, InDtype, OutDtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(inputs[1]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + a_rank = inputs[0]->getRank(); + b_rank = inputs[1]->getRank(); + if (a_rank != 0 && b_rank != 0 && a_rank != b_rank) + { + printNodeValidationError("Binary operator input ranks must match"); + return 1; + } + + max_input_rank = a_rank >= b_rank ? a_rank : b_rank; + + // A & B must be the same types + if (inputs[0]->matchType(*inputs[1])) + { + printNodeValidationError("Binary operator input types must match"); + return 1; + } + + // Result's geometry must match, but the type may be wider + if (outputs[0]->getRank() != max_input_rank) + { + printNodeValidationError("Binary operator input and output genometry must match"); + return 1; + } + + if (a_rank == max_input_rank) + { + a = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + } + else + { + a_rank0 = dynamic_cast<TosaReference::TensorTemplate<ETensor0<InEigenType>>*>(inputs[0]); + } + + if (b_rank == max_input_rank) + { + b = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[1]); + } + else + { + b_rank0 = dynamic_cast<TosaReference::TensorTemplate<ETensor0<InEigenType>>*>(inputs[1]); + } + + result = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + // either a or b can be rank0 + // a_rank0 and b_rank0 can't be valid at the same time. + // if a and be are both rank0, they should be evaulated as 'a' and 'b', instead of 'a_rank0' and 'b_rank0' + ASSERT_MEM((a || a_rank0) && (b || b_rank0) && !(a_rank0 && b_rank0) && result); + + return 0; +} + +template <int Rank, DType InDtype, DType OutDtype> +int BinaryNodeBase<Rank, InDtype, OutDtype>::broadcast() +{ + auto output_shape = result->getTensor().dimensions(); + + std::vector<int> a_shape, b_shape; + + if (a_rank == max_input_rank) + { + a_shape = a->getShape(); + } + else + { + a_shape.assign(max_input_rank, 1); + } + + if (b_rank == max_input_rank) + { + b_shape = b->getShape(); + } + else + { + b_shape.assign(max_input_rank, 1); + } + + for (int i = 0; i < max_input_rank; i++) + { + if (a_shape[i] != output_shape[i] && a_shape[i] == 1) + { + bcast_a[i] = output_shape[i]; + } + else + { + bcast_a[i] = 1; + } + if (b_shape[i] != output_shape[i] && b_shape[i] == 1) + { + bcast_b[i] = output_shape[i]; + } + else + { + bcast_b[i] = 1; + } + } + + return 0; +} + +template <int Rank, DType InDtype, DType OutDtype> +int BinaryNode<Rank, InDtype, OutDtype>::eval() +{ + this->broadcast(); + + Eigen::array<int, Rank> reshaper; + reshaper.fill(1); + TIn ia, ib; + + if (this->a_rank == this->max_input_rank) + { + ia = this->a->getTensor().broadcast(this->bcast_a); + } + else + { + ia = this->a_rank0->getTensor().reshape(reshaper).broadcast(this->bcast_a); + } + + if (this->b_rank == this->max_input_rank) + { + ib = this->b->getTensor().broadcast(this->bcast_b); + } + else + { + ib = this->b_rank0->getTensor().reshape(reshaper).broadcast(this->bcast_b); + } + + this->result->getTensor() = ia.binaryExpr(ib, this->fcn); + + return GraphNode::eval(); +} + +// still need to partial specialize this, or Eigen will throw static assertion +template <DType InDtype, DType OutDtype> +int BinaryNode<0, InDtype, OutDtype>::eval() +{ + this->result->getTensor() = this->a->getTensor().binaryExpr(this->b->getTensor(), this->fcn); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +int OpAdd<Rank, Dtype>::register_fcn() +{ + switch (InDtype) + { + case DType_FLOAT: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a + b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[InDtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpArithmeticRightShift<Rank, Dtype>::register_fcn() +{ + int32_t num_bits = 0; + switch (Dtype) + { + case DType_INT8: + num_bits = 8; + break; + case DType_INT16: + num_bits = 16; + break; + case DType_INT32: + num_bits = 32; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + this->fcn = [num_bits](InEigenType a, InEigenType b) -> OutEigenType { + uint32_t sign = a & (1 << (num_bits - 1)); + uint32_t ones_mask = ONES_MASK(b) << (num_bits - b); + if (sign) + return ones_mask | (a >> b); + else + return (~ones_mask) & (a >> b); + }; + + return 0; +} + +template <int Rank, DType Dtype> +int OpBitwiseAnd<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_AINT8: + case DType_INT16: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a & b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpBitwiseOr<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_AINT8: + case DType_INT16: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a | b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpBitwiseXor<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_AINT8: + case DType_INT16: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a ^ b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpLogicalAnd<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_BOOL: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a && b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpLogicalLeftShift<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_INT8: + case DType_INT16: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a << b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpLogicalRightShift<Rank, Dtype>::register_fcn() +{ + int32_t num_bits = 0; + switch (Dtype) + { + case DType_INT8: + num_bits = 8; + break; + case DType_INT16: + num_bits = 16; + break; + case DType_INT32: + num_bits = 32; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + this->fcn = [num_bits](InEigenType a, InEigenType b) -> OutEigenType { + uint32_t mask = ONES_MASK(num_bits) >> b; + return (a >> b) & mask; + }; + + return 0; +} + +template <int Rank, DType Dtype> +int OpLogicalOr<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_BOOL: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a || b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpLogicalXor<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_BOOL: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a ^ b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpMaximum<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a > b ? a : b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpMinimum<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a < b ? a : b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType InDtype, DType OutDtype> +int OpMul<Rank, InDtype, OutDtype>::register_fcn() +{ + switch (InDtype) + { + case DType_FLOAT: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a * b; }; + break; + case DType_INT8: + case DType_INT16: + this->fcn = [this](InEigenType lhs, InEigenType rhs) -> OutEigenType { + OutEigenType raw_output = (OutEigenType)lhs * (OutEigenType)rhs; + + OutEigenType clamped_output = std::min<OutEigenType>(QMax, std::max<OutEigenType>(raw_output, QMin)); + + return clamped_output; + }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[InDtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpPow<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return powf(a, b); }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpSub<Rank, Dtype>::register_fcn() +{ + switch (InDtype) + { + case DType_FLOAT: + case DType_INT32: + this->fcn = [](InEigenType a, InEigenType b) -> OutEigenType { return a - b; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[InDtype]); + } + + return 0; +} + +template <int Rank> +OpTable<Rank>::OpTable(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_TABLE, id_) +{ + setRequiredOperands(2, 1); + setRequiredRank(0, 6); +} + +template <int Rank> +OpTable<Rank>::~OpTable() +{} + +template <int Rank> +int OpTable<Rank>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + if (inputs[1]->getRank() != 1 || inputs[1]->getElementCount() != 513 || inputs[1]->getDtype() != DType_INT16) + { + FATAL_ERROR_NODE("OpTable: must have INT16 table with 513 entries"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + table = dynamic_cast<TosaReference::TensorTemplate<TTable>*>(inputs[1]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + ASSERT_MEM(in && table && out); + + return 0; +} + +template <int Rank> +int OpTable<Rank>::eval() +{ + this->out->getTensor() = this->in->getTensor().unaryExpr([this](InEigenType in) -> OutEigenType { + // 1. make sure input is int16 range + int32_t input_truncated = std::min<int32_t>(std::max<int32_t>(in, QInMin), QInMax); + + // 2. calculate index and interpolation fraction + int32_t index = (input_truncated >> 7) + (1 << (IntegerBits - 1)); + index = std::min<int32_t>(std::max<int32_t>(index, 0), NumTableEntries - 1); // 9-bit index + int32_t frac = (input_truncated)&0x7F; // 7-bit fraction + + // 3. interpolate, generate 16.7 (23-bit) output + int32_t base = this->table->getTensor()(index); + int32_t next = this->table->getTensor()(index + 1); + int32_t value = (base << 7) + (next - base) * frac; + + return value; + }); + + return GraphNode::eval(); +} + +// template explicit instantiation +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpAdd, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpAdd, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpArithmeticRightShift, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpArithmeticRightShift, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpArithmeticRightShift, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseAnd, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseAnd, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseAnd, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseOr, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseOr, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseOr, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseXor, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseXor, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseXor, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalAnd, BOOL); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalLeftShift, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalLeftShift, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalLeftShift, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalRightShift, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalRightShift, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalRightShift, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalOr, BOOL); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalXor, BOOL); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpMaximum, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpMaximum, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpMinimum, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpMinimum, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpMul, FLOAT, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpMul, INT8, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpMul, INT16, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpMul, INT32, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpPow, FLOAT); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSub, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSub, INT32); + +DEF_INSTANTIATE_ONE_RANK_0_6(OpTable); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(BinaryNode, FLOAT, BOOL); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(BinaryNode, INT32, BOOL); diff --git a/reference_model/src/ops/ewise_binary.h b/reference_model/src/ops/ewise_binary.h new file mode 100644 index 0000000..00fb3d9 --- /dev/null +++ b/reference_model/src/ops/ewise_binary.h @@ -0,0 +1,195 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_EWISE_BINARY_H +#define OPS_EWISE_BINARY_H + +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ + +// class BinaryNodeBase: hold common functions of all the binary nodes +// when an binary op is created, the virtual OpXXX::register_fcn() will be called +// and 'fcn' will be register with lambda function which has two inputs +// class BinaryNode: the level of indirection to partially specialize template for rank 0 +// eval() from toplevel called should call the .binaryExpr(dims, fcn) here +// this needs to be partially specialize or +// compiler will statically fail when trying to broadcast rank0 tensor +// class OpXXX: implement per-element lambda function based on different data type +// unlike BinaryNode, this doesn't need to be partially specialized + +// Eigen::Tensor does support some binary element-wise natively (e.g. CWiseMax, or '+', etc.) +// which might be faster since it could be implemented with SIMD instructions +// the way of registering lambda + .binaryExpr() might sacrifice performance here +// but it can avoid partially specialization for combination of {rankN, rank0} x {FLOAT/INT32, QU8, ...} +// needs to revisit if performance becomes a bottleneck here +template <int Rank, DType InDtype, DType OutDtype> +class BinaryNodeBase : public GraphNode +{ +public: + BinaryNodeBase(const Op& nodeType, TosaQuantInfoBase* qinfo_, const uint64_t id_); + virtual ~BinaryNodeBase(); + + virtual int checkTensorAttributes() final; + virtual int eval() = 0; + virtual int register_fcn() = 0; + + using InEigenType = typename GetEigenType<InDtype>::type; + using OutEigenType = typename GetEigenType<OutDtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + int broadcast(); + +protected: + std::function<OutEigenType(InEigenType, InEigenType)> fcn; + Eigen::array<int, Rank> bcast_a; + Eigen::array<int, Rank> bcast_b; + TosaReference::TensorTemplate<TIn>* a; + TosaReference::TensorTemplate<TIn>* b; + TosaReference::TensorTemplate<ETensor0<InEigenType>>* a_rank0; + TosaReference::TensorTemplate<ETensor0<InEigenType>>* b_rank0; + TosaReference::TensorTemplate<TOut>* result; + int a_rank; + int b_rank; + int max_input_rank; +}; + +// primary class +template <int Rank, DType InDtype, DType OutDtype> +class BinaryNode : public BinaryNodeBase<Rank, InDtype, OutDtype> +{ +public: + BinaryNode(const Op& op_, TosaQuantInfoBase* qinfo_, const uint64_t id_) + : BinaryNodeBase<Rank, InDtype, OutDtype>(op_, qinfo_, id_) + {} + virtual ~BinaryNode() + {} + + virtual int eval(); + + using InEigenType = typename GetEigenType<InDtype>::type; + using OutEigenType = typename GetEigenType<OutDtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; +}; + +// partial specialization for rank 0 +template <DType InDtype, DType OutDtype> +class BinaryNode<0, InDtype, OutDtype> : public BinaryNodeBase<0, InDtype, OutDtype> +{ +public: + BinaryNode(const Op& op_, TosaQuantInfoBase* qinfo_, const uint64_t id_) + : BinaryNodeBase<0, InDtype, OutDtype>(op_, qinfo_, id_) + {} + virtual ~BinaryNode() + {} + + virtual int eval(); +}; + +#define DEF_TEMPLATE_BINARY_OP_ONE_TYPE(Opname, OPNAME) \ + template <int Rank, DType Dtype> \ + class Op##Opname : public BinaryNode<Rank, Dtype, Dtype> \ + { \ + public: \ + Op##Opname(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) \ + : BinaryNode<Rank, Dtype, Dtype>(Op_##OPNAME, qinfo_, id_) \ + { \ + register_fcn(); \ + } \ + static constexpr DType InDtype = Dtype; \ + static constexpr DType OutDtype = Dtype; \ + using InEigenType = typename GetEigenType<InDtype>::type; \ + using OutEigenType = typename GetEigenType<OutDtype>::type; \ + virtual int register_fcn(); \ + }; + +#define DEF_TEMPLATE_BINARY_OP_TWO_TYPE(Opname, OPNAME) \ + template <int Rank, DType InDtype, DType OutDtype> \ + class Op##Opname : public BinaryNode<Rank, InDtype, OutDtype> \ + { \ + public: \ + Op##Opname(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) \ + : BinaryNode<Rank, InDtype, OutDtype>(Op_##OPNAME, qinfo_, id_) \ + { \ + register_fcn(); \ + } \ + static constexpr int32_t QMin = GetQMin<OutDtype>::value; \ + static constexpr int32_t QMax = GetQMax<OutDtype>::value; \ + using InEigenType = typename GetEigenType<InDtype>::type; \ + using OutEigenType = typename GetEigenType<OutDtype>::type; \ + virtual int register_fcn(); \ + }; + +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(Add, ADD) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(ArithmeticRightShift, ARITHMETIC_RIGHT_SHIFT) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(BitwiseAnd, BITWISE_AND) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(BitwiseOr, BITWISE_OR) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(BitwiseXor, BITWISE_XOR) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(LogicalAnd, LOGICAL_AND) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(LogicalLeftShift, LOGICAL_LEFT_SHIFT) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(LogicalRightShift, LOGICAL_RIGHT_SHIFT) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(LogicalOr, LOGICAL_OR) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(LogicalXor, LOGICAL_XOR) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(Maximum, MAXIMUM) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(Minimum, MINIMUM) +DEF_TEMPLATE_BINARY_OP_TWO_TYPE(Mul, MUL) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(Pow, POW) +DEF_TEMPLATE_BINARY_OP_ONE_TYPE(Sub, SUB) + +#undef DEF_TEMPLATE_BINARY_OP_ONE_TYPE +#undef DEF_TEMPLATE_BINARY_OP_TWO_TYPE + +template <int Rank> +class OpTable : public GraphNode +{ +public: + OpTable(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpTable(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + static constexpr DType InDtype = DType_INT16; + static constexpr DType TableDtype = DType_INT16; + static constexpr DType OutDtype = DType_INT32; + using InEigenType = typename GetEigenType<InDtype>::type; + using TableEigenType = typename GetEigenType<TableDtype>::type; + using OutEigenType = typename GetEigenType<OutDtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TTable = Eigen::Tensor<TableEigenType, 1>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + static constexpr int32_t IntegerBits = 9; + static constexpr int32_t FractionBits = 7; + static constexpr int32_t NumTableEntries = (1 << IntegerBits); + static constexpr int32_t QInMin = GetQMin<InDtype>::value; + static constexpr int32_t QInMax = GetQMax<InDtype>::value; + static constexpr int32_t QOutMin = GetQMin<OutDtype>::value; + static constexpr int32_t QOutMax = GetQMax<OutDtype>::value; + +protected: + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TTable>* table; + TosaReference::TensorTemplate<TOut>* out; +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/ewise_ternary.cc b/reference_model/src/ops/ewise_ternary.cc new file mode 100644 index 0000000..eded0d7 --- /dev/null +++ b/reference_model/src/ops/ewise_ternary.cc @@ -0,0 +1,115 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "ewise_ternary.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int Rank, DType Dtype> +OpSelectBase<Rank, Dtype>::OpSelectBase(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_SELECT, id_) +{ + setRequiredOperands(3, 1); + setRequiredRank(0, 6); +} + +template <int Rank, DType Dtype> +OpSelectBase<Rank, Dtype>::~OpSelectBase() +{} + +template <int Rank, DType Dtype> +int OpSelectBase<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(inputs[1]) || validateRequiredRank(inputs[2]) || + validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same types + if (inputs[0]->matchRank(*outputs[0]) || inputs[1]->matchRankType(*outputs[0]) || + inputs[2]->matchRankType(*outputs[0])) + { + printNodeValidationError("Failure to match input and output rank and type"); + return 1; + } + + cond = dynamic_cast<TosaReference::TensorTemplate<TCond>*>(inputs[0]); + then_val = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[1]); + else_val = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[2]); + out = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(outputs[0]); + + return 0; +} + +template <int Rank, DType Dtype> +int OpSelectBase<Rank, Dtype>::eval() +{ + FATAL_ERROR_NODE("shouldn't be called"); +} + +template <int Rank, DType Dtype> +int OpSelect<Rank, Dtype>::broadcast() +{ + std::vector<int> cond_shape = this->cond->getShape(); + std::vector<int> then_shape = this->then_val->getShape(); + std::vector<int> else_shape = this->else_val->getShape(); + std::vector<int> out_shape = this->out->getShape(); + + for (int i = 0; i < Rank; i++) + { + this->bcast_cond[i] = (cond_shape[i] == 1) ? std::max(then_shape[i], else_shape[i]) : 1; + this->bcast_then[i] = (then_shape[i] == 1) ? std::max(cond_shape[i], else_shape[i]) : 1; + this->bcast_else[i] = (else_shape[i] == 1) ? std::max(then_shape[i], cond_shape[i]) : 1; + ASSERT_MSG_NODE((this->bcast_cond[i] * cond_shape[i]) == out_shape[i], "SELECT broadcast invariant failed"); + ASSERT_MSG_NODE((this->bcast_then[i] * then_shape[i]) == out_shape[i], "SELECT broadcast invariant failed"); + ASSERT_MSG_NODE((this->bcast_else[i] * else_shape[i]) == out_shape[i], "SELECT broadcast invariant failed"); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpSelect<Rank, Dtype>::eval() +{ + this->broadcast(); + this->out->getTensor() = this->cond->getTensor() + .broadcast(this->bcast_cond) + .select(this->then_val->getTensor().broadcast(this->bcast_then), + this->else_val->getTensor().broadcast(this->bcast_else)); + + return GraphNode::eval(); +} + +template <DType Dtype> +int OpSelect<0, Dtype>::eval() +{ + this->out->getTensor() = this->cond->getTensor().select(this->then_val->getTensor(), this->else_val->getTensor()); + + return GraphNode::eval(); +} + +// template explicit instantiation +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, BOOL); diff --git a/reference_model/src/ops/ewise_ternary.h b/reference_model/src/ops/ewise_ternary.h new file mode 100644 index 0000000..b354247 --- /dev/null +++ b/reference_model/src/ops/ewise_ternary.h @@ -0,0 +1,83 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_TERNARY_H +#define OPS_TERNARY_H + +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ + +// The Ternary Select op has the following operands: +// 1. Cond: rank N, type=bool +// 2. Then_val: Rank N, type=<V> +// 3. Else_val: Rank N, type=<V> +// 4. Result: Rank N, type=<V> +// Cond, Then_val, Else_val need to be mutually-broadcastable +template <int Rank, DType Dtype> +class OpSelectBase : public GraphNode +{ +public: + OpSelectBase(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpSelectBase(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using CondEigenType = typename GetEigenType<DType_BOOL>::type; + using InEigenType = typename GetEigenType<Dtype>::type; + using TCond = Eigen::Tensor<CondEigenType, Rank>; + using TIn = Eigen::Tensor<InEigenType, Rank>; + +protected: + TosaReference::TensorTemplate<TCond>* cond; + Eigen::array<int, Rank> bcast_cond; + Eigen::array<int, Rank> bcast_then; + Eigen::array<int, Rank> bcast_else; + TosaReference::TensorTemplate<TIn>* then_val; + TosaReference::TensorTemplate<TIn>* else_val; + TosaReference::TensorTemplate<TIn>* out; +}; + +// primary class +template <int Rank, DType Dtype> +class OpSelect : public OpSelectBase<Rank, Dtype> +{ +public: + OpSelect(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : OpSelectBase<Rank, Dtype>(attribute_, qinfo_, id_) + {} + virtual int eval(); + int broadcast(); + + using InEigenType = typename OpSelectBase<Rank, Dtype>::InEigenType; +}; + +// partial specialization for rank 0 +template <DType Dtype> +class OpSelect<0, Dtype> : public OpSelectBase<0, Dtype> +{ +public: + OpSelect(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : OpSelectBase<0, Dtype>(attribute_, qinfo_, id_) + {} + virtual int eval(); +}; +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/ewise_unary.cc b/reference_model/src/ops/ewise_unary.cc new file mode 100644 index 0000000..d7bddc0 --- /dev/null +++ b/reference_model/src/ops/ewise_unary.cc @@ -0,0 +1,302 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "ewise_unary.h" +#include "quant_util.h" +#include "template_types.h" +#include <cmath> + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int Rank, DType Dtype> +UnaryNode<Rank, Dtype>::UnaryNode(const Op& op_, uint64_t id_) + : GraphNode(op_, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(0, 6); + + fcn = [](InEigenType a) -> OutEigenType { return OutEigenType(); }; +} + +template <int Rank, DType Dtype> +UnaryNode<Rank, Dtype>::~UnaryNode() +{} + +template <int Rank, DType Dtype> +int UnaryNode<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same types + if (inputs[0]->matchRankSize(*outputs[0])) + { + printNodeValidationError("UnaryNode: input and output rank must match"); + return 1; + } + + a = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + result = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + ASSERT_MEM(a && result); + + return 0; +} + +template <int Rank, DType Dtype> +int UnaryNode<Rank, Dtype>::eval() +{ + this->result->getTensor() = this->a->getTensor().unaryExpr(this->fcn); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +int OpAbs<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + case DType_INT32: + this->fcn = [](InEigenType a) -> OutEigenType { return a > (InEigenType)0 ? a : (-a); }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpBitwiseNot<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_AINT8: + case DType_INT16: + case DType_INT32: + this->fcn = [](InEigenType a) -> OutEigenType { return ~a; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpCeil<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a) -> OutEigenType { return ceilf(a); }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpClz<Rank, Dtype>::register_fcn() +{ + int32_t num_bits; + switch (Dtype) + { + case DType_INT32: + num_bits = 32; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + this->fcn = [num_bits](int32_t a) -> int32_t { + int32_t leading_zeros = 0; + for (int bit = num_bits - 1; bit >= 0; bit--) + { + if (((a >> bit) & 0x1) == 0) + { + leading_zeros++; + } + else + { + break; + } + } + return leading_zeros; + }; + + return 0; +} + +template <int Rank, DType Dtype> +int OpExp<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a) -> OutEigenType { return expf(a); }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpFloor<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a) -> OutEigenType { return floorf(a); }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpLog<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a) -> OutEigenType { return logf(a); }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpLogicalNot<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_BOOL: + this->fcn = [](InEigenType a) -> OutEigenType { return !a; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpNegate<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a) -> OutEigenType { + InEigenType result = -(a); + return result; + }; + break; + case DType_INT16: + case DType_INT32: + this->fcn = [](InEigenType a) -> OutEigenType { + InEigenType result = -(a); + return result; + }; + break; + case DType_AINT8: + ASSERT(this->qinfo); + this->fcn = [this](InEigenType a) -> OutEigenType { + InEigenType result = -(a - this->qinfo->input_zp()) + this->qinfo->output_zp(); + return result; + }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpReciprocal<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a) -> OutEigenType { return 1.0 / a; }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +template <int Rank, DType Dtype> +int OpRsqrt<Rank, Dtype>::register_fcn() +{ + switch (Dtype) + { + case DType_FLOAT: + this->fcn = [](InEigenType a) -> OutEigenType { return 1.0 / sqrtf(a); }; + break; + default: + FATAL_ERROR_NODE("unsupported DType %s", EnumNamesDType()[Dtype]); + } + + return 0; +} + +// template explicit instantiation +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpAbs, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpAbs, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseNot, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseNot, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseNot, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpCeil, FLOAT); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpClz, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpExp, FLOAT); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpFloor, FLOAT); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLog, FLOAT); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalNot, BOOL); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpNegate, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpNegate, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpNegate, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpNegate, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpRsqrt, FLOAT); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_ONE_TYPE(OpReciprocal, FLOAT); diff --git a/reference_model/src/ops/ewise_unary.h b/reference_model/src/ops/ewise_unary.h new file mode 100644 index 0000000..0db3cfb --- /dev/null +++ b/reference_model/src/ops/ewise_unary.h @@ -0,0 +1,102 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_EWISE_UNARY_H +#define OPS_EWISE_UNARY_H + +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ +template <int Rank, DType Dtype> +class UnaryNode : public GraphNode +{ +public: + UnaryNode(const Op& nodeType, const uint64_t id_); + virtual ~UnaryNode(); + + virtual int checkTensorAttributes() final; + virtual int eval() final; + virtual int register_fcn() = 0; + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + std::function<OutEigenType(InEigenType)> fcn; + TosaReference::TensorTemplate<TIn>* a; + TosaReference::TensorTemplate<TOut>* result; +}; + +#define DEF_TEMPLATE_UNARY_OP(Opname, OPNAME) \ + template <int Rank, DType Dtype> \ + class Op##Opname : public UnaryNode<Rank, Dtype> \ + { \ + public: \ + Op##Opname(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) \ + : UnaryNode<Rank, Dtype>(Op_##OPNAME, id_) \ + { \ + register_fcn(); \ + } \ + static constexpr int32_t QMin = GetQMin<Dtype>::value; \ + static constexpr int32_t QMax = GetQMax<Dtype>::value; \ + using InEigenType = typename GetEigenType<Dtype>::type; \ + using OutEigenType = typename GetEigenType<Dtype>::type; \ + virtual int register_fcn(); \ + }; + +#define DEF_TEMPLATE_UNARY_OP_WITH_QUANT_INFO(Opname, OPNAME) \ + template <int Rank, DType Dtype> \ + class Op##Opname : public UnaryNode<Rank, Dtype> \ + { \ + public: \ + Op##Opname(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) \ + : UnaryNode<Rank, Dtype>(Op_##OPNAME, id_) \ + { \ + INIT_QINFO(Unary); \ + register_fcn(); \ + } \ + static constexpr int32_t QMin = GetQMin<Dtype>::value; \ + static constexpr int32_t QMax = GetQMax<Dtype>::value; \ + using InEigenType = typename GetEigenType<Dtype>::type; \ + using OutEigenType = typename GetEigenType<Dtype>::type; \ + virtual int register_fcn(); \ + \ + protected: \ + TosaUnaryQuantInfo* qinfo; \ + }; + +DEF_TEMPLATE_UNARY_OP(Abs, ABS) +DEF_TEMPLATE_UNARY_OP(BitwiseNot, BITWISE_NOT) +DEF_TEMPLATE_UNARY_OP(Ceil, CEIL) +DEF_TEMPLATE_UNARY_OP(Clz, CLZ) +DEF_TEMPLATE_UNARY_OP(Exp, EXP) +DEF_TEMPLATE_UNARY_OP(Floor, FLOOR) +DEF_TEMPLATE_UNARY_OP(Log, LOG) +DEF_TEMPLATE_UNARY_OP(LogicalNot, LOGICAL_NOT) +DEF_TEMPLATE_UNARY_OP_WITH_QUANT_INFO(Negate, NEGATE) +DEF_TEMPLATE_UNARY_OP(Reciprocal, RECIPROCAL) +DEF_TEMPLATE_UNARY_OP(Rsqrt, RSQRT) + +#undef DEF_TEMPLATE_UNARY_OP +#undef DEF_TEMPLATE_UNARY_OP_WITH_QUANT_INFO + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/image.cc b/reference_model/src/ops/image.cc new file mode 100644 index 0000000..d3352ce --- /dev/null +++ b/reference_model/src/ops/image.cc @@ -0,0 +1,169 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "image.h" +#include "arith_util.h" +#include "quant_util.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <DType InDtype, DType OutDtype> +OpResize<InDtype, OutDtype>::OpResize(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_RESIZE, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(4, 4); + + INIT_ATTRIBUTE(Resize); +} + +template <DType InDtype, DType OutDtype> +OpResize<InDtype, OutDtype>::~OpResize() +{ + if (attribute) + delete attribute; +} + +template <DType InDtype, DType OutDtype> +int OpResize<InDtype, OutDtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + return 1; + + output_size = this->attribute->output_size(); + stride = this->attribute->stride(); + offset = this->attribute->offset(); + shift = this->attribute->shift(); + mode = this->attribute->mode(); + + int output_height = outputs[0]->getShape()[1]; + int output_width = outputs[0]->getShape()[2]; + + if (this->mode == ResizeMode_BILINEAR) + { + if (OutDtype != DType_INT32 && OutDtype != DType_INT48) + { + printNodeValidationError("OpResize: invalid data type for BILINEAR"); + return 1; + } + } + else + { + if (OutDtype != DType_INT8 && OutDtype != DType_INT16) + { + printNodeValidationError("OpResize: invalid data type for NEAREST"); + return 1; + } + } + + if (output_size[0] != output_height || output_size[1] != output_width) + { + printNodeValidationError("OpResize: attribute output_size doesn't match output [height, width]"); + return 1; + } + + if (shift < 1 || shift > 11) + { + printNodeValidationError("OpResize: attribute shift should be within [1, 11]"); + return 1; + } + + if (stride[0] <= 0 || stride[1] <= 0) + { + printNodeValidationError("OpResize: invalid attribute stride"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + ASSERT_MEM(in && out); + + return 0; +} + +template <DType InDtype, DType OutDtype> +int OpResize<InDtype, OutDtype>::eval() +{ + int in_batch = in->getShape()[0]; + int in_height = in->getShape()[1]; + int in_width = in->getShape()[2]; + int in_channels = in->getShape()[3]; + + int out_batch = out->getShape()[0]; + int out_height = out->getShape()[1]; + int out_width = out->getShape()[2]; + int out_channels = out->getShape()[3]; + + ASSERT_MSG_NODE(in_batch == out_batch, "OpResize: output tensor batch mismatch"); + ASSERT_MSG_NODE(in_channels == out_channels, "OpResize: output tensor channel mismatch"); + + for (int b = 0; b < out_batch; b++) + for (int c = 0; c < out_channels; c++) + for (int oy = 0; oy < out_height; oy++) + for (int ox = 0; ox < out_width; ox++) + { + int y = oy * stride[0] + offset[0]; + int x = ox * stride[1] + offset[1]; + + int iy = y >> shift; + int dy = y - (iy << shift); + int ix = x >> shift; + int dx = x - (ix << shift); + + int iy0 = MAX(iy, 0); + int iy1 = MIN(iy + 1, in_height - 1); + int ix0 = MAX(ix, 0); + int ix1 = MIN(ix + 1, in_width - 1); + + ASSERT_MSG(iy0 <= iy1 && ix0 <= ix1, "OpResize: invalid index (iy0, iy1, ix0, ix1)=(%d,%d,%d,%d)", + iy0, iy1, ix0, ix1); + + InEigenType v00 = in->getTensor()(b, iy0, ix0, c); + InEigenType v01 = in->getTensor()(b, iy0, ix1, c); + InEigenType v10 = in->getTensor()(b, iy1, ix0, c); + InEigenType v11 = in->getTensor()(b, iy1, ix1, c); + + OutEigenType acc; + if (mode == ResizeMode_BILINEAR) + { + acc = (OutEigenType)v00 * ((1 << shift) - dy) * ((1 << shift) - dx); + acc = acc + (OutEigenType)v01 * ((1 << shift) - dy) * dx; + acc = acc + (OutEigenType)v10 * dy * ((1 << shift) - dx); + acc = acc + (OutEigenType)v11 * dy * dx; + } + else + { + iy = (dy >> (shift - 1)) != 0 ? iy1 : iy0; + ix = (dx >> (shift - 1)) != 0 ? ix1 : ix0; + acc = in->getTensor()(b, iy, ix, c); + } + + out->getTensor()(b, oy, ox, c) = acc; + } + + return GraphNode::eval(); +} + +// template explicit instantiation +DEF_INSTANTIATE_TWO_TYPE(OpResize, INT8, INT32); +DEF_INSTANTIATE_TWO_TYPE(OpResize, INT8, INT8); +DEF_INSTANTIATE_TWO_TYPE(OpResize, INT16, INT48); +DEF_INSTANTIATE_TWO_TYPE(OpResize, INT16, INT16); diff --git a/reference_model/src/ops/image.h b/reference_model/src/ops/image.h new file mode 100644 index 0000000..9d15d49 --- /dev/null +++ b/reference_model/src/ops/image.h @@ -0,0 +1,53 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_IMAGE_H +#define OPS_IMAGE_H + +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ + +template <DType InDtype, DType OutDtype> +class OpResize : public GraphNode +{ +public: + OpResize(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpResize(); + virtual int checkTensorAttributes() final; + virtual int eval(); + + using InEigenType = typename GetEigenType<InDtype>::type; + using OutEigenType = typename GetEigenType<OutDtype>::type; + using TIn = Eigen::Tensor<InEigenType, 4>; + using TOut = Eigen::Tensor<OutEigenType, 4>; + +protected: + TosaResizeAttribute* attribute; + std::vector<int32_t> output_size; + std::vector<int32_t> stride; + std::vector<int32_t> offset; + int32_t shift; + ResizeMode mode; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/op_factory.cc b/reference_model/src/ops/op_factory.cc new file mode 100644 index 0000000..bad0c40 --- /dev/null +++ b/reference_model/src/ops/op_factory.cc @@ -0,0 +1,432 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "op_factory.h" +#include "activation_funcs.h" +#include "comparison.h" +#include "control_flow.h" +#include "custom.h" +#include "data_layout.h" +#include "data_nodes.h" +#include "ewise_binary.h" +#include "ewise_ternary.h" +#include "ewise_unary.h" +#include "image.h" +#include "reduction.h" +#include "scatter_gather.h" +#include "tensor_ops.h" +#include "type_conversion.h" + +using namespace TosaReference; +using namespace tosa; + +GraphNode* OpFactory::newOp(TosaSerializationHandler* tsh, + Op opType, + TosaAttributeBase* attribute, + TosaQuantInfoBase* qinfo, + uint64_t id, + DType inputDType, + int inputRank, + DType outputDType, + int outputRank, + DType weightDType, + int weightRank) +{ + switch (opType) + { + // tensor_ops + case Op_ARGMAX: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpArgMax, FLOAT); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpArgMax, AINT8); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpArgMax, INT16); + break; + case Op_AVG_POOL2D: + DEF_FACTORY_ONE_TYPE(OpAvgPool2d, FLOAT); + DEF_FACTORY_ONE_TYPE(OpAvgPool2d, AINT8); + DEF_FACTORY_ONE_TYPE(OpAvgPool2d, INT16); + break; + case Op_CONV2D: + DEF_FACTORY_TWO_TYPE(OpConv2d, FLOAT, FLOAT); + DEF_FACTORY_TWO_TYPE(OpConv2d, AINT8, INT4); + DEF_FACTORY_TWO_TYPE(OpConv2d, AINT8, INT8); + DEF_FACTORY_TWO_TYPE(OpConv2d, AINT8, AINT8); + DEF_FACTORY_TWO_TYPE(OpConv2d, INT16, INT8); + break; + case Op_DEPTHWISE_CONV2D: + DEF_FACTORY_TWO_TYPE(OpDepthwiseConv2d, FLOAT, FLOAT); + DEF_FACTORY_TWO_TYPE(OpDepthwiseConv2d, AINT8, INT4); + DEF_FACTORY_TWO_TYPE(OpDepthwiseConv2d, AINT8, INT8); + DEF_FACTORY_TWO_TYPE(OpDepthwiseConv2d, AINT8, AINT8); + DEF_FACTORY_TWO_TYPE(OpDepthwiseConv2d, INT16, INT8); + break; + case Op_FULLY_CONNECTED: + DEF_FACTORY_TWO_TYPE(OpFullyConnected, FLOAT, FLOAT); + DEF_FACTORY_TWO_TYPE(OpFullyConnected, AINT8, INT4); + DEF_FACTORY_TWO_TYPE(OpFullyConnected, AINT8, INT8); + DEF_FACTORY_TWO_TYPE(OpFullyConnected, AINT8, AINT8); + DEF_FACTORY_TWO_TYPE(OpFullyConnected, INT16, INT8); + break; + case Op_MATMUL: + DEF_FACTORY_ONE_TYPE(OpMatMul, FLOAT); + DEF_FACTORY_ONE_TYPE(OpMatMul, AINT8); + DEF_FACTORY_ONE_TYPE(OpMatMul, INT16); + break; + case Op_MAX_POOL2D: + DEF_FACTORY_ONE_TYPE(OpMaxPool2d, FLOAT); + DEF_FACTORY_ONE_TYPE(OpMaxPool2d, AINT8); + DEF_FACTORY_ONE_TYPE(OpMaxPool2d, INT16); + break; + case Op_TRANSPOSE_CONV2D: + DEF_FACTORY_TWO_TYPE(OpTransposeConv2d, FLOAT, FLOAT); + DEF_FACTORY_TWO_TYPE(OpTransposeConv2d, AINT8, INT4); + DEF_FACTORY_TWO_TYPE(OpTransposeConv2d, AINT8, INT8); + DEF_FACTORY_TWO_TYPE(OpTransposeConv2d, AINT8, AINT8); + DEF_FACTORY_TWO_TYPE(OpTransposeConv2d, INT16, INT8); + break; + + // activation_funcs + case Op_CLAMP: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpClamp, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpClamp, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpClamp, INT16); + break; + case Op_RELUN: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpReluN, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpReluN, INT32); + break; + case Op_SIGMOID: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSigmoid, FLOAT); + break; + case Op_TANH: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTanh, FLOAT); + break; + + // ewise_binary + case Op_ADD: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpAdd, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpAdd, INT32); + break; + case Op_ARITHMETIC_RIGHT_SHIFT: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpArithmeticRightShift, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpArithmeticRightShift, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpArithmeticRightShift, INT32); + break; + case Op_BITWISE_AND: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseAnd, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseAnd, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseAnd, INT32); + break; + case Op_BITWISE_OR: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseOr, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseOr, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseOr, INT32); + break; + case Op_BITWISE_XOR: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseXor, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseXor, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseXor, INT32); + break; + case Op_LOGICAL_AND: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalAnd, BOOL); + break; + case Op_LOGICAL_LEFT_SHIFT: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalLeftShift, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalLeftShift, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalLeftShift, INT32); + break; + case Op_LOGICAL_RIGHT_SHIFT: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalRightShift, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalRightShift, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalRightShift, INT32); + break; + case Op_LOGICAL_OR: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalOr, BOOL); + break; + case Op_LOGICAL_XOR: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalOr, BOOL); + break; + case Op_MAXIMUM: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpMaximum, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpMaximum, INT32); + break; + case Op_MINIMUM: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpMinimum, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpMinimum, INT32); + break; + case Op_MUL: + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpMul, FLOAT, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpMul, INT8, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpMul, INT16, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpMul, INT32, INT32); + break; + case Op_POW: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpPow, FLOAT); + break; + case Op_SUB: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSub, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSub, INT32); + break; + case Op_TABLE: + DEF_FACTORY_ONE_RANK_0_6(OpTable); + break; + + // ewise_unary + case Op_ABS: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpAbs, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpAbs, INT32); + break; + case Op_BITWISE_NOT: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseNot, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseNot, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpBitwiseNot, INT32); + break; + case Op_CEIL: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpCeil, FLOAT); + break; + case Op_CLZ: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpClz, INT32); + break; + case Op_EXP: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpExp, FLOAT); + break; + case Op_FLOOR: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpFloor, FLOAT); + break; + case Op_LOG: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLog, FLOAT); + break; + case Op_LOGICAL_NOT: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpLogicalNot, BOOL); + break; + case Op_NEGATE: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpNegate, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpNegate, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpNegate, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpNegate, INT32); + break; + case Op_RECIPROCAL: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpReciprocal, FLOAT); + break; + case Op_RSQRT: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpRsqrt, FLOAT); + break; + + // ewise_ternary + case Op_SELECT: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSelect, BOOL); + break; + + // comparison + case Op_EQUAL: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpEqual, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpEqual, INT32); + break; + case Op_GREATER: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpGreater, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpGreater, INT32); + break; + case Op_GREATER_EQUAL: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpGreaterEqual, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpGreaterEqual, INT32); + break; + + // reduction + case Op_REDUCE_ALL: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceAll, BOOL); + break; + case Op_REDUCE_ANY: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceAny, BOOL); + break; + case Op_REDUCE_MAX: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMax, FLOAT); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMax, AINT8); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMax, INT16); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMax, INT32); + break; + case Op_REDUCE_MIN: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMin, FLOAT); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMin, AINT8); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMin, INT16); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMin, INT32); + break; + case Op_REDUCE_PRODUCT: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceProduct, FLOAT); + break; + case Op_REDUCE_SUM: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceSum, FLOAT); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceSum, INT32); + break; + + // data layout + case Op_CONCAT: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, FLOAT); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, AINT8); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, INT8); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, INT16); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, INT32); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpConcat, BOOL); + break; + case Op_PAD: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, FLOAT); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, INT32); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, AINT8); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, INT8); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, INT16); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpPad, BOOL); + break; + case Op_RESHAPE: + DEF_FACTORY_RESHAPE(OpReshape, FLOAT); + DEF_FACTORY_RESHAPE(OpReshape, AINT8); + DEF_FACTORY_RESHAPE(OpReshape, INT8); + DEF_FACTORY_RESHAPE(OpReshape, INT16); + DEF_FACTORY_RESHAPE(OpReshape, INT32); + DEF_FACTORY_RESHAPE(OpReshape, BOOL); + break; + case Op_REVERSE: + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, FLOAT); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, AINT8); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, INT8); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, INT16); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, INT32); + DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OpReverse, BOOL); + break; + case Op_SLICE: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpSlice, BOOL); + break; + case Op_TILE: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTile, BOOL); + break; + case Op_TRANSPOSE: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, BOOL); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpTranspose, INT32); + break; + + // scatter_gather + case Op_GATHER: + { + // output.rank = input.rank - 1 + index.rank + int32_t index_rank = outputRank - inputRank + 1; + DEF_FACTORY_GATHER(OpGather, AINT8); + DEF_FACTORY_GATHER(OpGather, INT16); + DEF_FACTORY_GATHER(OpGather, INT32); + } + break; + + // image + case Op_RESIZE: + DEF_FACTORY_TWO_TYPE_RESIZE(OpResize, INT8, INT32); + DEF_FACTORY_TWO_TYPE_RESIZE(OpResize, INT8, INT8); + DEF_FACTORY_TWO_TYPE_RESIZE(OpResize, INT16, INT48); + DEF_FACTORY_TWO_TYPE_RESIZE(OpResize, INT16, INT16); + break; + + // data_nodes + case Op_CONST: + return new OpConst(id); + case Op_PLACEHOLDER: + return new OpPlaceholder(id); + case Op_IDENTITY: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentity, BOOL); + break; + case Op_IDENTITYN: + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OpIdentityN, BOOL); + break; + + // type_conversion + case Op_CAST: + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, BOOL, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, BOOL, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, BOOL, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT8, BOOL); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT8, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT8, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT8, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT16, BOOL); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT16, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT16, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT16, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT32, BOOL); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT32, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT32, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT32, FLOAT); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, FLOAT, INT8); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, FLOAT, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, FLOAT, INT32); + break; + case Op_RESCALE: + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, AINT8, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, AINT8, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, AINT8, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT16, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT16, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT16, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT32, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT32, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT32, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT48, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT48, INT16); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT48, INT32); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, UINT8, AINT8); + DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, AINT8, UINT8); + break; + + // custom + case Op_CUSTOM: + return new OpCustom(id); + + // control_flow + case Op_COND_IF: + return new OpCondIf(tsh, attribute, id); + case Op_WHILE_LOOP: + return new OpWhileLoop(tsh, attribute, id); + + // Ops not recognized + default: + goto done; + + } // End of switch(opType) + +done: + return nullptr; +} diff --git a/reference_model/src/ops/op_factory.h b/reference_model/src/ops/op_factory.h new file mode 100644 index 0000000..cde6841 --- /dev/null +++ b/reference_model/src/ops/op_factory.h @@ -0,0 +1,294 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_OP_FACTORY_H +#define OPS_OP_FACTORY_H + +#include "attribute.h" +#include "graph_node.h" +#include "quant_info.h" +#include "template_types.h" +#include "tosa_serialization_handler.h" + +#define DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, RANK, DTYPE) \ + case RANK: \ + return new OP<RANK, DType_##DTYPE>(attribute, qinfo, id); + +#define DEF_FACTORY_ONE_RANK_TWO_TYPE(OP, RANK, DTYPE1, DTYPE2) \ + case RANK: \ + return new OP<RANK, DType_##DTYPE1, DType_##DTYPE2>(attribute, qinfo, id); + +#define DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, RANK1, RANK2, DTYPE) \ + case RANK2: \ + return new OP<RANK1, RANK2, DType_##DTYPE>(attribute, qinfo, id); + +#define DEF_FACTORY_TWO_RANK_TWO_TYPE(OP, RANK1, RANK2, DTYPE1, DTYPE2) \ + case RANK2: \ + return new OP<RANK1, RANK2, DType_##DTYPE1, DType_##DTYPE2>(attribute, qinfo, id); + +#define DEF_FACTORY_ONE_RANK_0_6(OP) \ + switch (inputRank) \ + { \ + case 0: \ + return new OP<0>(attribute, qinfo, id); \ + case 1: \ + return new OP<1>(attribute, qinfo, id); \ + case 2: \ + return new OP<2>(attribute, qinfo, id); \ + case 3: \ + return new OP<3>(attribute, qinfo, id); \ + case 4: \ + return new OP<4>(attribute, qinfo, id); \ + case 5: \ + return new OP<5>(attribute, qinfo, id); \ + case 6: \ + return new OP<6>(attribute, qinfo, id); \ + } + +#define DEF_FACTORY_ONE_TYPE(OP, DTYPE) \ + if (inputDType == DType_##DTYPE) \ + { \ + return new OP<DType_##DTYPE>(attribute, qinfo, id); \ + } + +#define DEF_FACTORY_TWO_TYPE(OP, DTYPE1, DTYPE2) \ + if (inputDType == DType_##DTYPE1 && weightDType == DType_##DTYPE2) \ + { \ + return new OP<DType_##DTYPE1, DType_##DTYPE2>(attribute, qinfo, id); \ + } + +#define DEF_FACTORY_TWO_TYPE_RESIZE(OP, DTYPE1, DTYPE2) \ + if (inputDType == DType_##DTYPE1 && outputDType == DType_##DTYPE2) \ + { \ + return new OP<DType_##DTYPE1, DType_##DTYPE2>(attribute, qinfo, id); \ + } + +#define DEF_FACTORY_RANK0_6_ONE_RANK_ONE_TYPE(OP, DTYPE) \ + if (inputDType == DType_##DTYPE) \ + { \ + switch (inputRank) \ + { \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 0, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 1, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 2, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 3, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 4, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 5, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 6, DTYPE) \ + } \ + } + +#define DEF_FACTORY_RANK1_6_ONE_RANK_ONE_TYPE(OP, DTYPE) \ + if (inputDType == DType_##DTYPE) \ + { \ + switch (inputRank) \ + { \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 1, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 2, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 3, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 4, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 5, DTYPE) \ + DEF_FACTORY_ONE_RANK_ONE_TYPE(OP, 6, DTYPE) \ + } \ + } + +#define DEF_FACTORY_RANK0_6_ONE_RANK_TWO_TYPE(OP, DTYPE1, DTYPE2) \ + if (inputDType == DType_##DTYPE1 && outputDType == DType_##DTYPE2) \ + { \ + switch (inputRank) \ + { \ + DEF_FACTORY_ONE_RANK_TWO_TYPE(OP, 0, DTYPE1, DTYPE2) \ + DEF_FACTORY_ONE_RANK_TWO_TYPE(OP, 1, DTYPE1, DTYPE2) \ + DEF_FACTORY_ONE_RANK_TWO_TYPE(OP, 2, DTYPE1, DTYPE2) \ + DEF_FACTORY_ONE_RANK_TWO_TYPE(OP, 3, DTYPE1, DTYPE2) \ + DEF_FACTORY_ONE_RANK_TWO_TYPE(OP, 4, DTYPE1, DTYPE2) \ + DEF_FACTORY_ONE_RANK_TWO_TYPE(OP, 5, DTYPE1, DTYPE2) \ + DEF_FACTORY_ONE_RANK_TWO_TYPE(OP, 6, DTYPE1, DTYPE2) \ + } \ + } + +#define DEF_FACTORY_RESHAPE(OP, DTYPE) \ + if (inputDType == DType_##DTYPE && outputDType == DType_##DTYPE) \ + { \ + switch (inputRank) \ + { \ + case 0: \ + { \ + switch (outputRank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 0, 0, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 0, 1, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 0, 2, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 0, 3, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 0, 4, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 0, 5, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 0, 6, DTYPE) \ + } \ + } \ + case 1: \ + { \ + switch (outputRank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 0, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 1, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 2, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 3, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 4, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 5, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 6, DTYPE) \ + } \ + } \ + case 2: \ + { \ + switch (outputRank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 0, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 1, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 2, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 3, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 4, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 5, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 6, DTYPE) \ + } \ + } \ + case 3: \ + { \ + switch (outputRank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 0, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 1, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 2, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 3, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 4, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 5, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 6, DTYPE) \ + } \ + } \ + case 4: \ + { \ + switch (outputRank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 0, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 1, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 2, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 3, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 4, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 5, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 6, DTYPE) \ + } \ + } \ + case 5: \ + { \ + switch (outputRank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 5, 0, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 5, 1, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 5, 2, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 5, 3, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 5, 4, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 5, 5, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 5, 6, DTYPE) \ + } \ + } \ + case 6: \ + { \ + switch (outputRank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 6, 0, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 6, 1, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 6, 2, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 6, 3, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 6, 4, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 6, 5, DTYPE) \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 6, 6, DTYPE) \ + } \ + } \ + } \ + } + +#define DEF_FACTORY_GATHER(OP, DTYPE) \ + if (inputDType == DType_##DTYPE && outputDType == DType_##DTYPE) \ + { \ + switch (inputRank) \ + { \ + case 1: \ + switch (index_rank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 1, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 2, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 3, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 4, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 5, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 1, 6, DTYPE); \ + } \ + case 2: \ + switch (index_rank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 1, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 2, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 3, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 4, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 2, 5, DTYPE); \ + } \ + case 3: \ + switch (index_rank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 1, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 2, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 3, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 3, 4, DTYPE); \ + } \ + case 4: \ + switch (index_rank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 1, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 2, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 4, 3, DTYPE); \ + } \ + case 5: \ + switch (index_rank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 5, 1, DTYPE); \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 5, 2, DTYPE); \ + } \ + case 6: \ + switch (index_rank) \ + { \ + DEF_FACTORY_TWO_RANK_ONE_TYPE(OP, 6, 1, DTYPE); \ + } \ + } \ + } + +namespace TosaReference +{ + +class OpFactory +{ +public: + static GraphNode* newOp(tosa::TosaSerializationHandler* tsh, + tosa::Op opType, + tosa::TosaAttributeBase* attribute, + tosa::TosaQuantInfoBase* qinfo, + uint64_t id, + tosa::DType inputDType, + int inputRank, + tosa::DType outputDType, + int outputRank, + tosa::DType weightDType, + int weightRank); +}; +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/reduction.cc b/reference_model/src/ops/reduction.cc new file mode 100644 index 0000000..a2adfdb --- /dev/null +++ b/reference_model/src/ops/reduction.cc @@ -0,0 +1,139 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "reduction.h" +#include "quant_util.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int Rank, DType Dtype> +ReduceNode<Rank, Dtype>::ReduceNode(const Op& op_, TosaAttributeBase* attribute_, uint64_t id_) + : GraphNode(op_, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(0, 4); + + INIT_ATTRIBUTE(Axis); +} + +template <int Rank, DType Dtype> +ReduceNode<Rank, Dtype>::~ReduceNode() +{ + if (attribute) + delete attribute; +} + +template <int Rank, DType Dtype> +int ReduceNode<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + if (attribute->axis() < 0 || attribute->axis() >= inputs[0]->getRank()) + { + printNodeValidationError("Reduce axis must between [0, input_rank - 1]"); + return 1; + } + + if (inputs[0]->matchRank(*outputs[0])) + { + printNodeValidationError("Input and output tensor ranks must match"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + ASSERT_MEM(in && out); + + dims[0] = this->attribute->axis(); + + return 0; +} + +template <int Rank, DType Dtype> +int OpReduceAll<Rank, Dtype>::eval() +{ + this->out->getTensor() = this->in->getTensor().all(this->dims).reshape(this->out->getTensor().dimensions()); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +int OpReduceAny<Rank, Dtype>::eval() +{ + this->out->getTensor() = this->in->getTensor().any(this->dims).reshape(this->out->getTensor().dimensions()); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +int OpReduceMax<Rank, Dtype>::eval() +{ + this->out->getTensor() = this->in->getTensor().maximum(this->dims).reshape(this->out->getTensor().dimensions()); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +int OpReduceMin<Rank, Dtype>::eval() +{ + this->out->getTensor() = this->in->getTensor().minimum(this->dims).reshape(this->out->getTensor().dimensions()); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +int OpReduceProduct<Rank, Dtype>::eval() +{ + this->out->getTensor() = this->in->getTensor().prod(this->dims).reshape(this->out->getTensor().dimensions()); + + return GraphNode::eval(); +} + +template <int Rank, DType Dtype> +int OpReduceSum<Rank, Dtype>::eval() +{ + this->out->getTensor() = this->in->getTensor().sum(this->dims).reshape(this->out->getTensor().dimensions()); + + return GraphNode::eval(); +} + +// template explicit instantiation +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceAll, BOOL); + +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceAny, BOOL); + +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMax, FLOAT); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMax, AINT8); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMax, INT16); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMax, INT32); + +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMin, FLOAT); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMin, AINT8); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMin, INT16); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceMin, INT32); + +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceProduct, FLOAT); + +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceSum, FLOAT); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpReduceSum, INT32); diff --git a/reference_model/src/ops/reduction.h b/reference_model/src/ops/reduction.h new file mode 100644 index 0000000..cf75812 --- /dev/null +++ b/reference_model/src/ops/reduction.h @@ -0,0 +1,109 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_REDUCTION_H +#define OPS_REDUCTION_H + +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ + +template <int Rank, DType Dtype> +class ReduceNode : public GraphNode +{ +public: + ReduceNode(const Op& nodeType, TosaAttributeBase* attribute_, const uint64_t id_); + virtual ~ReduceNode(); + virtual int checkTensorAttributes(); + virtual int eval() = 0; + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + Eigen::array<int, 1> dims; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; + TosaAxisAttribute* attribute; +}; + +template <int Rank, DType Dtype> +class OpReduceAll : public ReduceNode<Rank, Dtype> +{ +public: + OpReduceAll(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : ReduceNode<Rank, Dtype>(Op_REDUCE_ALL, attribute_, id_) + {} + virtual int eval(); +}; + +template <int Rank, DType Dtype> +class OpReduceAny : public ReduceNode<Rank, Dtype> +{ +public: + OpReduceAny(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : ReduceNode<Rank, Dtype>(Op_REDUCE_ALL, attribute_, id_) + {} + virtual int eval(); +}; + +template <int Rank, DType Dtype> +class OpReduceMax : public ReduceNode<Rank, Dtype> +{ +public: + OpReduceMax(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : ReduceNode<Rank, Dtype>(Op_REDUCE_MAX, attribute_, id_) + {} + virtual int eval(); +}; + +template <int Rank, DType Dtype> +class OpReduceMin : public ReduceNode<Rank, Dtype> +{ +public: + OpReduceMin(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : ReduceNode<Rank, Dtype>(Op_REDUCE_MIN, attribute_, id_) + {} + virtual int eval(); +}; + +template <int Rank, DType Dtype> +class OpReduceProduct : public ReduceNode<Rank, Dtype> +{ +public: + OpReduceProduct(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : ReduceNode<Rank, Dtype>(Op_REDUCE_PRODUCT, attribute_, id_) + {} + virtual int eval(); +}; + +template <int Rank, DType Dtype> +class OpReduceSum : public ReduceNode<Rank, Dtype> +{ +public: + OpReduceSum(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : ReduceNode<Rank, Dtype>(Op_REDUCE_SUM, attribute_, id_) + {} + virtual int eval(); +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/scatter_gather.cc b/reference_model/src/ops/scatter_gather.cc new file mode 100644 index 0000000..c54204a --- /dev/null +++ b/reference_model/src/ops/scatter_gather.cc @@ -0,0 +1,120 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "scatter_gather.h" +#include "quant_util.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int InRank, int IndexRank, DType Dtype> +OpGather<InRank, IndexRank, Dtype>::OpGather(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_GATHER, id_) +{ + setRequiredOperands(2, 1); + setRequiredRank(1, 6); + + INIT_ATTRIBUTE(Axis); +} + +template <int InRank, int IndexRank, DType Dtype> +OpGather<InRank, IndexRank, Dtype>::~OpGather() +{ + if (attribute) + delete attribute; +} + +template <int InRank, int IndexRank, DType Dtype> +int OpGather<InRank, IndexRank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(inputs[1]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same types + if (inputs[0]->matchType(*outputs[0])) + { + printNodeValidationError("Failure to match input and output type"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + index = dynamic_cast<TosaReference::TensorTemplate<TIndex>*>(inputs[1]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + ASSERT_MEM(in && index && out); + + return 0; +} + +template <int InRank, int IndexRank, DType Dtype> +int OpGather<InRank, IndexRank, Dtype>::eval() +{ + int axis = attribute->axis(); + + // calculate size left and right to axis + int left_size = 1; + for (int i = 0; i < axis; ++i) + { + left_size *= in->getShape()[i]; + } + + int right_size = 1; + for (int i = axis + 1; i < in->getRank(); ++i) + { + right_size *= in->getShape()[i]; + } + + InEigenType* input_data = in->getTensor().data(); + int32_t* index_data = index->getTensor().data(); + OutEigenType* output_data = out->getTensor().data(); + + int32_t axis_size = in->getShape()[axis]; + int32_t index_count = index->getElementCount(); + + // sanity check if index is valid + // need to check until this point since index is not known until runtime + for (size_t i = 0; i < index->getElementCount(); i++) + { + if (index_data[i] >= axis_size) + { + FATAL_ERROR_NODE("OpGather: index[%lu]=%i can't exceed axis_size=%i", i, index_data[i], axis_size); + } + } + + // Eigen stores tensor in column-major + // so we iterate through dimension right to axis and the index array + // do memory copy with size of left size each time + for (int right = 0; right < right_size; ++right) + { + for (int i = 0; i < index_count; ++i) + { + std::memcpy(output_data + (right * index_count + i) * left_size, + input_data + (right * axis_size + index_data[i]) * left_size, sizeof(InEigenType) * left_size); + } + } + + return GraphNode::eval(); +} + +// template explicit instantiation +DEF_INSTANTIATE_GATHER(OpGather, AINT8); +DEF_INSTANTIATE_GATHER(OpGather, INT16); +DEF_INSTANTIATE_GATHER(OpGather, INT32); diff --git a/reference_model/src/ops/scatter_gather.h b/reference_model/src/ops/scatter_gather.h new file mode 100644 index 0000000..d9b1263 --- /dev/null +++ b/reference_model/src/ops/scatter_gather.h @@ -0,0 +1,54 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_SCATTER_GATHER_H +#define OPS_SCATTER_GATHER_H + +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ + +// input and index can have different rank +// and infer OutRank statically +template <int InRank, int IndexRank, DType Dtype> +class OpGather : public GraphNode +{ +public: + OpGather(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpGather(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + static constexpr int OutRank = InRank - 1 + IndexRank; + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, InRank>; + using TIndex = Eigen::Tensor<int32_t, IndexRank>; + using TOut = Eigen::Tensor<OutEigenType, OutRank>; + +protected: + TosaAxisAttribute* attribute; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TIndex>* index; + TosaReference::TensorTemplate<TOut>* out; +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/template_types.h b/reference_model/src/ops/template_types.h new file mode 100644 index 0000000..1859e03 --- /dev/null +++ b/reference_model/src/ops/template_types.h @@ -0,0 +1,277 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OP_TEMPLATE_TYPES_H +#define OP_TEMPLATE_TYPES_H + +#include "tosa_generated.h" +#include <Eigen/CXX11/Tensor> + +using namespace tosa; + +namespace TosaReference +{ +// Shorter aliase templates for common Eigen::Tensor types +template <typename T> +using ETensor0 = Eigen::Tensor<T, 0>; +template <typename T> +using ETensor1 = Eigen::Tensor<T, 1>; +template <typename T> +using ETensor2 = Eigen::Tensor<T, 2>; +template <typename T> +using ETensor3 = Eigen::Tensor<T, 3>; +template <typename T> +using ETensor4 = Eigen::Tensor<T, 4>; +template <typename T> +using ETensor5 = Eigen::Tensor<T, 5>; +template <typename T> +using ETensor6 = Eigen::Tensor<T, 6>; + +// Forward declaration +template <class T> +class TensorTemplate; + +// Shortcut to hide the TensorTemplate class. +// For example, declare Tensor1<float> to get a TensorTemplate +// with an Eigen::Tensor<float, 1> +template <typename T> +using Tensor0 = TensorTemplate<ETensor0<T>>; +template <typename T> +using Tensor1 = TensorTemplate<ETensor1<T>>; +template <typename T> +using Tensor2 = TensorTemplate<ETensor2<T>>; +template <typename T> +using Tensor3 = TensorTemplate<ETensor3<T>>; +template <typename T> +using Tensor4 = TensorTemplate<ETensor4<T>>; +template <typename T> +using Tensor5 = TensorTemplate<ETensor5<T>>; +template <typename T> +using Tensor6 = TensorTemplate<ETensor6<T>>; + +template <DType type> +struct GetEigenType; +template <> +struct GetEigenType<DType_FLOAT> +{ + using type = float; +}; +template <> +struct GetEigenType<DType_INT32> +{ + using type = int32_t; +}; +template <> +struct GetEigenType<DType_INT48> +{ + using type = int64_t; +}; +template <> +struct GetEigenType<DType_BOOL> +{ + using type = bool; +}; +template <> +struct GetEigenType<DType_AINT8> +{ + using type = int32_t; +}; +template <> +struct GetEigenType<DType_UINT8> +{ + using type = int32_t; +}; +template <> +struct GetEigenType<DType_INT4> +{ + using type = int32_t; +}; +template <> +struct GetEigenType<DType_INT8> +{ + using type = int32_t; +}; +template <> +struct GetEigenType<DType_INT16> +{ + using type = int32_t; +}; + +// Meta function to get number of bits +template <DType T> +struct GetNumBits +{ + static constexpr int32_t value = 0; +}; +template <> +struct GetNumBits<DType_BOOL> +{ + static constexpr int32_t value = 1; +}; +template <> +struct GetNumBits<DType_AINT8> +{ + static constexpr int32_t value = 8; +}; +template <> +struct GetNumBits<DType_UINT8> +{ + static constexpr int32_t value = 8; +}; +template <> +struct GetNumBits<DType_INT4> +{ + static constexpr int32_t value = 4; +}; +template <> +struct GetNumBits<DType_INT8> +{ + static constexpr int32_t value = 8; +}; +template <> +struct GetNumBits<DType_INT16> +{ + static constexpr int32_t value = 16; +}; +template <> +struct GetNumBits<DType_INT32> +{ + static constexpr int32_t value = 32; +}; +template <> +struct GetNumBits<DType_INT48> +{ + static constexpr int32_t value = 48; +}; + +// Meta function to get quantized min/max in compile time +template <DType T> +struct GetQMin +{ + static constexpr int64_t value = 0L; +}; +template <> +struct GetQMin<DType_AINT8> +{ + static constexpr int64_t value = -128L; +}; +template <> +struct GetQMin<DType_UINT8> +{ + static constexpr int64_t value = 0L; +}; +template <> +struct GetQMin<DType_INT4> +{ + static constexpr int64_t value = -8L; +}; +template <> +struct GetQMin<DType_INT8> +{ + static constexpr int64_t value = -128L; +}; +template <> +struct GetQMin<DType_INT16> +{ + static constexpr int64_t value = -32768L; +}; +template <> +struct GetQMin<DType_INT32> +{ + static constexpr int64_t value = -(1L << 31); +}; +template <> +struct GetQMin<DType_INT48> +{ + static constexpr int64_t value = -(1L << 47); +}; + +template <DType T> +struct GetQMax +{ + static constexpr int64_t value = 0L; +}; +template <> +struct GetQMax<DType_AINT8> +{ + static constexpr int64_t value = 127L; +}; +template <> +struct GetQMax<DType_UINT8> +{ + static constexpr int64_t value = 255L; +}; +template <> +struct GetQMax<DType_INT4> +{ + static constexpr int64_t value = 7L; +}; +template <> +struct GetQMax<DType_INT8> +{ + static constexpr int64_t value = 127L; +}; +template <> +struct GetQMax<DType_INT16> +{ + static constexpr int64_t value = 32767L; +}; +template <> +struct GetQMax<DType_INT32> +{ + static constexpr int64_t value = (1L << 31) - 1; +}; +template <> +struct GetQMax<DType_INT48> +{ + static constexpr int64_t value = (1L << 47) - 1; +}; + +template <DType TIn1, DType TIn2> +struct GetAccDType; +template <> +struct GetAccDType<DType_AINT8, DType_AINT8> +{ + static constexpr DType value = DType_INT32; +}; +template <> +struct GetAccDType<DType_AINT8, DType_INT4> +{ + static constexpr DType value = DType_INT32; +}; +template <> +struct GetAccDType<DType_AINT8, DType_INT8> +{ + static constexpr DType value = DType_INT32; +}; +template <> +struct GetAccDType<DType_INT16, DType_INT8> +{ + static constexpr DType value = DType_INT48; +}; +template <> +struct GetAccDType<DType_INT16, DType_INT16> +{ + static constexpr DType value = DType_INT48; +}; +template <> +struct GetAccDType<DType_FLOAT, DType_FLOAT> +{ + static constexpr DType value = DType_FLOAT; +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/tensor_ops.cc b/reference_model/src/ops/tensor_ops.cc new file mode 100644 index 0000000..a735334 --- /dev/null +++ b/reference_model/src/ops/tensor_ops.cc @@ -0,0 +1,1229 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "tensor_ops.h" +#include "quant_util.h" +#include "template_types.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int Rank, DType Dtype> +OpArgMax<Rank, Dtype>::OpArgMax(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_ARGMAX, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(0, 6); + + INIT_ATTRIBUTE(Axis); +} + +template <int Rank, DType Dtype> +OpArgMax<Rank, Dtype>::~OpArgMax() +{ + if (attribute) + delete attribute; +} + +template <int Rank, DType Dtype> +int OpArgMax<Rank, Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + input = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + output = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + return 0; +} + +template <int Rank, DType Dtype> +int OpArgMax<Rank, Dtype>::eval() +{ + Eigen::Tensor<DenseIndex, Rank - 1> index = this->input->getTensor().argmax(attribute->axis()); + + this->output->getTensor() = index.unaryExpr([](DenseIndex in) -> OutEigenType { return (OutEigenType)in; }); + + return GraphNode::eval(); +} + +template <DType Dtype> +OpAvgPool2d<Dtype>::OpAvgPool2d(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_AVG_POOL2D, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(4); + + INIT_ATTRIBUTE(Pool2d); + INIT_QINFO(Unary); +} + +template <DType Dtype> +OpAvgPool2d<Dtype>::~OpAvgPool2d() +{ + if (attribute) + delete attribute; +} + +template <DType Dtype> +int OpAvgPool2d<Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + if (inputs[0]->matchType(*outputs[0])) + { + printNodeValidationError("OpAvgPool2d: input and output tensor type mismatch"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + if (!in->hasFormat(Format_NHWC)) + { + printNodeValidationError("OpAvgPool2d: unsupported tensor format"); + return 1; + } + + if (attribute->padding().size() != 4) + { + printNodeValidationError("OpAvgPool2d: illegal size for attribute padding"); + return 1; + } + + if (attribute->kernel().size() != 2) + { + printNodeValidationError("OpAvgPool2d: illegal size for attribute kernel"); + return 1; + } + + if (attribute->stride().size() != 2) + { + printNodeValidationError("OpAvgPool2d: illegal size for attribute stride"); + return 1; + } + + return 0; +} + +template <DType Dtype> +ETensor1<int32_t> OpAvgPool2d<Dtype>::calculate_div_map_1d(int in_size, int out_size, int kernel_size, int stride) +{ + ETensor1<int32_t> result(out_size); + + int32_t total_pad = (out_size - 1) * stride + kernel_size - in_size; + total_pad = total_pad < 0 ? 0 : total_pad; + + int32_t pad_left = total_pad >> 1; + int32_t pad_right = total_pad - pad_left; + + result.setConstant(kernel_size); + + // the index left to 'left_index' and index right to 'right_index' indicates + // the input window of this output covers a pad bit + int32_t left_index = pad_left / stride; + int32_t right_index = pad_right / stride; + + // not handle ultra small activation yet + ASSERT_MSG_NODE((out_size - 1 - right_index) >= left_index, "AvgPool2d: Small activations not supported yet"); + + // minus the number of pad bit this index cover + while (left_index >= 0) + { + result(left_index) -= (pad_left - left_index * stride); + left_index--; + } + + while (right_index >= 0) + { + result(out_size - 1 - right_index) -= (pad_right - right_index * stride); + right_index--; + } + + return result; +} + +// assuming input and output tensor have same scales like tflite reference +// so no need to scale input and output +template <DType Dtype> +int OpAvgPool2d<Dtype>::eval() +{ + int in_batch = this->in->getShape()[0]; + int in_height = this->in->getShape()[1]; + int in_width = this->in->getShape()[2]; + int in_channels = this->in->getShape()[3]; + + int out_batch = this->out->getShape()[0]; + int out_height = this->out->getShape()[1]; + int out_width = this->out->getShape()[2]; + int out_channels = this->out->getShape()[3]; + + ASSERT_MSG_NODE(in_batch == out_batch, "OpAvgPool2d: tensor batch mismatch %d != %d", in_batch, out_batch); + + int padding_top = this->attribute->padding()[0]; + int padding_bottom = this->attribute->padding()[1]; + int padding_left = this->attribute->padding()[2]; + int padding_right = this->attribute->padding()[3]; + int kernel_h = this->attribute->kernel()[0]; + int kernel_w = this->attribute->kernel()[1]; + int stride_h = this->attribute->stride()[0]; + int stride_w = this->attribute->stride()[1]; + + DEBUG_INFO(OP, + "perform AvgPool2d, input.shape=[%d,%d,%d,%d], output.shape=[%d,%d,%d,%d], kernel=[%d,%d], " + "stride=[%d,%d], padding=[%d,%d,%d,%d]", + in_batch, in_height, in_width, in_channels, out_batch, out_height, out_width, out_channels, kernel_h, + kernel_w, stride_h, stride_w, padding_top, padding_bottom, padding_left, padding_right); + + Eigen::array<Eigen::Index, 2> im2col_input_dims; + im2col_input_dims[0] = kernel_h * kernel_w; + im2col_input_dims[1] = out_batch * out_height * out_width * out_channels; + + Eigen::array<Eigen::Index, 4> col2im_output_dims; + col2im_output_dims[0] = out_batch; + col2im_output_dims[1] = out_height; + col2im_output_dims[2] = out_width; + col2im_output_dims[3] = out_channels; + + Eigen::array<std::pair<int32_t, int32_t>, 4> padding; + padding[0] = std::make_pair(0, 0); + padding[1] = std::make_pair(padding_top, padding_bottom); + padding[2] = std::make_pair(padding_left, padding_right); + padding[3] = std::make_pair(0, 0); + + ETensor4<InEigenType> input_val = this->in->getTensor(); + if (this->qinfo) + { + input_val = input_val - (InEigenType)this->qinfo->input_zp(); + } + + ETensor4<InEigenType> input_padded = input_val.pad(padding); + + // assuming input and output have same scales + // so input and output scaling is not required + // TODO: check if this assumption TOSA made + + // extract_image_patches() output [N, KH, KW, H * W, C] + // transpose to [KH, KW, N, H * W, C] + // reshape to [KH * KW, N * H * W * C] + ETensor2<InEigenType> input_extract_patches = + input_padded.extract_image_patches(kernel_h, kernel_w, stride_h, stride_w, 1, 1, Eigen::PADDING_VALID) + .shuffle(Eigen::array<Eigen::Index, 5>{ 1, 2, 0, 3, 4 }) + .reshape(im2col_input_dims); + + // 1D result with [N * H * W * C] + ETensor1<AccEigenType> out_1d(this->out->getElementCount()); + out_1d.setZero(); + + // sum pool + for (size_t i = 0; i < this->out->getElementCount(); i++) + { + for (int32_t j = 0; j < kernel_h * kernel_w; j++) + { + out_1d(i) += (AccEigenType)input_extract_patches(j, i); + } + } + + // reshape result to [N, H, W, C] and divide with div_map + ETensor4<AccEigenType> sum = out_1d.reshape(col2im_output_dims); + + // calculate 1d height/width div_map (number of elements this pooling window covers) + // and outer product to get 2d div_map, then reshape/broadcast to [N, H, W, C] + ETensor1<int32_t> div_map_h = calculate_div_map_1d(in_height, out_height, kernel_h, stride_h); + ETensor1<int32_t> div_map_w = calculate_div_map_1d(in_width, out_width, kernel_w, stride_w); + Eigen::array<Eigen::IndexPair<Eigen::Index>, 1> contract_dims = { Eigen::IndexPair<Eigen::Index>(1, 0) }; + Eigen::array<Eigen::Index, 4> bcast{ out_batch, 1, 1, out_channels }; + + ETensor4<int32_t> div_map = + div_map_h.reshape(Eigen::array<Eigen::Index, 2>{ out_height, 1 }) + .contract(div_map_w.reshape(Eigen::array<Eigen::Index, 2>{ 1, out_width }), contract_dims) + .reshape(Eigen::array<Eigen::Index, 4>{ 1, out_height, out_width, 1 }) + .broadcast(bcast); + + if (Dtype != DType_FLOAT) + { + this->out->getTensor() = sum.binaryExpr(div_map, [](AccEigenType value, int32_t div) -> OutEigenType { + int32_t multiplier, shift; + TosaReference::QuantUtil<AccDtype>::reciprocal_scale(div, multiplier, shift); + + return (OutEigenType)TosaReference::QuantUtil<AccDtype>::apply_scale(value, multiplier, shift, false); + }); + this->out->getTensor() = this->out->getTensor() + (OutEigenType)(this->qinfo->output_zp()); + this->out->getTensor() = this->out->getTensor().cwiseMax((OutEigenType)QMin); + this->out->getTensor() = this->out->getTensor().cwiseMin((OutEigenType)QMax); + } + else + { + this->out->getTensor() = (sum / div_map.template cast<AccEigenType>()).template cast<OutEigenType>(); + } + + return GraphNode::eval(); +} + +template <DType InDtype, DType WeightDtype> +OpConv2d<InDtype, WeightDtype>::OpConv2d(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_CONV2D, id_) +{ + setRequiredOperands(3, 1); + setRequiredRank(4); + + INIT_ATTRIBUTE(Conv2d); + INIT_QINFO(Conv); +} + +template <DType InDtype, DType WeightDtype> +OpConv2d<InDtype, WeightDtype>::~OpConv2d() +{ + if (attribute) + delete attribute; + if (qinfo) + delete qinfo; +} + +template <DType InDtype, DType WeightDtype> +int OpConv2d<InDtype, WeightDtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(inputs[1]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // 'bias' checked separatedly since it doens't make sense to make required rank ranging from 1 to 4 + if (inputs[2]->getRank() != 1) + { + printNodeValidationError("OpConv2d: bias tensor must be rank 1"); + } + + if (inputs[1]->getIsConst() == 0) + { + printNodeValidationError("OpConv2d: weight tensor is not const typed"); + } + + input = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + weight = dynamic_cast<TosaReference::TensorTemplate<TWeight>*>(inputs[1]); + bias = dynamic_cast<TosaReference::TensorTemplate<TBias>*>(inputs[2]); + output = dynamic_cast<TosaReference::TensorTemplate<TAcc>*>(outputs[0]); + + if (!input->hasFormat(Format_NHWC)) + { + printNodeValidationError("OpConv2d: unsupported input tensor format"); + return 1; + } + + if (!weight->hasFormat(Format_OHWI)) + { + printNodeValidationError("OpConv2d: unsupported weight tensor format"); + return 1; + } + + if (attribute->padding().size() != 4) + { + printNodeValidationError("OpConv2d: illegal size for attribute padding"); + return 1; + } + + if (attribute->stride().size() != 2) + { + printNodeValidationError("OpConv2d: illegal size for attribute stride"); + return 1; + } + + if (attribute->dilation().size() != 2) + { + printNodeValidationError("OpConv2d: illegal size for attribute dilation"); + return 1; + } + + return 0; +} + +template <DType InDtype, DType WeightDtype> +int OpConv2d<InDtype, WeightDtype>::eval() +{ + int in_batch = this->input->getShape()[0]; + int in_height = this->input->getShape()[1]; + int in_width = this->input->getShape()[2]; + int in_channels = this->input->getShape()[3]; + + int f_out_channels = this->weight->getShape()[0]; + int f_height = this->weight->getShape()[1]; + int f_width = this->weight->getShape()[2]; + int f_in_channels = this->weight->getShape()[3]; + + int b_out_channels = this->bias->getShape()[0]; + + int out_batch = this->output->getShape()[0]; + int out_height = this->output->getShape()[1]; + int out_width = this->output->getShape()[2]; + int out_channels = this->output->getShape()[3]; + + ASSERT_MSG_NODE(in_batch == out_batch, "OpConv2d: tensor batch mismatch %d != %d", in_batch, out_batch); + ASSERT_MSG_NODE(f_in_channels == in_channels, "OpConv2d: tensor input channel mismatch %d != %d", f_in_channels, + in_channels); + ASSERT_MSG_NODE(f_out_channels == out_channels, "OpConv2d: tensor output channel mismatch %d != %d", f_out_channels, + out_channels); + ASSERT_MSG_NODE(b_out_channels == out_channels, "OpConv2d: tensor output channel mismatch %d != %d", b_out_channels, + out_channels); + + int padding_top = this->attribute->padding()[0]; + int padding_bottom = this->attribute->padding()[1]; + int padding_left = this->attribute->padding()[2]; + int padding_right = this->attribute->padding()[3]; + int stride_h = this->attribute->stride()[0]; + int stride_w = this->attribute->stride()[1]; + int dilation_h = this->attribute->dilation()[0]; + int dilation_w = this->attribute->dilation()[1]; + + DEBUG_INFO(OP, + "perform OpConv2d, input.shape=[%d,%d,%d,%d], weight.shape=[%d,%d,%d,%d], output.shape=[%d,%d,%d,%d], " + "stride=[%d,%d], dilation=[%d,%d], padding=[%d,%d,%d,%d]", + in_batch, in_height, in_width, in_channels, f_height, f_width, f_in_channels, f_out_channels, out_batch, + out_height, out_width, out_channels, stride_h, stride_w, dilation_h, dilation_w, padding_top, + padding_bottom, padding_left, padding_right); + + // GEMM-conv2d, left matrix is input, right matrix is weight + Eigen::array<Eigen::Index, 2> im2col_input_dims; + im2col_input_dims[0] = out_batch * out_height * out_width; + im2col_input_dims[1] = f_height * f_width * f_in_channels; + + Eigen::array<Eigen::Index, 2> im2col_weight_dims; + im2col_weight_dims[0] = f_height * f_width * f_in_channels; + im2col_weight_dims[1] = f_out_channels; + + Eigen::array<Eigen::Index, 2> bias_reshaped_dims; + bias_reshaped_dims[0] = 1; + bias_reshaped_dims[1] = b_out_channels; + + Eigen::array<Eigen::Index, 4> weight_zp_bcast_dims; + weight_zp_bcast_dims[0] = f_height; + weight_zp_bcast_dims[1] = f_width; + weight_zp_bcast_dims[2] = f_in_channels; + + Eigen::array<Eigen::Index, 2> bias_bcast_dims; + bias_bcast_dims[0] = out_batch * out_height * out_width; + bias_bcast_dims[1] = 1; + + Eigen::array<Eigen::Index, 4> col2im_output_dims; + col2im_output_dims[0] = out_batch; + col2im_output_dims[1] = out_height; + col2im_output_dims[2] = out_width; + col2im_output_dims[3] = out_channels; + + Eigen::array<Eigen::IndexPair<Eigen::Index>, 1> contract_dims = { Eigen::IndexPair<Eigen::Index>(1, 0) }; + + Eigen::array<std::pair<int32_t, int32_t>, 4> padding; + padding[0] = std::make_pair(0, 0); + padding[1] = std::make_pair(padding_top, padding_bottom); + padding[2] = std::make_pair(padding_left, padding_right); + padding[3] = std::make_pair(0, 0); + + TIn input_val = this->input->getTensor(); + TWeight weight_val = this->weight->getTensor(); + if (this->qinfo) + { + input_val = input_val - (InEigenType)this->qinfo->input_zp(); + weight_val = weight_val - (WeightEigenType)this->qinfo->weight_zp(); + } + + ETensor4<InEigenType> input_padded = input_val.pad(padding); + + // extract_image_patches() output [N, KH, KW, H * W, C] + // need to transpose to [N, H * W, KH, KW, C] + ETensor5<InEigenType> input_extract_patches = + input_padded + .extract_image_patches(f_height, f_width, stride_h, stride_w, dilation_h, dilation_w, Eigen::PADDING_VALID) + .shuffle(Eigen::array<Eigen::Index, 5>{ 0, 3, 1, 2, 4 }); + + // reshape input to [N * H * W, KH * KW * C] + ETensor2<InEigenType> im2col_input = input_extract_patches.reshape(im2col_input_dims); + + // transpose and reshape weight from [OC, H, W, IC] to [H * W * IC, OC] + ETensor2<WeightEigenType> im2col_weight = + weight_val.shuffle(Eigen::array<Eigen::Index, 4>({ 1, 2, 3, 0 })).reshape(im2col_weight_dims); + + // don't need to apply bias_multiplier ( * bias_scale and >> bias_shift) since tflite already scale it + // and reshaped from [C] to [1, C], and broadcast to [N * H * W, C] + ETensor2<AccEigenType> bias_2d = this->bias->getTensor().reshape(bias_reshaped_dims).broadcast(bias_bcast_dims); + + // output matrix is [N * H * W, C] + ETensor2<AccEigenType> contracted_result = + im2col_input.template cast<AccEigenType>().contract(im2col_weight.template cast<AccEigenType>(), contract_dims); + + // adding bias + ETensor2<AccEigenType> biased_output = contracted_result + bias_2d.template cast<AccEigenType>(); + + // reshape back to [N, H, W, C] + this->output->getTensor() = biased_output.reshape(col2im_output_dims); + + if (AccDtype == DType_INT48) + { + this->output->getTensor() = this->output->getTensor().cwiseMax((AccEigenType)AccQMin); + this->output->getTensor() = this->output->getTensor().cwiseMin((AccEigenType)AccQMax); + } + + return GraphNode::eval(); +} + +template <DType InDtype, DType WeightDtype> +OpDepthwiseConv2d<InDtype, WeightDtype>::OpDepthwiseConv2d(TosaAttributeBase* attribute_, + TosaQuantInfoBase* qinfo_, + uint64_t id_) + : GraphNode(Op_DEPTHWISE_CONV2D, id_) +{ + setRequiredOperands(3, 1); + setRequiredRank(4); + + INIT_ATTRIBUTE(Conv2d); + INIT_QINFO(Conv); +} + +template <DType InDtype, DType WeightDtype> +OpDepthwiseConv2d<InDtype, WeightDtype>::~OpDepthwiseConv2d() +{ + if (attribute) + delete attribute; + if (qinfo) + delete qinfo; +} + +template <DType InDtype, DType WeightDtype> +int OpDepthwiseConv2d<InDtype, WeightDtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(inputs[1]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // 'bias' checked separatedly since it doens't make sense to make required rank ranging from 1 to 4 + if (inputs[2]->getRank() != 1) + { + printNodeValidationError("OpDepthwiseConv2d: bias tensor must be rank 1"); + } + + if (inputs[1]->getIsConst() == 0) + { + printNodeValidationError("OpDepthwiseConv2d: weight tensor is not const typed"); + } + + input = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + weight = dynamic_cast<TosaReference::TensorTemplate<TWeight>*>(inputs[1]); + bias = dynamic_cast<TosaReference::TensorTemplate<TBias>*>(inputs[2]); + output = dynamic_cast<TosaReference::TensorTemplate<TAcc>*>(outputs[0]); + + if (!input->hasFormat(Format_NHWC)) + { + printNodeValidationError("OpDepthwiseConv2d: unsupported input tensor format"); + return 1; + } + + if (!weight->hasFormat(Format_HWIM)) + { + printNodeValidationError("OpDepthwiseConv2d: unsupported weight tensor format"); + return 1; + } + + if (attribute->padding().size() != 4) + { + printNodeValidationError("OpDepthwiseConv2d: illegal size for attribute padding"); + return 1; + } + + if (attribute->stride().size() != 2) + { + printNodeValidationError("OpDepthwiseConv2d: illegal size for attribute stride"); + return 1; + } + + if (attribute->dilation().size() != 2) + { + printNodeValidationError("OpDepthwiseConv2d: illegal size for attribute dilation"); + return 1; + } + + return 0; +} + +template <DType InDtype, DType WeightDtype> +int OpDepthwiseConv2d<InDtype, WeightDtype>::eval() +{ + int in_batch = this->input->getShape()[0]; + int in_height = this->input->getShape()[1]; + int in_width = this->input->getShape()[2]; + int in_channels = this->input->getShape()[3]; + + int f_height = this->weight->getShape()[0]; + int f_width = this->weight->getShape()[1]; + int f_in_channels = this->weight->getShape()[2]; + int f_multiplier = this->weight->getShape()[3]; + + int b_out_channels = this->bias->getShape()[0]; + + int out_batch = this->output->getShape()[0]; + int out_height = this->output->getShape()[1]; + int out_width = this->output->getShape()[2]; + int out_channels = this->output->getShape()[3]; + + ASSERT_MSG_NODE(in_batch == out_batch, "OpDepthwiseConv2d: tensor batch mismatch %d != %d", in_batch, out_batch); + ASSERT_MSG_NODE(f_in_channels == in_channels, "OpDepthwiseConv2d: tensor input channel mismatch %d != %d", + f_in_channels, in_channels); + ASSERT_MSG_NODE(in_channels * f_multiplier == out_channels, + "OpDepthwiseConv2d: tensor output channel mismatch %d != %d", in_channels * f_multiplier, + out_channels); + ASSERT_MSG_NODE(b_out_channels == out_channels, "OpDepthwiseConv2d: tensor b_out_channels mismatch %d != %d", + b_out_channels, out_channels); + + int padding_top = this->attribute->padding()[0]; + int padding_bottom = this->attribute->padding()[1]; + int padding_left = this->attribute->padding()[2]; + int padding_right = this->attribute->padding()[3]; + int stride_h = this->attribute->stride()[0]; + int stride_w = this->attribute->stride()[1]; + int dilation_h = this->attribute->dilation()[0]; + int dilation_w = this->attribute->dilation()[1]; + + DEBUG_INFO(OP, + "perform OpDepthwiseConv2d, input.shape=[%d,%d,%d,%d], weight.shape=[%d,%d,%d,%d], " + "output.shape=[%d,%d,%d,%d], stride=[%d,%d], dilation=[%d,%d], padding=[%d,%d,%d,%d]", + in_batch, in_height, in_width, in_channels, f_height, f_width, f_in_channels, f_multiplier, out_batch, + out_height, out_width, out_channels, stride_h, stride_w, dilation_h, dilation_w, padding_top, + padding_bottom, padding_left, padding_right); + + Eigen::array<std::pair<int32_t, int32_t>, 4> padding; + padding[0] = std::make_pair(0, 0); + padding[1] = std::make_pair(padding_top, padding_bottom); + padding[2] = std::make_pair(padding_left, padding_right); + padding[3] = std::make_pair(0, 0); + + TIn input_val = this->input->getTensor(); + TWeight weight_val = this->weight->getTensor(); + if (this->qinfo) + { + input_val = input_val - (InEigenType)this->qinfo->input_zp(); + weight_val = weight_val - (WeightEigenType)this->qinfo->weight_zp(); + } + + ETensor4<InEigenType> input_padded = input_val.pad(padding); + + // GEMM doesn't fit well with DepthwiseConv2d + // 1. use extract_image_patches() to handle stride/dilation/padding + // 2. perform direct convolution + + // 1. extract_image_patches() output [N, KH, KW, OH * OW, IC] + ETensor5<InEigenType> input_extract_patches = input_padded.extract_image_patches( + f_height, f_width, stride_h, stride_w, dilation_h, dilation_w, Eigen::PADDING_VALID); + + Eigen::array<Eigen::Index, 4> reshape_dim; + reshape_dim.fill(1); + reshape_dim[3] = b_out_channels; + + Eigen::array<Eigen::Index, 4> bcast; + bcast[0] = out_batch; + bcast[1] = out_height; + bcast[2] = out_width; + bcast[3] = 1; + + // initialize with bias + this->output->getTensor() = this->bias->getTensor().reshape(reshape_dim).broadcast(bcast); + + // 2. direct depthwise convolution + for (int ob = 0; ob < out_batch; ob++) + { + for (int oh = 0; oh < out_height; oh++) + { + for (int ow = 0; ow < out_width; ow++) + { + for (int ic = 0; ic < in_channels; ic++) + { + for (int cm = 0; cm < f_multiplier; cm++) + { + for (int fh = 0; fh < f_height; fh++) + { + for (int fw = 0; fw < f_width; fw++) + { + this->output->getTensor()(ob, oh, ow, ic * f_multiplier + cm) += + ((AccEigenType)input_extract_patches(ob, fh, fw, ow * out_height + oh, ic) * + (AccEigenType)weight_val(fh, fw, ic, cm)); + } + } + } + } + } + } + } + + if (AccDtype == DType_INT48) + { + this->output->getTensor() = this->output->getTensor().cwiseMax((AccEigenType)AccQMin); + this->output->getTensor() = this->output->getTensor().cwiseMin((AccEigenType)AccQMax); + } + + return GraphNode::eval(); +} + +template <DType InDtype, DType WeightDtype> +OpFullyConnected<InDtype, WeightDtype>::OpFullyConnected(TosaAttributeBase* attribute_, + TosaQuantInfoBase* qinfo_, + uint64_t id_) + : GraphNode(Op_FULLY_CONNECTED, id_) +{ + setRequiredOperands(3, 1); + setRequiredRank(2); + + INIT_QINFO(Conv); +} + +template <DType InDtype, DType WeightDtype> +OpFullyConnected<InDtype, WeightDtype>::~OpFullyConnected() +{ + if (qinfo) + delete qinfo; +} + +template <DType InDtype, DType WeightDtype> +int OpFullyConnected<InDtype, WeightDtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(inputs[1]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + input = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + weight = dynamic_cast<TosaReference::TensorTemplate<TWeight>*>(inputs[1]); + bias = dynamic_cast<TosaReference::TensorTemplate<TBias>*>(inputs[2]); + + if (input->getShape()[1] != weight->getShape()[1]) + { + printNodeValidationError("OpFullyConnected operator input.shape[1] should match weight.shape[1]"); + return 1; + } + + if (weight->getShape()[0] != bias->getShape()[0]) + { + printNodeValidationError("OpFullyConnected operator bias.shape[0] should match weight.shape[0]"); + return 1; + } + + output = dynamic_cast<TosaReference::TensorTemplate<TAcc>*>(outputs[0]); + + return 0; +} + +template <DType InDtype, DType WeightDtype> +int OpFullyConnected<InDtype, WeightDtype>::eval() +{ + typedef Eigen::Tensor<int, 1>::DimensionPair DimPair; + Eigen::array<DimPair, 1> dims{ { DimPair(1, 0) } }; + + Eigen::array<Eigen::Index, 2> weight_shuffle{ 1, 0 }; + + Eigen::array<Eigen::Index, 2> bias_reshape; + bias_reshape[0] = 1; + bias_reshape[1] = this->bias->getShape()[0]; + + Eigen::array<Eigen::Index, 2> bias_bcast; + bias_bcast[0] = this->input->getShape()[0]; + bias_bcast[1] = 1; + + TIn input_val = this->input->getTensor(); + TWeight weight_val = this->weight->getTensor().shuffle(weight_shuffle); + if (this->qinfo) + { + input_val = input_val - (InEigenType)this->qinfo->input_zp(); + weight_val = weight_val - (WeightEigenType)this->qinfo->weight_zp(); + } + + this->output->getTensor() = + input_val.template cast<AccEigenType>().contract(weight_val.template cast<AccEigenType>(), dims) + + this->bias->getTensor().reshape(bias_reshape).broadcast(bias_bcast); + + if (AccDtype == DType_INT48) + { + this->output->getTensor() = this->output->getTensor().cwiseMax((AccEigenType)AccQMin); + this->output->getTensor() = this->output->getTensor().cwiseMin((AccEigenType)AccQMax); + } + return GraphNode::eval(); +} + +template <DType Dtype> +OpMatMul<Dtype>::OpMatMul(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_MATMUL, id_) +{ + setRequiredOperands(2, 1); + setRequiredRank(2); + + INIT_QINFO(MatMul); +} + +template <DType Dtype> +OpMatMul<Dtype>::~OpMatMul() +{ + if (qinfo) + delete qinfo; +} + +template <DType Dtype> +int OpMatMul<Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(inputs[1]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + a = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + b = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[1]); + + if (a->getShape()[1] != b->getShape()[0]) + { + printNodeValidationError("OpMatMul operator a.shape[1] should match b.shape[0]"); + return 1; + } + + c = dynamic_cast<TosaReference::TensorTemplate<TAcc>*>(outputs[0]); + + return 0; +} + +template <DType Dtype> +int OpMatMul<Dtype>::eval() +{ + typedef Eigen::Tensor<int, 1>::DimensionPair DimPair; + Eigen::array<DimPair, 1> dims{ { DimPair(1, 0) } }; + + TIn a_val = this->a->getTensor(); + TIn b_val = this->b->getTensor(); + if (this->qinfo) + { + a_val = a_val - (InEigenType)this->qinfo->a_zp(); + b_val = b_val - (InEigenType)this->qinfo->b_zp(); + } + + this->c->getTensor() = a_val.template cast<AccEigenType>().contract(b_val.template cast<AccEigenType>(), dims); + + if (AccDtype == DType_INT48) + { + this->c->getTensor() = this->c->getTensor().cwiseMax((AccEigenType)AccQMin); + this->c->getTensor() = this->c->getTensor().cwiseMin((AccEigenType)AccQMax); + } + + return GraphNode::eval(); +} + +template <DType Dtype> +OpMaxPool2d<Dtype>::OpMaxPool2d(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_MAX_POOL2D, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(4); + + INIT_ATTRIBUTE(Pool2d); +} + +template <DType Dtype> +OpMaxPool2d<Dtype>::~OpMaxPool2d() +{ + if (attribute) + delete attribute; +} + +template <DType Dtype> +int OpMaxPool2d<Dtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + if (inputs[0]->matchType(*outputs[0])) + { + printNodeValidationError("OpMaxPool2d: input and output tensor type mismatch"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + if (!in->hasFormat(Format_NHWC)) + { + printNodeValidationError("OpMaxPool2d: unsupported tensor format"); + return 1; + } + + if (attribute->padding().size() != 4) + { + printNodeValidationError("OpMaxPool2d: illegal size for attribute padding"); + return 1; + } + + if (attribute->kernel().size() != 2) + { + printNodeValidationError("OpMaxPool2d: illegal size for attribute kernel"); + return 1; + } + + if (attribute->stride().size() != 2) + { + printNodeValidationError("OpMaxPool2d: illegal size for attribute stride"); + return 1; + } + + return 0; +} + +template <DType Dtype> +int OpMaxPool2d<Dtype>::eval() +{ + int in_batch = this->in->getShape()[0]; + int in_height = this->in->getShape()[1]; + int in_width = this->in->getShape()[2]; + int in_channels = this->in->getShape()[3]; + + int out_batch = this->out->getShape()[0]; + int out_height = this->out->getShape()[1]; + int out_width = this->out->getShape()[2]; + int out_channels = this->out->getShape()[3]; + + ASSERT_MSG_NODE(in_batch == out_batch, "OpMaxPool2d: tensor batch mismatch %d != %d", in_batch, out_batch); + + int padding_top = this->attribute->padding()[0]; + int padding_bottom = this->attribute->padding()[1]; + int padding_left = this->attribute->padding()[2]; + int padding_right = this->attribute->padding()[3]; + int kernel_h = this->attribute->kernel()[0]; + int kernel_w = this->attribute->kernel()[1]; + int stride_h = this->attribute->stride()[0]; + int stride_w = this->attribute->stride()[1]; + + DEBUG_INFO(OP, + "perform MaxPool2d, input.shape=[%d,%d,%d,%d], output.shape=[%d,%d,%d,%d], kernel=[%d,%d], " + "stride=[%d,%d], padding=[%d,%d,%d,%d]", + in_batch, in_height, in_width, in_channels, out_batch, out_height, out_width, out_channels, kernel_h, + kernel_w, stride_h, stride_w, padding_top, padding_bottom, padding_left, padding_right); + + Eigen::array<Eigen::Index, 2> im2col_input_dims; + im2col_input_dims[0] = kernel_h * kernel_w; + im2col_input_dims[1] = out_batch * out_height * out_width * out_channels; + + Eigen::array<Eigen::Index, 4> col2im_output_dims; + col2im_output_dims[0] = out_batch; + col2im_output_dims[1] = out_height; + col2im_output_dims[2] = out_width; + col2im_output_dims[3] = out_channels; + + Eigen::array<std::pair<int32_t, int32_t>, 4> padding; + padding[0] = std::make_pair(0, 0); + padding[1] = std::make_pair(padding_top, padding_bottom); + padding[2] = std::make_pair(padding_left, padding_right); + padding[3] = std::make_pair(0, 0); + + ETensor4<InEigenType> input_padded = this->in->getTensor().pad(padding, std::numeric_limits<InEigenType>::lowest()); + + // extract_image_patches() output [N, KH, KW, H * W, C] + // transpose to [KH, KW, N, H * W, C] + // reshape to [KH * KW, N * H * W * C] + // + // Set the padding value to be the most negative value that can be + // represented by the datatype to ensure that any padding values will be equal + // to or smaller than the actual maximum in the KH x KW patch. + ETensor2<InEigenType> input_extract_patches = + input_padded + .extract_image_patches(kernel_h, kernel_w, stride_h, stride_w, 1, 1, Eigen::PADDING_VALID, + std::numeric_limits<InEigenType>::lowest()) + .shuffle(Eigen::array<Eigen::Index, 5>{ 1, 2, 0, 3, 4 }) + .reshape(im2col_input_dims); + + // Get the maximum of the KHxHW patches along axis 0 + Eigen::Tensor<DenseIndex, 1> tensor_argmax = input_extract_patches.argmax(0); + + // 1D result with [N * H * W * C] + ETensor1<OutEigenType> out_1d(this->out->getElementCount()); + + // index input_patches with argmax array should give the result + for (size_t i = 0; i < this->out->getElementCount(); i++) + { + out_1d(i) = (OutEigenType)input_extract_patches(tensor_argmax(i), i); + } + + // reshape result to [N, H, W, C] + this->out->getTensor() = out_1d.reshape(col2im_output_dims); + + return GraphNode::eval(); +} + +template <DType InDtype, DType OutDtype> +OpTransposeConv2d<InDtype, OutDtype>::OpTransposeConv2d(TosaAttributeBase* attribute_, + TosaQuantInfoBase* qinfo_, + uint64_t id_) + : GraphNode(Op_TRANSPOSE_CONV2D, id_) +{ + setRequiredOperands(3, 1); + setRequiredRank(4); + + INIT_ATTRIBUTE(TransposeConv2d); + INIT_QINFO(Conv); +} + +template <DType InDtype, DType OutDtype> +OpTransposeConv2d<InDtype, OutDtype>::~OpTransposeConv2d() +{ + if (attribute) + delete attribute; + if (qinfo) + delete qinfo; +} + +template <DType InDtype, DType OutDtype> +int OpTransposeConv2d<InDtype, OutDtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(inputs[1]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + if (inputs[1]->getIsConst() == 0) + { + printNodeValidationError("OpTransposeConv2d: weight tensor is not const typed"); + } + + input = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + weight = dynamic_cast<TosaReference::TensorTemplate<TWeight>*>(inputs[1]); + bias = dynamic_cast<TosaReference::TensorTemplate<TBias>*>(inputs[2]); + output = dynamic_cast<TosaReference::TensorTemplate<TAcc>*>(outputs[0]); + + if (!input->hasFormat(Format_NHWC)) + { + printNodeValidationError("OpTransposeConv2d: unsupported input tensor format"); + return 1; + } + + if (!weight->hasFormat(Format_OHWI)) + { + printNodeValidationError("OpTransposeConv2d: unsupported weight tensor format"); + return 1; + } + + if (attribute->outpad().size() != 2) + { + printNodeValidationError("OpTransposeConv2d: illegal size for attribute outpad"); + return 1; + } + + if (attribute->stride().size() != 2) + { + printNodeValidationError("OpTransposeConv2d: illegal size for attribute stride"); + return 1; + } + + if (attribute->dilation().size() != 2) + { + printNodeValidationError("OpTransposeConv2d: illegal size for attribute dilation"); + return 1; + } + + if (attribute->output_shape().size() != 4) + { + printNodeValidationError("OpTransposeConv2d: illegal size for attribute output_shape"); + return 1; + } + + for (int d = 0; d < 4; d++) + { + if (attribute->output_shape()[d] != this->output->getShape()[d]) + { + printNodeValidationError("OpTransposeConv2d: illegal size for attribute output_shape"); + return 1; + } + } + + return 0; +} + +template <DType InDtype, DType OutDtype> +int OpTransposeConv2d<InDtype, OutDtype>::eval() +{ + int in_batch = this->input->getShape()[0]; + int in_height = this->input->getShape()[1]; + int in_width = this->input->getShape()[2]; + int in_channels = this->input->getShape()[3]; + + int f_out_channels = this->weight->getShape()[0]; + int f_height = this->weight->getShape()[1]; + int f_width = this->weight->getShape()[2]; + int f_in_channels = this->weight->getShape()[3]; + + int b_out_channels = this->bias->getShape()[0]; + + int out_batch = this->output->getShape()[0]; + int out_height = this->output->getShape()[1]; + int out_width = this->output->getShape()[2]; + int out_channels = this->output->getShape()[3]; + + int padding_top = this->attribute->outpad()[0]; + int padding_left = this->attribute->outpad()[1]; + int stride_h = this->attribute->stride()[0]; + int stride_w = this->attribute->stride()[1]; + int dilation_h = this->attribute->dilation()[0]; + int dilation_w = this->attribute->dilation()[1]; + + ASSERT_MSG_NODE(in_batch == out_batch, "OpTransposeConv2d: tensor batch mismatch %d != %d", in_batch, out_batch); + ASSERT_MSG_NODE(f_in_channels == in_channels, "OpTransposeConv2d: tensor input channel mismatch %d != %d", + f_in_channels, in_channels); + ASSERT_MSG_NODE(f_out_channels == out_channels, "OpTransposeConv2d: tensor output channel mismatch %d != %d", + f_out_channels, out_channels); + ASSERT_MSG_NODE(b_out_channels == out_channels, "OpDepthwiseConv2d: tensor b_out_channels mismatch %d != %d", + b_out_channels, out_channels); + + DEBUG_INFO(OP, + "perform OpTransposeConv2d, input.shape=[%d,%d,%d,%d], weight.shape=[%d,%d,%d,%d], " + "output.shape=[%d,%d,%d,%d], stride=[%d,%d], dilation=[%d,%d], padding=[%d,%d]", + in_batch, in_height, in_width, in_channels, f_height, f_width, f_out_channels, f_in_channels, out_batch, + out_height, out_width, out_channels, stride_h, stride_w, dilation_h, dilation_w, padding_top, + padding_left); + + TIn input_val = this->input->getTensor(); + TWeight weight_val = this->weight->getTensor(); + if (this->qinfo) + { + input_val = input_val - (InEigenType)this->qinfo->input_zp(); + weight_val = weight_val - (WeightEigenType)this->qinfo->weight_zp(); + } + + Eigen::array<Eigen::Index, 4> reshape_dim; + reshape_dim.fill(1); + reshape_dim[3] = b_out_channels; + + Eigen::array<Eigen::Index, 4> bcast; + bcast[0] = out_batch; + bcast[1] = out_height; + bcast[2] = out_width; + bcast[3] = 1; + + // initialize with bias + this->output->getTensor() = this->bias->getTensor().reshape(reshape_dim).broadcast(bcast); + + int out_x_origin, out_y_origin; + int out_x, out_y; + + // reference implementation from: tensorflow/tensorflow/lite/kernels/internal/reference/reference_ops.h + for (int ob = 0; ob < out_batch; ob++) + { + for (int ih = 0; ih < in_height; ih++) + { + for (int iw = 0; iw < in_width; iw++) + { + out_x_origin = iw * stride_w - padding_left; + out_y_origin = ih * stride_h - padding_top; + for (int ic = 0; ic < in_channels; ic++) + { + for (int fh = 0; fh < f_height; fh++) + { + for (int fw = 0; fw < f_width; fw++) + { + out_x = out_x_origin + fw * dilation_w; + out_y = out_y_origin + fh * dilation_h; + for (int oc = 0; oc < out_channels; oc++) + { + if ((out_x >= 0 && out_x < out_width) && (out_y >= 0 && out_y < out_height)) + { + this->output->getTensor()(ob, out_y, out_x, oc) += + ((AccEigenType)input_val(ob, ih, iw, ic) * + (AccEigenType)weight_val(oc, fh, fw, ic)); + } + } + } + } + } + } + } + } + + if (AccDtype == DType_INT48) + { + this->output->getTensor() = this->output->getTensor().cwiseMax((AccEigenType)AccQMin); + this->output->getTensor() = this->output->getTensor().cwiseMin((AccEigenType)AccQMax); + } + + return GraphNode::eval(); +} + +// template explicit instantiation +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpArgMax, FLOAT); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpArgMax, AINT8); +DEF_INSTANTIATE_RANK1_6_ONE_RANK_ONE_TYPE(OpArgMax, INT16); + +DEF_INSTANTIATE_ONE_TYPE(OpAvgPool2d, FLOAT) +DEF_INSTANTIATE_ONE_TYPE(OpAvgPool2d, AINT8) +DEF_INSTANTIATE_ONE_TYPE(OpAvgPool2d, INT16) + +DEF_INSTANTIATE_TWO_TYPE(OpConv2d, FLOAT, FLOAT); +DEF_INSTANTIATE_TWO_TYPE(OpConv2d, AINT8, INT4); +DEF_INSTANTIATE_TWO_TYPE(OpConv2d, AINT8, INT8); +DEF_INSTANTIATE_TWO_TYPE(OpConv2d, AINT8, AINT8); +DEF_INSTANTIATE_TWO_TYPE(OpConv2d, INT16, INT8); + +DEF_INSTANTIATE_TWO_TYPE(OpDepthwiseConv2d, FLOAT, FLOAT); +DEF_INSTANTIATE_TWO_TYPE(OpDepthwiseConv2d, AINT8, INT4); +DEF_INSTANTIATE_TWO_TYPE(OpDepthwiseConv2d, AINT8, INT8); +DEF_INSTANTIATE_TWO_TYPE(OpDepthwiseConv2d, AINT8, AINT8); +DEF_INSTANTIATE_TWO_TYPE(OpDepthwiseConv2d, INT16, INT8); + +DEF_INSTANTIATE_TWO_TYPE(OpFullyConnected, FLOAT, FLOAT); +DEF_INSTANTIATE_TWO_TYPE(OpFullyConnected, AINT8, INT4); +DEF_INSTANTIATE_TWO_TYPE(OpFullyConnected, AINT8, INT8); +DEF_INSTANTIATE_TWO_TYPE(OpFullyConnected, AINT8, AINT8); +DEF_INSTANTIATE_TWO_TYPE(OpFullyConnected, INT16, INT8); + +DEF_INSTANTIATE_ONE_TYPE(OpMatMul, AINT8); +DEF_INSTANTIATE_ONE_TYPE(OpMatMul, INT16); +DEF_INSTANTIATE_ONE_TYPE(OpMatMul, FLOAT); + +DEF_INSTANTIATE_ONE_TYPE(OpMaxPool2d, FLOAT); +DEF_INSTANTIATE_ONE_TYPE(OpMaxPool2d, AINT8); +DEF_INSTANTIATE_ONE_TYPE(OpMaxPool2d, INT16); + +DEF_INSTANTIATE_TWO_TYPE(OpTransposeConv2d, FLOAT, FLOAT); +DEF_INSTANTIATE_TWO_TYPE(OpTransposeConv2d, AINT8, INT4); +DEF_INSTANTIATE_TWO_TYPE(OpTransposeConv2d, AINT8, INT8); +DEF_INSTANTIATE_TWO_TYPE(OpTransposeConv2d, AINT8, AINT8); +DEF_INSTANTIATE_TWO_TYPE(OpTransposeConv2d, INT16, INT8); diff --git a/reference_model/src/ops/tensor_ops.h b/reference_model/src/ops/tensor_ops.h new file mode 100644 index 0000000..26ce84b --- /dev/null +++ b/reference_model/src/ops/tensor_ops.h @@ -0,0 +1,253 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_TENSOR_OPS_H +#define OPS_TENSOR_OPS_H + +#include "graph_node.h" +#include "quant_util.h" + +using namespace tosa; + +namespace TosaReference +{ + +template <int Rank, DType Dtype> +class OpArgMax : public GraphNode +{ +public: + OpArgMax(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpArgMax(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<DType_INT32>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank - 1>; + +protected: + TosaAxisAttribute* attribute; + TosaReference::TensorTemplate<TIn>* input; + TosaReference::TensorTemplate<TOut>* output; +}; + +template <DType Dtype> +class OpAvgPool2d : public GraphNode +{ +public: + OpAvgPool2d(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpAvgPool2d(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + static constexpr DType AccDtype = GetAccDType<Dtype, Dtype>::value; + using InEigenType = typename GetEigenType<Dtype>::type; + using AccEigenType = typename GetEigenType<AccDtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, 4>; + using TOut = Eigen::Tensor<OutEigenType, 4>; + + static constexpr int64_t QMin = GetQMin<Dtype>::value; + static constexpr int64_t QMax = GetQMax<Dtype>::value; + +protected: + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; + tosa::TosaPool2dAttribute* attribute; + tosa::TosaUnaryQuantInfo* qinfo; + +protected: + // return a 1D [N] tensor that describes a how many valid elements covered in the input space + ETensor1<int32_t> calculate_div_map_1d(int in_size, int out_size, int kernel_size, int stride); +}; + +template <DType InDtype, DType WeightDtype> +class OpConv2d : public GraphNode +{ +public: + OpConv2d(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpConv2d(); + + virtual int checkTensorAttributes() final; + virtual int eval() final; + + static constexpr DType AccDtype = GetAccDType<InDtype, WeightDtype>::value; + + using InEigenType = typename GetEigenType<InDtype>::type; + using WeightEigenType = typename GetEigenType<WeightDtype>::type; + using AccEigenType = typename GetEigenType<AccDtype>::type; + using TIn = Eigen::Tensor<InEigenType, 4>; + using TWeight = Eigen::Tensor<WeightEigenType, 4>; + using TBias = Eigen::Tensor<AccEigenType, 1>; + using TAcc = Eigen::Tensor<AccEigenType, 4>; + + static constexpr int64_t AccQMin = GetQMin<AccDtype>::value; + static constexpr int64_t AccQMax = GetQMax<AccDtype>::value; + +protected: + TosaReference::TensorTemplate<TIn>* input; + TosaReference::TensorTemplate<TWeight>* weight; + TosaReference::TensorTemplate<TBias>* bias; + TosaReference::TensorTemplate<TAcc>* output; + tosa::TosaConv2dAttribute* attribute; + tosa::TosaConvQuantInfo* qinfo; +}; + +template <DType InDtype, DType WeightDtype> +class OpDepthwiseConv2d : public GraphNode +{ +public: + OpDepthwiseConv2d(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpDepthwiseConv2d(); + + virtual int checkTensorAttributes() final; + virtual int eval() final; + + static constexpr DType AccDtype = GetAccDType<InDtype, WeightDtype>::value; + + using InEigenType = typename GetEigenType<InDtype>::type; + using WeightEigenType = typename GetEigenType<WeightDtype>::type; + using AccEigenType = typename GetEigenType<AccDtype>::type; + using TIn = Eigen::Tensor<InEigenType, 4>; + using TWeight = Eigen::Tensor<WeightEigenType, 4>; + using TBias = Eigen::Tensor<AccEigenType, 1>; + using TAcc = Eigen::Tensor<AccEigenType, 4>; + + static constexpr int64_t AccQMin = GetQMin<AccDtype>::value; + static constexpr int64_t AccQMax = GetQMax<AccDtype>::value; + +protected: + TosaReference::TensorTemplate<TIn>* input; + TosaReference::TensorTemplate<TWeight>* weight; + TosaReference::TensorTemplate<TBias>* bias; + TosaReference::TensorTemplate<TAcc>* output; + tosa::TosaConv2dAttribute* attribute; + tosa::TosaConvQuantInfo* qinfo; +}; + +template <DType InDtype, DType WeightDtype> +class OpFullyConnected : public GraphNode +{ +public: + OpFullyConnected(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpFullyConnected(); + + virtual int checkTensorAttributes() final; + virtual int eval() final; + + static constexpr DType AccDtype = GetAccDType<InDtype, WeightDtype>::value; + using InEigenType = typename GetEigenType<InDtype>::type; + using WeightEigenType = typename GetEigenType<WeightDtype>::type; + using AccEigenType = typename GetEigenType<AccDtype>::type; + using TIn = Eigen::Tensor<InEigenType, 2>; + using TWeight = Eigen::Tensor<WeightEigenType, 2>; + using TBias = Eigen::Tensor<AccEigenType, 1>; + using TAcc = Eigen::Tensor<AccEigenType, 2>; + + static constexpr int64_t AccQMin = GetQMin<AccDtype>::value; + static constexpr int64_t AccQMax = GetQMax<AccDtype>::value; + +protected: + TosaReference::TensorTemplate<TIn>* input; + TosaReference::TensorTemplate<TWeight>* weight; + TosaReference::TensorTemplate<TBias>* bias; + TosaReference::TensorTemplate<TAcc>* output; + tosa::TosaConvQuantInfo* qinfo; +}; + +template <DType Dtype> +class OpMatMul : public GraphNode +{ +public: + OpMatMul(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpMatMul(); + + virtual int checkTensorAttributes() final; + virtual int eval() final; + + static constexpr DType AccDtype = GetAccDType<Dtype, Dtype>::value; + using InEigenType = typename GetEigenType<Dtype>::type; + using AccEigenType = typename GetEigenType<AccDtype>::type; + using TIn = Eigen::Tensor<InEigenType, 2>; + using TAcc = Eigen::Tensor<AccEigenType, 2>; + static constexpr int64_t AccQMin = GetQMin<AccDtype>::value; + static constexpr int64_t AccQMax = GetQMax<AccDtype>::value; + +protected: + TosaReference::TensorTemplate<TIn>* a; + TosaReference::TensorTemplate<TIn>* b; + TosaReference::TensorTemplate<TAcc>* c; + tosa::TosaMatMulQuantInfo* qinfo; +}; + +template <DType Dtype> +class OpMaxPool2d : public GraphNode +{ +public: + OpMaxPool2d(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpMaxPool2d(); + + virtual int checkTensorAttributes(); + virtual int eval(); + + using InEigenType = typename GetEigenType<Dtype>::type; + using OutEigenType = typename GetEigenType<Dtype>::type; + using TIn = Eigen::Tensor<InEigenType, 4>; + using TOut = Eigen::Tensor<OutEigenType, 4>; + +protected: + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; + tosa::TosaPool2dAttribute* attribute; +}; + +template <DType InDtype, DType WeightDtype> +class OpTransposeConv2d : public GraphNode +{ +public: + OpTransposeConv2d(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpTransposeConv2d(); + + virtual int checkTensorAttributes() final; + virtual int eval() final; + + static constexpr DType AccDtype = GetAccDType<InDtype, WeightDtype>::value; + + using InEigenType = typename GetEigenType<InDtype>::type; + using WeightEigenType = typename GetEigenType<WeightDtype>::type; + using AccEigenType = typename GetEigenType<AccDtype>::type; + using TIn = Eigen::Tensor<InEigenType, 4>; + using TWeight = Eigen::Tensor<WeightEigenType, 4>; + using TBias = Eigen::Tensor<AccEigenType, 1>; + using TAcc = Eigen::Tensor<AccEigenType, 4>; + + static constexpr int64_t AccQMin = GetQMin<AccDtype>::value; + static constexpr int64_t AccQMax = GetQMax<AccDtype>::value; + +protected: + TosaReference::TensorTemplate<TIn>* input; + TosaReference::TensorTemplate<TWeight>* weight; + TosaReference::TensorTemplate<TBias>* bias; + TosaReference::TensorTemplate<TAcc>* output; + TosaTransposeConv2dAttribute* attribute; + TosaConvQuantInfo* qinfo; +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/ops/type_conversion.cc b/reference_model/src/ops/type_conversion.cc new file mode 100644 index 0000000..61a19f4 --- /dev/null +++ b/reference_model/src/ops/type_conversion.cc @@ -0,0 +1,299 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "type_conversion.h" +#include "quant_util.h" +#include "template_types.h" +#include <cmath> + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +template <int Rank, DType InDtype, DType OutDtype> +OpRescale<Rank, InDtype, OutDtype>::OpRescale(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_RESCALE, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(0, 6); + INIT_ATTRIBUTE(Rescale); +} + +template <int Rank, DType InDtype, DType OutDtype> +OpRescale<Rank, InDtype, OutDtype>::~OpRescale() +{ + if (attribute) + delete attribute; +} + +template <int Rank, DType InDtype, DType OutDtype> +int OpRescale<Rank, InDtype, OutDtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same rank and size + if (inputs[0]->matchRankSize(*outputs[0])) + { + printNodeValidationError("OpRescale: input and output rank/size must match"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + ASSERT_MEM(in && out); + + return 0; +} + +template <int Rank, DType InDtype, DType OutDtype> +int OpRescale<Rank, InDtype, OutDtype>::eval() +{ + int32_t input_zp = attribute->input_zp(); + int32_t output_zp = attribute->output_zp(); + std::vector<int32_t> multiplier = attribute->multiplier(); + std::vector<int32_t> shift = attribute->shift(); + //bool scale32 = attribute->scale32(); + bool double_round = attribute->double_round(); + bool per_channel = attribute->per_channel(); + + if (TosaReference::TypeChecker::is_symmetric(InDtype)) + { + if (input_zp != 0) + { + FATAL_ERROR_NODE("input tensor is symmetric type %s but zeropoint is %d instead of 0", + EnumNamesDType()[InDtype], input_zp); + } + } + + if (TosaReference::TypeChecker::is_symmetric(OutDtype)) + { + if (output_zp != 0) + { + FATAL_ERROR_NODE("output tensor is symmetric type %s but zeropoint is %d instead of 0", + EnumNamesDType()[OutDtype], output_zp); + } + } + + // reshape [d0, d1, ..., dn] into [d0 * d1 ..., dn] + Eigen::array<Eigen::Index, 2> shape_2d; + shape_2d[0] = 1; + if (Rank > 0) + { + for (int i = 0; i < Rank - 1; i++) + { + shape_2d[0] *= this->in->getShape()[i]; + } + shape_2d[1] = this->in->getShape()[Rank - 1]; + } + else + { + shape_2d[1] = 1; + } + ETensor2<InEigenType> input_reshaped = this->in->getTensor().reshape(shape_2d); + + ETensor2<OutEigenType> output_2d(shape_2d); + + // TODO: pass scale32 in when 16-bit mode implemented + if (per_channel) + { + ETensor2<InEigenType> curr_channel_slice_prescaled; + ETensor2<OutEigenType> curr_channel_slice_postscaled; + int32_t channel_multiplier, channel_shift; + Eigen::array<Eigen::Index, 2> begin, size; + size = Eigen::array<Eigen::Index, 2>({ shape_2d[0], 1 }); + for (int32_t i = 0; i < shape_2d[1]; i++) + { + begin = Eigen::array<Eigen::Index, 2>({ 0, i }); + curr_channel_slice_prescaled = input_reshaped.slice(begin, size); + channel_multiplier = multiplier[i]; + channel_shift = shift[i]; + curr_channel_slice_postscaled = + curr_channel_slice_prescaled.unaryExpr([input_zp, output_zp, channel_multiplier, channel_shift, + double_round](InEigenType in_val) -> OutEigenType { + InEigenType input_zp_shifted = in_val - (InEigenType)input_zp; + int32_t scaled = TosaReference::QuantUtil<InDtype>::apply_scale( + input_zp_shifted, channel_multiplier, channel_shift, double_round); + OutEigenType out_val = (OutEigenType)(scaled + output_zp); + out_val = std::max<OutEigenType>(out_val, QMin); + out_val = std::min<OutEigenType>(out_val, QMax); + return out_val; + }); + + for (int32_t j = 0; j < shape_2d[0]; j++) + { + output_2d(j, i) = curr_channel_slice_postscaled(j, 0); + } + } + } + else + { + int32_t tensor_multiplier = multiplier[0]; + int32_t tensor_shift = shift[0]; + output_2d = input_reshaped.unaryExpr( + [input_zp, output_zp, tensor_multiplier, tensor_shift, double_round](InEigenType in_val) -> OutEigenType { + InEigenType input_zp_shifted = in_val - (InEigenType)input_zp; + int32_t scaled = TosaReference::QuantUtil<InDtype>::apply_scale(input_zp_shifted, tensor_multiplier, + tensor_shift, double_round); + OutEigenType out_val = (OutEigenType)(scaled + output_zp); + out_val = std::max<OutEigenType>(out_val, QMin); + out_val = std::min<OutEigenType>(out_val, QMax); + return out_val; + }); + } + + // reshape [d0 * d1 ..., dn] back to [d0, d1, ..., dn] + Eigen::array<Eigen::Index, Rank> output_shape; + for (int i = 0; i < Rank; i++) + { + output_shape[i] = this->out->getShape()[i]; + } + this->out->getTensor() = output_2d.reshape(output_shape); + + return GraphNode::eval(); +} + +template <int Rank, DType InDtype, DType OutDtype> +OpCast<Rank, InDtype, OutDtype>::OpCast(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_) + : GraphNode(Op_CAST, id_) +{ + setRequiredOperands(1, 1); + setRequiredRank(0, 6); +} + +template <int Rank, DType InDtype, DType OutDtype> +OpCast<Rank, InDtype, OutDtype>::~OpCast() +{} + +template <int Rank, DType InDtype, DType OutDtype> +int OpCast<Rank, InDtype, OutDtype>::checkTensorAttributes() +{ + if (validateRequiredOperands()) + return 1; + + if (validateRequiredRank(inputs[0]) || validateRequiredRank(outputs[0])) + { + return 1; + } + + // output and input must be the same rank and size + if (inputs[0]->matchRankSize(*outputs[0])) + { + printNodeValidationError("OpCast: input and output rank/size must match"); + return 1; + } + + in = dynamic_cast<TosaReference::TensorTemplate<TIn>*>(inputs[0]); + out = dynamic_cast<TosaReference::TensorTemplate<TOut>*>(outputs[0]); + + ASSERT_MEM(in && out); + + return 0; +} + +template <int Rank, DType InDtype, DType OutDtype> +int OpCast<Rank, InDtype, OutDtype>::eval() +{ + this->out->getTensor() = this->in->getTensor().unaryExpr(cast_helper.get_fcn()); + + return GraphNode::eval(); +} + +template <DType InDtype, DType OutDtype> +CastHelper<InDtype, OutDtype>::CastHelper() +{ + fcn = [](InEigenType in) -> OutEigenType { + OutEigenType out = (OutEigenType)in; // implicit sign_extend() if sizeof(out_t) >= sizeof(in_t) + int64_t mask = (1L << OutBits) - 1; + out = out & mask; + return out; + }; +} + +template <DType InDtype> +CastHelper<InDtype, DType_BOOL>::CastHelper() +{ + fcn = [](InEigenType in) -> bool { return (in != 0) ? true : false; }; +} + +template <DType OutDtype> +CastHelper<DType_BOOL, OutDtype>::CastHelper() +{ + fcn = [](bool in) -> OutEigenType { + OutEigenType out = in ? (OutEigenType)1 : (OutEigenType)0; + return out; + }; +} + +template <DType InDtype> +CastHelper<InDtype, DType_FLOAT>::CastHelper() +{ + fcn = [](InEigenType in) -> float { + float out = (OutEigenType)in; // default cast to float is round_to_nearest_float() + return out; + }; +} + +template <DType OutDtype> +CastHelper<DType_FLOAT, OutDtype>::CastHelper() +{ + fcn = [](float in) -> OutEigenType { + OutEigenType out = std::round(in); + out = std::max<OutEigenType>(out, OutMin); + out = std::min<OutEigenType>(out, OutMax); + return out; + }; +} + +// template explicit instantiation +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, BOOL, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, BOOL, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, BOOL, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT8, BOOL); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT8, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT8, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT8, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT16, BOOL); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT16, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT16, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT16, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT32, BOOL); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT32, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT32, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, INT32, FLOAT); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, FLOAT, INT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, FLOAT, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpCast, FLOAT, INT32); + +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, AINT8, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, AINT8, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, AINT8, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT16, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT16, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT16, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT32, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT32, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT32, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT48, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT48, INT16); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, INT48, INT32); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, UINT8, AINT8); +DEF_INSTANTIATE_RANK0_6_ONE_RANK_TWO_TYPE(OpRescale, AINT8, UINT8); diff --git a/reference_model/src/ops/type_conversion.h b/reference_model/src/ops/type_conversion.h new file mode 100644 index 0000000..6ec4d6d --- /dev/null +++ b/reference_model/src/ops/type_conversion.h @@ -0,0 +1,162 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef OPS_TYPE_CONVERSION_H +#define OPS_TYPE_CONVERSION_H + +#include "graph_node.h" + +using namespace tosa; + +namespace TosaReference +{ +template <int Rank, DType InDtype, DType OutDtype> +class OpRescale : public GraphNode +{ +public: + OpRescale(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpRescale(); + + virtual int checkTensorAttributes() final; + virtual int eval() final; + + using InEigenType = typename GetEigenType<InDtype>::type; + using OutEigenType = typename GetEigenType<OutDtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + + static constexpr int32_t QMin = GetQMin<OutDtype>::value; + static constexpr int32_t QMax = GetQMax<OutDtype>::value; + +protected: + TosaRescaleAttribute* attribute; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; +}; + +template <DType InDtype, DType OutDtype> +class CastHelper +{ +public: + using InEigenType = typename GetEigenType<InDtype>::type; + using OutEigenType = typename GetEigenType<OutDtype>::type; + using FcnType = std::function<OutEigenType(InEigenType)>; + static constexpr int32_t OutBits = GetNumBits<OutDtype>::value; + CastHelper(); + const FcnType& get_fcn() const + { + return fcn; + } + +private: + FcnType fcn; +}; + +template <DType InDtype> +class CastHelper<InDtype, DType_BOOL> +{ +public: + using InEigenType = typename GetEigenType<InDtype>::type; + using OutEigenType = typename GetEigenType<DType_BOOL>::type; + using FcnType = std::function<OutEigenType(InEigenType)>; + CastHelper(); + const FcnType& get_fcn() const + { + return fcn; + } + +private: + FcnType fcn; +}; + +template <DType OutDtype> +class CastHelper<DType_BOOL, OutDtype> +{ +public: + using InEigenType = typename GetEigenType<DType_BOOL>::type; + using OutEigenType = typename GetEigenType<OutDtype>::type; + using FcnType = std::function<OutEigenType(InEigenType)>; + static constexpr int32_t OutMin = GetQMin<OutDtype>::value; + static constexpr int32_t OutMax = GetQMax<OutDtype>::value; + CastHelper(); + const FcnType& get_fcn() const + { + return fcn; + } + +private: + FcnType fcn; +}; + +template <DType InDtype> +class CastHelper<InDtype, DType_FLOAT> +{ +public: + using InEigenType = typename GetEigenType<InDtype>::type; + using OutEigenType = typename GetEigenType<DType_FLOAT>::type; + using FcnType = std::function<OutEigenType(InEigenType)>; + CastHelper(); + const FcnType& get_fcn() const + { + return fcn; + } + +private: + FcnType fcn; +}; + +template <DType OutDtype> +class CastHelper<DType_FLOAT, OutDtype> +{ +public: + using InEigenType = typename GetEigenType<DType_FLOAT>::type; + using OutEigenType = typename GetEigenType<OutDtype>::type; + using FcnType = std::function<OutEigenType(InEigenType)>; + static constexpr int32_t OutMin = GetQMin<OutDtype>::value; + static constexpr int32_t OutMax = GetQMax<OutDtype>::value; + CastHelper(); + const FcnType& get_fcn() const + { + return fcn; + } + +private: + FcnType fcn; +}; + +template <int Rank, DType InDtype, DType OutDtype> +class OpCast : public GraphNode +{ +public: + OpCast(TosaAttributeBase* attribute_, TosaQuantInfoBase* qinfo_, uint64_t id_); + virtual ~OpCast(); + + virtual int checkTensorAttributes() final; + virtual int eval() final; + + using InEigenType = typename GetEigenType<InDtype>::type; + using OutEigenType = typename GetEigenType<OutDtype>::type; + using TIn = Eigen::Tensor<InEigenType, Rank>; + using TOut = Eigen::Tensor<OutEigenType, Rank>; + +protected: + CastHelper<InDtype, OutDtype> cast_helper; + TosaReference::TensorTemplate<TIn>* in; + TosaReference::TensorTemplate<TOut>* out; +}; + +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/quant_util.h b/reference_model/src/quant_util.h new file mode 100644 index 0000000..3638b3b --- /dev/null +++ b/reference_model/src/quant_util.h @@ -0,0 +1,103 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef TOSA_REFERENCE_QUANT_UTIL_H +#define TOSA_REFERENCE_QUANT_UTIL_H + +#include "arith_util.h" +#include "func_debug.h" +#include "ops/template_types.h" +#include "tosa_generated.h" + +using namespace tosa; + +namespace TosaReference +{ + +template <DType AccDType> +class QuantUtil +{ +public: + using T = typename GetEigenType<AccDType>::type; + + static void reciprocal_scale(int32_t value, + // Output + int32_t& multiplier, + int32_t& shift) + { + ASSERT_MSG(value > 0, "AvgPool2d reciprocal_scale() error: # of elements should be > 1 but is %d", value); + uint32_t value_u32 = (uint32_t)value; + int32_t k = 32 - LEADING_ZEROS_32(value_u32 - 1); // (1<<k)/2 < value <= (1<<k) + int64_t numerator = ((1L << 30) + 1) << k; + multiplier = numerator / value; // (1<<30) <= multiplier < (1<<31) + shift = 30 + k; + } + + static int32_t apply_scale(T value, int32_t multiplier, int32_t shift, bool enabled_adjusted_rounding = true) + { + if (AccDType == DType_FLOAT) + { + return value; + } + ASSERT_MSG(multiplier >= 0, "apply_scale() error: multiplier should >= 0 but is %d", multiplier); + int64_t round = (shift > 0) ? (1L << (shift - 1)) : 0; + if (enabled_adjusted_rounding) + { + if (AccDType != DType_INT48) + { + if (shift > 31 && value >= 0) + round += (1L << 30); + if (shift > 31 && value < 0) + round -= (1L << 30); + } + else + { // input data could be int16, which leads to 48 bits accumulator + ASSERT_MSG(multiplier < (1 << 15), "apply_scale() error: multiplier should <= %d in 48 bit mode", + (1 << 15)); + } + } + int64_t result = (int64_t)value * multiplier + round; + result = result >> shift; + ASSERT_MSG(result >= -(1L << 31) && result < (1L << 31), + "apply_scale() error: scaled result exceed int32 numeric range"); + return static_cast<int32_t>(result); + } +}; + +class TypeChecker +{ +public: + static bool is_integer(DType dtype) + { + if (dtype == DType_INT4 || dtype == DType_INT8 || dtype == DType_AINT8 || dtype == DType_UINT8 || + dtype == DType_INT16 || dtype == DType_INT32 || dtype == DType_INT48) + { + return true; + } + return false; + } + static bool is_symmetric(DType dtype) + { + if (dtype == DType_INT4 || dtype == DType_INT8 || dtype == DType_INT16 || dtype == DType_INT32 || + dtype == DType_INT48) + { + return true; + } + return false; + } +}; +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/subgraph_traverser.cc b/reference_model/src/subgraph_traverser.cc new file mode 100644 index 0000000..789bcae --- /dev/null +++ b/reference_model/src/subgraph_traverser.cc @@ -0,0 +1,649 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "subgraph_traverser.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +SubgraphTraverser::SubgraphTraverser(TosaSerializationBasicBlock* _block, TosaSerializationHandler* _tsh) +{ + block = _block; + tsh = _tsh; + + tensors.clear(); + nodes.clear(); + nextNodeList.clear(); +} + +SubgraphTraverser::~SubgraphTraverser() +{ + nextNodeList.clear(); + + for (GraphNode* n : nodes) + { + delete n; + } + nodes.clear(); + + for (TosaReference::Tensor* t : tensors) + { + if (t->is_allocated()) + { + t->deallocate(); + } + delete t; + } + tensors.clear(); +} + +int SubgraphTraverser::getNumInputTensors() const +{ + return inputTensors.size(); +} + +TosaReference::Tensor* SubgraphTraverser::getInputTensor(const unsigned int idx) const +{ + return inputTensors[idx]; +} + +TosaReference::Tensor* SubgraphTraverser::getInputTensorByName(const std::string name) const +{ + for (auto t : inputTensors) + { + if (t->getName() == name) + { + return t; + } + } + + return nullptr; +} + +int SubgraphTraverser::getNumOutputTensors() const +{ + return outputTensors.size(); +} + +TosaReference::Tensor* SubgraphTraverser::getOutputTensor(const unsigned int idx) const +{ + return outputTensors[idx]; +} + +TosaReference::Tensor* SubgraphTraverser::getOutputTensorByName(const std::string name) const +{ + for (auto t : outputTensors) + { + if (t->getName() == name) + { + return t; + } + } + + return nullptr; +} + +int SubgraphTraverser::initializeGraph() +{ + char tensor_fullname[1000]; + int idx = 0; + for (auto op : block->GetOperators()) + { + // translated TosaSerializationOperator to GraphNode + DType in_dtype = DType_UNKNOWN, out_dtype = DType_UNKNOWN, weight_dtype = DType_UNKNOWN; + uint32_t in_rank = 0, out_rank = 0, weight_rank = 0; + for (auto name : op->GetInputTensorNames()) + { + + TosaSerializationTensor* ts = block->GetTensorByName(name); + ASSERT_MSG(ts, "SubgraphTraverser: fail to get tensor %s from TosaSerializationHandler", name.c_str()); + + if (ts->HasUsage(Usage_WEIGHT)) + { + weight_dtype = ts->GetDtype(); + weight_rank = ts->GetShape().size(); + } + else if (ts->HasUsage(Usage_INDEX)) + { + // do nothing, but this will prevent tensor's dtype/rank being wrongly used as template argument when initializing this op + } + else if (ts->HasUsage(Usage_ACTIVATION)) + { + if (ts->GetShape().size() >= in_rank) + { + in_dtype = ts->GetDtype(); + in_rank = ts->GetShape().size(); + } + } + } + + for (auto name : op->GetOutputTensorNames()) + { + + TosaSerializationTensor* ts = block->GetTensorByName(name); + ASSERT_MSG(ts, "SubgraphTraverser: fail to get tensor %s from TosaSerializationHandler", name.c_str()); + + out_dtype = ts->GetDtype(); + out_rank = ts->GetShape().size(); + } + + DEBUG_INFO(GT, "Creating operator id_%03u, %8s, %lu input tensors, %lu output tensors", idx, + EnumNamesOp()[op->GetOp()], op->GetInputTensorNames().size(), op->GetOutputTensorNames().size()); + + GraphNode* cn = OpFactory::newOp(tsh, op->GetOp(), op->GetAttribute(), op->GetQInfo(), idx, in_dtype, in_rank, + out_dtype, out_rank, weight_dtype, weight_rank); + if (!cn) + { + if (weight_dtype == DType_UNKNOWN && weight_rank == 0) + { + fprintf(g_func_debug.func_debug_file, + "OpFactory could not allocate op %8s input=(%s rank %d) -> (%s rank %d)", + EnumNamesOp()[op->GetOp()], EnumNamesDType()[in_dtype], in_rank, EnumNamesDType()[out_dtype], + out_rank); + } + else + { + fprintf(g_func_debug.func_debug_file, + "OpFactory could not allocate op %8s input=(%s rank %d), weight=(%s rank %d) -> (%s rank %d)", + EnumNamesOp()[op->GetOp()], EnumNamesDType()[in_dtype], in_rank, EnumNamesDType()[weight_dtype], + weight_rank, EnumNamesDType()[out_dtype], out_rank); + } + + for (auto ts : op->GetInputTensors()) + { + fprintf(g_func_debug.func_debug_file, "Input: %s\n", ts->GetName().c_str()); + } + + for (auto ts : op->GetOutputTensors()) + { + fprintf(g_func_debug.func_debug_file, "Output: %s\n", ts->GetName().c_str()); + } + FATAL_ERROR("Unsupported operation type or rank."); + } + + for (auto name : op->GetInputTensorNames()) + { + cn->addInputName(name); + } + + for (auto name : op->GetOutputTensorNames()) + { + cn->addOutputName(name); + } + + addNode(cn); + + // if node doesn't have any inputs (i.e. CONST) + // it should be ready for evaluation + if (op->GetInputTensorNames().empty() && !cn->getOnNextNodeList()) + { + addToNextNodeList(cn); + } + + idx++; + } + + for (auto ts : block->GetTensors()) + { + + bool is_const = false; + if (ts->HasUsage(Usage_WEIGHT)) + { + is_const = true; + } + + DEBUG_INFO(GT, "Creating tensor %s", ts->GetName().c_str()); + TosaReference::Tensor* ct = + TensorFactory::newTensor(ts->GetName(), ts->GetDtype(), ts->GetUsage(), ts->GetFormat(), ts->GetShape(), + is_const, ts->GetShape().size()); + + if (ts->GetNpyFilePtr()) + { + if (ct->allocate()) + { + FATAL_ERROR("Fail to allocate Eigen tensor %s", ct->getName().c_str()); + } + + bzero(tensor_fullname, sizeof(tensor_fullname)); + snprintf(tensor_fullname, sizeof(tensor_fullname), "%s/%s", g_func_config.subgraph_dir, + ts->GetNpyFilePtr()->c_str()); + if (ct->readFromNpyFile(tensor_fullname)) + { + FATAL_ERROR("Cannot read input data into graph tensor %s from block %s", ct->getName().c_str(), + block->GetName().c_str()); + } + } + + // update this->tensors + addTensor(ct); + } + + DEBUG_INFO(GT, "Enumerating block %s graph inputs", block->GetName().c_str()); + for (auto& input_name : block->GetInputs()) + { + TosaReference::Tensor* ct = findTensorByName(input_name); + DEBUG_INFO(GT, "input tensor name=%s", input_name.c_str()); + if (ct) + { + ct->setIsSubgraphInput(); + inputTensors.push_back(ct); + } + else + { + FATAL_ERROR("loadGraphJson: Fail to find input tensor by name %s", input_name.c_str()); + } + } + + DEBUG_INFO(GT, "Enumerating block %s graph outputs", block->GetName().c_str()); + for (auto& output_name : block->GetOutputs()) + { + TosaReference::Tensor* ct = findTensorByName(output_name); + DEBUG_INFO(GT, "output tensor name=%s\n", output_name.c_str()); + if (ct) + { + ct->setIsSubgraphOutput(); + outputTensors.push_back(ct); + } + else + { + FATAL_ERROR("loadGraphJson: Fail to find output tensor by name %s", output_name.c_str()); + } + } + + if (DEBUG_ENABLED(DEBUG_VERB_HIGH, GT)) + { + dumpNextNodeList(g_func_debug.func_debug_file); + } + + return 0; +} + +int SubgraphTraverser::isFullyEvaluated() const +{ + return nextNodeList.empty(); +} + +GraphNode* SubgraphTraverser::getNextNode() +{ + GraphNode* nextNode = nextNodeList.front(); + ASSERT_MSG(nextNode, "SubgraphTraverser::getNextNode(): called with empty next node list"); + ASSERT_MSG(nextNode->getOnNextNodeList(), + "SubgraphTraverser::getNextNode(): internal state error: node is not listed as being on next node list"); + + nextNodeList.pop_front(); + + nextNode->clearOnNextNodeList(); + return nextNode; +} + +int SubgraphTraverser::addToNextNodeList(GraphNode* nextNode) +{ + ASSERT_MSG(nextNode, "SubgraphTraverser::addToNextNodeList(): called with no node"); + ASSERT_MSG(!nextNode->getOnNextNodeList(), + "SubgraphTraverser::addToNextNodeList(): internal state error: node is already on next node list"); + + nextNode->setOnNextNodeList(); + nextNodeList.push_back(nextNode); + + return 0; +} + +int SubgraphTraverser::evaluateNextNode() +{ + if (isFullyEvaluated()) + return 0; + + GraphNode* currNode = getNextNode(); + + DEBUG_INFO(GT, "Evaluating node_%03lu, %8s, output tensor=%s", currNode->getID(), EnumNamesOp()[currNode->getOp()], + currNode->getOutputNames()[0].c_str()); + + // Sanity check for never-ending loops + if (currNode->getEvalCount() >= MAX_EVAL_COUNT && (currNode->getEvalCount() % MAX_EVAL_COUNT) == 0) + { + WARNING("Node %lu has been evaluated %d times. Loop suspected.", currNode->getID(), currNode->getEvalCount()); + } + + for (auto ct : currNode->getOutputs()) + { + if (!ct->is_allocated()) + if (ct->allocate()) + { + FATAL_ERROR("Fail to allocate Eigen tensor %s", ct->getName().c_str()); + } + } + + if (currNode->eval()) + { + FATAL_ERROR("Error evaluating node: %lu\n", currNode->getID()); + } + + // free input tensor if all of its consumers have all of their outputs ready and it's not block's output + for (auto ct : currNode->getInputs()) + { + bool in_use = false; + for (auto cn : ct->getConsumers()) + { + if (!cn->hasAllOutputsReady()) + { + in_use = true; + } + } + for (auto name : block->GetOutputs()) + { + if (name == ct->getName()) + { + in_use = true; + } + } + if (!in_use) + { + ct->deallocate(); + } + } + + // Search the output tensors of this node to see if + // there are now new ready nodes available from completing this node + for (TosaReference::Tensor* tensor : currNode->getOutputs()) + { + for (GraphNode* node : tensor->getConsumers()) + { + if (!node->getOnNextNodeList() && node->hasAllInputsReady()) + { + addToNextNodeList(node); + } + } + } + + if (DEBUG_ENABLED(DEBUG_VERB_HIGH, GT)) + { + dumpNextNodeList(g_func_debug.func_debug_file); + } + + if (g_func_config.dump_intermediates) + { + currNode->dumpNode(g_func_debug.func_debug_file); + for (auto outs : currNode->getOutputs()) + { + outs->dumpTensorParams(g_func_debug.func_debug_file); + outs->dumpTensor(g_func_debug.func_debug_file); + fprintf(g_func_debug.func_debug_file, "\n"); + } + } + + return 0; +} + +int SubgraphTraverser::dumpNextNodeList(FILE* out) const +{ + + // Dump next node list + fprintf(out, "Next node list\n"); + + if (nextNodeList.empty()) + { + fprintf(out, "<empty>\n"); + } + + for (auto gn : nextNodeList) + { + gn->dumpNode(out); + } + + fprintf(out, "Done.\n"); + return 0; +} + +int SubgraphTraverser::clearAllNodeMarkings() +{ + for (GraphNode* currNode : nodes) + { + currNode->clearNodeMarked(); + } + + return false; +} + +int SubgraphTraverser::addTensor(TosaReference::Tensor* ct) +{ + // Enforce no duplicate tensors/tensor names + // O(N), but the number of tensors is small + for (TosaReference::Tensor* currTensor : tensors) + { + if (ct == currTensor || currTensor->getName() == ct->getName()) + { + FATAL_ERROR("Error: Duplicate tensor or tensor name being added to graph: %s\n", ct->getName().c_str()); + return 1; + } + } + + tensors.push_back(ct); + + if (ct->getIsSubgraphInput()) + { + inputTensors.push_back(ct); + } + + if (ct->getIsSubgraphOutput()) + { + outputTensors.push_back(ct); + } + + return 0; +} +int SubgraphTraverser::addNode(GraphNode* newNode) +{ + // Enforce no duplicate nodes + for (GraphNode* currNode : nodes) + { + if (currNode == newNode) + { + FATAL_ERROR("Error: duplicate node being added to graph"); + return 1; + } + } + + nodes.push_back(newNode); + + return 0; +} + +TosaReference::Tensor* SubgraphTraverser::findTensorByName(const std::string& name) const +{ + for (TosaReference::Tensor* currTensor : tensors) + { + if (currTensor->getName() == name) + { + return currTensor; + } + } + + WARNING("Unable to find tensor with name: %s\n", name.c_str()); + + return nullptr; +} + +int SubgraphTraverser::linkTensorsAndNodes() +{ + // Nodes have a list of input/output tensor names + // For each node, read this list, link up the tensors with their inputs/outputs + for (GraphNode* currNode : nodes) + { + + // Link inputs/consuming nodes + for (std::string& name : currNode->getInputNames()) + { + TosaReference::Tensor* t = findTensorByName(name); + if (!t) + { + FATAL_ERROR("linkTensorsAndNodes: Cannot find tensor %s in node %lu\n", name.c_str(), + currNode->getID()); + return 1; + } + + if (currNode->addInputTensor(t)) + { + FATAL_ERROR("linkTensorsAndNodes: cannot link tensor %s to node %lu\n", name.c_str(), + currNode->getID()); + return 1; + } + + if (t->addConsumer(currNode)) + { + FATAL_ERROR("linkTensorsAndNodes: cannot link consumer node %lu to tensor %s\n", currNode->getID(), + name.c_str()); + return 1; + } + } + + // Link outputs/producing nodes + for (std::string& name : currNode->getOutputNames()) + { + TosaReference::Tensor* t = findTensorByName(name); + if (!t) + { + FATAL_ERROR("linkTensorsAndNodes: Cannot find tensor %s in node %lu\n", name.c_str(), + currNode->getID()); + return 1; + } + + if (currNode->addOutputTensor(t)) + { + FATAL_ERROR("linkTensorsAndNodes: cannot link tensor %s to node %lu\n", name.c_str(), + currNode->getID()); + return 1; + } + + if (t->setProducer(currNode)) + { + FATAL_ERROR("linkTensorsAndNodes: cannot link producer node %lu to tensor tensor %s\n", + currNode->getID(), name.c_str()); + return 1; + } + } + } + + return 0; +} + +int SubgraphTraverser::validateGraph() +{ + // Need to make sure that: + // - each tensor is actually used + // - input and output tesnsors truly are just input and just output + // Graph building already determined that each node has found its input/output tensors + + for (TosaReference::Tensor* currTensor : tensors) + { + + if (!currTensor->getProducer() && currTensor->getConsumers().empty()) + { + WARNING("Graph inconsistency: TosaReference::Tensor %s has no producers or consumers\n", + currTensor->getName().c_str()); + return 1; + } + + if (currTensor->getIsSubgraphInput()) + { + if (currTensor->getProducer() && currTensor->getProducer()->getOp() != Op_PLACEHOLDER) + { + WARNING("Graph inconsistency: TosaReference::Tensor %s is a subgraph input and has a producer\n", + currTensor->getName().c_str()); + return 1; + } + } + + // comment this check out as this is possible when graph have multiple output + // for example: + // %0 = add(%arg0, %arg1) + // %1 = mul(%arg0, %0) + // yields(%0, %1) + //if (currTensor->getIsSubgraphOutput()) { + // if (!currTensor->getConsumers().empty()) { + // WARNING ("Graph inconsistency: TosaReference::Tensor %s is a subgraph output and has a consumer\n", + // currTensor->getName().c_str()); + // return 1; + // } + //} + + if (g_func_config.tosa_profile == 0) + { + DType dtype = currTensor->getDtype(); + + // Float-point disallowed + if (dtype == DType_FLOAT) + { + WARNING("TOSA Base Inference profile selected: All floating point disabled, but %s tensor %s found\n", + EnumNamesDType()[dtype], currTensor->getName().c_str()); + return 1; + } + } + else if (g_func_config.tosa_profile == 1 || g_func_config.tosa_profile == 2) + { + // Do nothing. All FP types allowed + // Currently no implementation difference between Main Inference and Main Training modes + } + else + { + FATAL_ERROR("TOSA profile not recognized: %d", g_func_config.tosa_profile); + } + } + + for (GraphNode* currNode : nodes) + { + if (currNode->checkTensorAttributes()) + { + WARNING("TosaReference::Tensor attribute check failed"); + return 1; + } + } + + if (outputTensors.size() <= 0) + { + DEBUG_MED(GT, "Graph output tensor empty"); + return 0; + } + + return 0; +} + +int SubgraphTraverser::dumpGraph(FILE* out) const +{ + int i = 0; + + fprintf(out, "Full graph dump:\n"); + for (GraphNode* currNode : nodes) + { + fprintf(out, "Node [%d]: ", i++); + currNode->dumpNode(out); + } + + return 0; +} + +int SubgraphTraverser::evaluateAll() +{ + // evaluation loop + while (!isFullyEvaluated()) + { + if (evaluateNextNode()) + { + return 1; + } + } + + return 0; +} diff --git a/reference_model/src/subgraph_traverser.h b/reference_model/src/subgraph_traverser.h new file mode 100644 index 0000000..3f4eecf --- /dev/null +++ b/reference_model/src/subgraph_traverser.h @@ -0,0 +1,90 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef SUBGRAPH_TRAVERSER_H +#define SUBGRAPH_TRAVERSER_H + +#include "model_common.h" + +#include "graph_node.h" +#include "ops/op_factory.h" +#include "tosa_serialization_handler.h" + +namespace TosaReference +{ + +class SubgraphTraverser +{ +public: + SubgraphTraverser(TosaSerializationBasicBlock* block, TosaSerializationHandler* tsh); + ~SubgraphTraverser(); + + int initializeGraph(); + int isFullyEvaluated() const; + int evaluateNextNode(); + int evaluateAll(); + + int linkTensorsAndNodes(); + int validateGraph(); + + int dumpGraph(FILE* out) const; + int dumpNextNodeList(FILE* out) const; + int clearAllNodeMarkings(); + + int getNumInputTensors() const; + Tensor* getInputTensor(const unsigned int idx) const; + Tensor* getInputTensorByName(const std::string name) const; + int getNumOutputTensors() const; + Tensor* getOutputTensor(const unsigned int idx) const; + Tensor* getOutputTensorByName(const std::string name) const; + int addToNextNodeList(GraphNode*); + +private: + int addTensor(Tensor* ct); + int addNode(GraphNode* cn); + + Tensor* findTensorByName(const std::string& name) const; + + GraphNode* getNextNode(); + + // pointer to serialization library and corresponding basic block + TosaSerializationBasicBlock* block; + TosaSerializationHandler* tsh; + + // The definitive list of all tensors + std::vector<Tensor*> tensors; + + // The subset of tensors that are also input tensors + std::vector<Tensor*> inputTensors; + + // The subset of tensors that are also output tensors + std::vector<Tensor*> outputTensors; + + // The definitive list of all nodes in the graph + std::vector<GraphNode*> nodes; + + // The subset of node that have all of their input tensors ready, but + // have not yet been evaluated to produce their output tensors. + // With control flow, a node may appear on this list more than once during its + // lifetime, although the list itself should only contain unique nodes. + std::list<GraphNode*> nextNodeList; + + // Maximum number of times to evalute a node before + // warning. + const int MAX_EVAL_COUNT = 10000; +}; +}; // namespace TosaReference + +#endif diff --git a/reference_model/src/tensor.cc b/reference_model/src/tensor.cc new file mode 100644 index 0000000..179484e --- /dev/null +++ b/reference_model/src/tensor.cc @@ -0,0 +1,3008 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "tensor.h" +#include "arith_util.h" + +using namespace TosaReference; +using namespace Eigen; +using namespace tosa; + +TosaReference::Tensor::Tensor(std::string tensorName_, + DType tensorDtype_, + const std::vector<Usage>& tensorUsage_, + const std::vector<Format>& tensorFormat_, + std::vector<int> shape_, + int isConst_) +{ + tensorName = std::string(tensorName_); + tensorDtype = tensorDtype_; + tensorUsage = std::vector<Usage>(tensorUsage_); + tensorFormat = std::vector<Format>(tensorFormat_); + shape = std::vector<int>(shape_); + isConst = isConst_; + producer = nullptr; + isValid = false; + consumers.clear(); + isSubgraphInput = false; + isSubgraphOutput = false; +} + +TosaReference::Tensor::~Tensor() +{} + +int TosaReference::Tensor::setIsSubgraphInput() +{ + isSubgraphInput = true; + return 0; +} + +int TosaReference::Tensor::setIsSubgraphOutput() +{ + isSubgraphOutput = true; + return 0; +} + +int TosaReference::Tensor::setProducer(GraphNode* node) +{ + ASSERT_MSG(node, "Tensor::setProducer: no node passed in"); + ASSERT_MSG(!producer, "Tensor::setProducer: producer node already set, tensor %s", tensorName.c_str()); + producer = node; + + return 0; +} + +int TosaReference::Tensor::addConsumer(GraphNode* node) +{ + ASSERT_MSG(node, "Tensor::addConsumer: no node passed in"); + consumers.push_back(node); + + return 0; +} + +int TosaReference::Tensor::dumpTensorParams(FILE* out) const +{ + fprintf(out, "Name: %s DType=%s Usage=%s isValid=%d Rank=%d Shape=%s\n", tensorName.c_str(), + EnumNamesDType()[getDtype()], getUsageAsString().c_str(), getIsValid(), getRank(), + getShapeAsString().c_str()); + + return 0; +} + +int TosaReference::Tensor::dumpTensorParams(std::ostream& out) const +{ + out << "Name: " << getName() << " DType=" << EnumNamesDType()[getDtype()] << " Usage=" << getUsageAsString() + << " isValid=" << getIsValid() << " Rank=" << getRank() << " Shape=" << getShapeAsString() << "\n"; + + return 0; +} + +int TosaReference::Tensor::readFromNpyFile(const char* filename) +{ + uint32_t elements = getElementCount(); + float* fdatabuf = nullptr; + int32_t* i32databuf = nullptr; + int64_t* i64databuf = nullptr; + bool* bdatabuf = nullptr; + NumpyUtilities::NPError nperror; + + switch (getDtype()) + { + case DType_FLOAT: + fdatabuf = (float*)calloc(sizeof(float), elements); + ASSERT_MEM(fdatabuf); + + nperror = NumpyUtilities::readFromNpyFile(filename, elements, fdatabuf); + break; + case DType_INT32: + case DType_AINT8: + case DType_UINT8: + case DType_INT4: + case DType_INT8: + case DType_INT16: + i32databuf = (int32_t*)calloc(sizeof(int32_t), elements); + ASSERT_MEM(i32databuf); + + nperror = NumpyUtilities::readFromNpyFile(filename, elements, i32databuf); + break; + case DType_INT48: + i64databuf = (int64_t*)calloc(sizeof(int64_t), elements); + ASSERT_MEM(i64databuf); + + nperror = NumpyUtilities::readFromNpyFile(filename, elements, i64databuf); + break; + case DType_BOOL: + bdatabuf = (bool*)calloc(sizeof(bool), elements); + ASSERT_MEM(bdatabuf); + + nperror = NumpyUtilities::readFromNpyFile(filename, elements, bdatabuf); + break; + default: + FATAL_ERROR("unsupported tensor type=%s", EnumNamesDType()[getDtype()]); + } + + switch (nperror) + { + case NumpyUtilities::NO_ERROR: + break; + case NumpyUtilities::FILE_NOT_FOUND: + FATAL_ERROR("readFromNpyFile: Cannot open file %s", filename); + case NumpyUtilities::FILE_IO_ERROR: + FATAL_ERROR("readFromNpyFile: IO error reading file: %s", filename); + case NumpyUtilities::FILE_TYPE_MISMATCH: + FATAL_ERROR("readFromNpyFile: Tensor type %s and Numpy file type mismatch for tensor %s filename %s", + EnumNamesDType()[getDtype()], getName().c_str(), filename); + case NumpyUtilities::HEADER_PARSE_ERROR: + FATAL_ERROR("Numpy header parsing error for file: %s", filename); + case NumpyUtilities::BUFFER_SIZE_MISMATCH: + FATAL_ERROR("Buffer size does not match numpy file size for tensor %s filename %s", getName().c_str(), + filename); + default: + FATAL_ERROR("Unknown error parsing Numpy file: %s", filename); + } + + switch (getDtype()) + { + case DType_FLOAT: + if (setTensorValueFloat(elements, fdatabuf)) + { + free(fdatabuf); + return 1; + } + break; + case DType_INT32: + case DType_AINT8: + case DType_UINT8: + case DType_INT4: + case DType_INT8: + case DType_INT16: + if (setTensorValueInt32(elements, i32databuf)) + { + free(i32databuf); + return 1; + } + break; + case DType_INT48: + if (setTensorValueInt64(elements, i64databuf)) + { + free(i64databuf); + return 1; + } + break; + case DType_BOOL: + if (setTensorValueBool(elements, bdatabuf)) + { + free(i32databuf); + return 1; + } + break; + default: + FATAL_ERROR("unsupported tensor type=%s", EnumNamesDType()[getDtype()]); + } + + setIsValid(); + + if (fdatabuf) + free(fdatabuf); + if (i32databuf) + free(i32databuf); + if (i64databuf) + free(i64databuf); + if (bdatabuf) + free(bdatabuf); + + return 0; +} + +int TosaReference::Tensor::writeToNpyFile(const char* filename) const +{ + float* fdatabuf = nullptr; + int32_t* i32databuf = nullptr; + int64_t* i64databuf = nullptr; + bool* bdatabuf = nullptr; + NumpyUtilities::NPError nperror; + int elements = getElementCount(); + + switch (getDtype()) + { + case DType_FLOAT: + fdatabuf = (float*)calloc(sizeof(float), elements); + ASSERT_MEM(fdatabuf); + + if (getTensorValueFloat(elements, fdatabuf)) + { + free(fdatabuf); + return 1; + } + + nperror = NumpyUtilities::writeToNpyFile(filename, shape, fdatabuf); + + free(fdatabuf); + break; + case DType_INT32: + case DType_AINT8: + case DType_UINT8: + case DType_INT4: + case DType_INT8: + case DType_INT16: + i32databuf = (int32_t*)calloc(sizeof(int32_t), elements); + ASSERT_MEM(i32databuf); + + if (getTensorValueInt32(elements, i32databuf)) + { + free(i32databuf); + return 1; + } + + nperror = NumpyUtilities::writeToNpyFile(filename, shape, i32databuf); + + free(i32databuf); + break; + case DType_INT48: + i64databuf = (int64_t*)calloc(sizeof(int64_t), elements); + ASSERT_MEM(i64databuf); + + if (getTensorValueInt64(elements, i64databuf)) + { + free(i64databuf); + return 1; + } + + nperror = NumpyUtilities::writeToNpyFile(filename, shape, i64databuf); + + free(i64databuf); + break; + case DType_BOOL: + bdatabuf = (bool*)calloc(sizeof(bool), elements); + ASSERT_MEM(bdatabuf); + + if (getTensorValueBool(elements, bdatabuf)) + { + free(bdatabuf); + return 1; + } + + nperror = NumpyUtilities::writeToNpyFile(filename, shape, bdatabuf); + + free(bdatabuf); + break; + default: + FATAL_ERROR("unsupported tensor type=%s", EnumNamesDType()[getDtype()]); + } + + switch (nperror) + { + case NumpyUtilities::NO_ERROR: + break; + case NumpyUtilities::FILE_NOT_FOUND: + FATAL_ERROR("writeToNpyFile: Cannot open output file %s", filename); + case NumpyUtilities::FILE_IO_ERROR: + FATAL_ERROR("writeToNpyFile: IO error writing file: %s", filename); + case NumpyUtilities::FILE_TYPE_MISMATCH: + FATAL_ERROR("writeToNpyFile: Tensor type and Numpy file type mismatch for tensor %s filename %s", + getName().c_str(), filename); + case NumpyUtilities::HEADER_PARSE_ERROR: + FATAL_ERROR("Numpy header parsing error for file: %s", filename); + case NumpyUtilities::BUFFER_SIZE_MISMATCH: + FATAL_ERROR("Buffer size does not match numpy file size for tensor %s filename %s", getName().c_str(), + filename); + default: + FATAL_ERROR("Unknown error writing Numpy file: %s", filename); + } + + return 0; +} + +template <class T> +int TosaReference::TensorTemplate<T>::copyValueFrom(TosaReference::Tensor* src) +{ + FATAL_ERROR("TensorTemplate<T>::copyValueFrom should not be called. " + "Implement template specialization version."); + return 0; +} + +#define DEF_CTENSOR_COPY_VALUE_FROM(RANK, TYPE) \ + template <> \ + int TosaReference::Tensor##RANK<TYPE>::copyValueFrom(TosaReference::Tensor* src) \ + { \ + TosaReference::Tensor##RANK<TYPE>* t = dynamic_cast<Tensor##RANK<TYPE>*>(src); \ + if (!t) \ + { \ + WARNING("tensor %s templated class does not match %s", src->getName().c_str(), this->getName().c_str()); \ + return 1; \ + } \ + \ + uint32_t src_rank = src->getRank(); \ + uint32_t dst_rank = this->getRank(); \ + DType src_dtype = src->getDtype(); \ + DType dst_dtype = this->getDtype(); \ + bool tensor_match = true; \ + \ + if ((src_rank != dst_rank) || (src_dtype != dst_dtype)) \ + { \ + tensor_match = false; \ + } \ + else \ + { \ + for (uint32_t i = 0; i < src_rank; i++) \ + { \ + int src_dim = src->getShape()[i]; \ + int dst_dim = this->getShape()[i]; \ + if (src_dim != dst_dim) \ + { \ + tensor_match = false; \ + } \ + } \ + } \ + \ + if (!tensor_match) \ + { \ + WARNING("source tensor %s (rank=%u, dtype=%s, shape=%s) doesn't match destination tensor %s (rank=%u, " \ + "dtype=%s, shape=%s)", \ + src->getName().c_str(), src_rank, EnumNamesDType()[src_dtype], src->getShapeAsString().c_str(), \ + this->getName().c_str(), dst_rank, EnumNamesDType()[dst_dtype], this->getShapeAsString().c_str()); \ + return 1; \ + } \ + \ + this->getTensor() = t->getTensor(); \ + return 0; \ + } + +DEF_CTENSOR_COPY_VALUE_FROM(0, float) +DEF_CTENSOR_COPY_VALUE_FROM(1, float) +DEF_CTENSOR_COPY_VALUE_FROM(2, float) +DEF_CTENSOR_COPY_VALUE_FROM(3, float) +DEF_CTENSOR_COPY_VALUE_FROM(4, float) +DEF_CTENSOR_COPY_VALUE_FROM(5, float) +DEF_CTENSOR_COPY_VALUE_FROM(6, float) +DEF_CTENSOR_COPY_VALUE_FROM(0, int32_t) +DEF_CTENSOR_COPY_VALUE_FROM(1, int32_t) +DEF_CTENSOR_COPY_VALUE_FROM(2, int32_t) +DEF_CTENSOR_COPY_VALUE_FROM(3, int32_t) +DEF_CTENSOR_COPY_VALUE_FROM(4, int32_t) +DEF_CTENSOR_COPY_VALUE_FROM(5, int32_t) +DEF_CTENSOR_COPY_VALUE_FROM(6, int32_t) +DEF_CTENSOR_COPY_VALUE_FROM(0, int64_t) +DEF_CTENSOR_COPY_VALUE_FROM(1, int64_t) +DEF_CTENSOR_COPY_VALUE_FROM(2, int64_t) +DEF_CTENSOR_COPY_VALUE_FROM(3, int64_t) +DEF_CTENSOR_COPY_VALUE_FROM(4, int64_t) +DEF_CTENSOR_COPY_VALUE_FROM(5, int64_t) +DEF_CTENSOR_COPY_VALUE_FROM(6, int64_t) +DEF_CTENSOR_COPY_VALUE_FROM(0, bool) +DEF_CTENSOR_COPY_VALUE_FROM(1, bool) +DEF_CTENSOR_COPY_VALUE_FROM(2, bool) +DEF_CTENSOR_COPY_VALUE_FROM(3, bool) +DEF_CTENSOR_COPY_VALUE_FROM(4, bool) +DEF_CTENSOR_COPY_VALUE_FROM(5, bool) +DEF_CTENSOR_COPY_VALUE_FROM(6, bool) + +#undef DEF_CTENSOR_COPY_VALUE_FROM + +template <class T> +int TosaReference::TensorTemplate<T>::setTensorValueFloat(const size_t buflen, const float* vals) +{ + FATAL_ERROR("TensorTemplate<T>::setTensorValueFloat should not be called. " + "Implement template specialization version."); + return 0; +} + +template <> +int TosaReference::Tensor0<float>::setTensorValueFloat(const size_t bufLen, const float* vals) +{ + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + (*tensor)(0) = vals[0]; + + return 0; +} + +template <> +int TosaReference::Tensor1<float>::setTensorValueFloat(const size_t bufLen, const float* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + (*tensor)(i0) = vals[idx++]; + } + + return 0; +} + +template <> +int TosaReference::Tensor2<float>::setTensorValueFloat(const size_t bufLen, const float* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + (*tensor)(i0, i1) = vals[idx++]; + } + } + + return 0; +} + +template <> +int TosaReference::Tensor3<float>::setTensorValueFloat(const size_t bufLen, const float* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + (*tensor)(i0, i1, i2) = vals[idx++]; + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor4<float>::setTensorValueFloat(const size_t bufLen, const float* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + (*tensor)(i0, i1, i2, i3) = vals[idx++]; + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor5<float>::setTensorValueFloat(const size_t bufLen, const float* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + (*tensor)(i0, i1, i2, i3, i4) = vals[idx++]; + } + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor6<float>::setTensorValueFloat(const size_t bufLen, const float* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + for (int i5 = 0; i5 < shape[5]; i5++) + { + (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++]; + } + } + } + } + } + } + return 0; +} + +template <class T> +int TosaReference::TensorTemplate<T>::setTensorValueInt32(const size_t bufLen, const int32_t* vals) +{ + FATAL_ERROR("TensorTemplate<T>::setTensorValueInt32 should not be called. " + "Implement template specialization version."); + return 0; +} + +template <> +int TosaReference::Tensor0<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals) +{ + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + (*tensor)(0) = vals[0]; + + return 0; +} + +template <> +int TosaReference::Tensor1<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + (*tensor)(i0) = vals[idx++]; + } + + return 0; +} + +template <> +int TosaReference::Tensor2<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + (*tensor)(i0, i1) = vals[idx++]; + } + } + + return 0; +} + +template <> +int TosaReference::Tensor3<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + (*tensor)(i0, i1, i2) = vals[idx++]; + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor4<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + (*tensor)(i0, i1, i2, i3) = vals[idx++]; + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor5<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + (*tensor)(i0, i1, i2, i3, i4) = vals[idx++]; + } + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor6<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + for (int i5 = 0; i5 < shape[5]; i5++) + { + (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++]; + } + } + } + } + } + } + return 0; +} + +template <class T> +int TosaReference::TensorTemplate<T>::setTensorValueInt64(const size_t bufLen, const int64_t* vals) +{ + FATAL_ERROR("TensorTemplate<T>::setTensorValueInt64 should not be called. " + "Implement template specialization version."); + return 0; +} + +template <> +int TosaReference::Tensor0<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals) +{ + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + (*tensor)(0) = vals[0]; + + return 0; +} + +template <> +int TosaReference::Tensor1<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + (*tensor)(i0) = vals[idx++]; + } + + return 0; +} + +template <> +int TosaReference::Tensor2<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + (*tensor)(i0, i1) = vals[idx++]; + } + } + + return 0; +} + +template <> +int TosaReference::Tensor3<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + (*tensor)(i0, i1, i2) = vals[idx++]; + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor4<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + (*tensor)(i0, i1, i2, i3) = vals[idx++]; + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor5<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + (*tensor)(i0, i1, i2, i3, i4) = vals[idx++]; + } + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor6<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + for (int i5 = 0; i5 < shape[5]; i5++) + { + (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++]; + } + } + } + } + } + } + return 0; +} + +template <class T> +int TosaReference::TensorTemplate<T>::setTensorValueBool(const size_t buflen, const bool* vals) +{ + FATAL_ERROR("TensorTemplate<T>::setTensorValueBool should not be called. " + "Implement template specialization version."); + return 0; +} + +template <> +int TosaReference::Tensor0<bool>::setTensorValueBool(const size_t bufLen, const bool* vals) +{ + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + (*tensor)(0) = vals[0]; + + return 0; +} + +template <> +int TosaReference::Tensor1<bool>::setTensorValueBool(const size_t bufLen, const bool* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + (*tensor)(i0) = vals[idx++]; + } + + return 0; +} + +template <> +int TosaReference::Tensor2<bool>::setTensorValueBool(const size_t bufLen, const bool* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + (*tensor)(i0, i1) = vals[idx++]; + } + } + + return 0; +} + +template <> +int TosaReference::Tensor3<bool>::setTensorValueBool(const size_t bufLen, const bool* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + (*tensor)(i0, i1, i2) = vals[idx++]; + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor4<bool>::setTensorValueBool(const size_t bufLen, const bool* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + (*tensor)(i0, i1, i2, i3) = vals[idx++]; + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor5<bool>::setTensorValueBool(const size_t bufLen, const bool* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + (*tensor)(i0, i1, i2, i3, i4) = vals[idx++]; + } + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor6<bool>::setTensorValueBool(const size_t bufLen, const bool* vals) +{ + uint32_t idx = 0; + + ASSERT_MSG(bufLen == getElementCount(), "Total elements must match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + for (int i5 = 0; i5 < shape[5]; i5++) + { + (*tensor)(i0, i1, i2, i3, i4, i5) = vals[idx++]; + } + } + } + } + } + } + return 0; +} + +template <class T> +int TosaReference::TensorTemplate<T>::getTensorValueFloat(const size_t bufLen, float* vals) const +{ + FATAL_ERROR("TensorTemplate<T>::getTensorValueFloat should not be called. " + "Implement template specialization version."); + return 0; +} + +template <> +int TosaReference::Tensor0<float>::getTensorValueFloat(const size_t bufLen, float* vals) const +{ + int totalVals = 1; + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + vals[0] = (*tensor)(0); + + return 0; +} + +template <> +int TosaReference::Tensor1<float>::getTensorValueFloat(const size_t bufLen, float* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + vals[idx++] = (*tensor)(i0); + } + + return 0; +} + +template <> +int TosaReference::Tensor2<float>::getTensorValueFloat(const size_t bufLen, float* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + vals[idx++] = (*tensor)(i0, i1); + } + } + + return 0; +} + +template <> +int TosaReference::Tensor3<float>::getTensorValueFloat(const size_t bufLen, float* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + vals[idx++] = (*tensor)(i0, i1, i2); + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor4<float>::getTensorValueFloat(const size_t bufLen, float* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3); + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor5<float>::getTensorValueFloat(const size_t bufLen, float* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3, i4); + } + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor6<float>::getTensorValueFloat(const size_t bufLen, float* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + for (int i5 = 0; i5 < shape[5]; i5++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5); + } + } + } + } + } + } + return 0; +} + +template <class T> +int TosaReference::TensorTemplate<T>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const +{ + FATAL_ERROR("TensorTemplate<T>::getTensorValueInt32 should not be called. " + "Implement template specialization version."); + return 0; +} + +template <> +int TosaReference::Tensor0<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const +{ + int totalVals = 1; + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + vals[0] = (*tensor)(0); + + return 0; +} + +template <> +int TosaReference::Tensor1<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + vals[idx++] = (*tensor)(i0); + } + + return 0; +} + +template <> +int TosaReference::Tensor2<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + vals[idx++] = (*tensor)(i0, i1); + } + } + + return 0; +} + +template <> +int TosaReference::Tensor3<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + vals[idx++] = (*tensor)(i0, i1, i2); + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor4<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3); + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor5<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3, i4); + } + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor6<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + for (int i5 = 0; i5 < shape[5]; i5++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5); + } + } + } + } + } + } + return 0; +} + +template <class T> +int TosaReference::TensorTemplate<T>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const +{ + FATAL_ERROR("TensorTemplate<T>::getTensorValueInt64 should not be called. " + "Implement template specialization version."); + return 0; +} + +template <> +int TosaReference::Tensor0<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const +{ + int totalVals = 1; + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + vals[0] = (*tensor)(0); + + return 0; +} + +template <> +int TosaReference::Tensor1<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + vals[idx++] = (*tensor)(i0); + } + + return 0; +} + +template <> +int TosaReference::Tensor2<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + vals[idx++] = (*tensor)(i0, i1); + } + } + + return 0; +} + +template <> +int TosaReference::Tensor3<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + vals[idx++] = (*tensor)(i0, i1, i2); + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor4<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3); + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor5<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3, i4); + } + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor6<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + for (int i5 = 0; i5 < shape[5]; i5++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5); + } + } + } + } + } + } + return 0; +} + +template <class T> +int TosaReference::TensorTemplate<T>::getTensorValueBool(const size_t bufLen, bool* vals) const +{ + FATAL_ERROR("TensorTemplate<T>::getTensorValueBool should not be called. " + "Implement template specialization version."); + return 0; +} + +template <> +int TosaReference::Tensor0<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const +{ + int totalVals = 1; + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + vals[0] = (*tensor)(0); + + return 0; +} + +template <> +int TosaReference::Tensor1<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + vals[idx++] = (*tensor)(i0); + } + + return 0; +} + +template <> +int TosaReference::Tensor2<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + vals[idx++] = (*tensor)(i0, i1); + } + } + + return 0; +} + +template <> +int TosaReference::Tensor3<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + vals[idx++] = (*tensor)(i0, i1, i2); + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor4<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3); + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor5<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3, i4); + } + } + } + } + } + + return 0; +} + +template <> +int TosaReference::Tensor6<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const +{ + uint32_t idx = 0; + int totalVals = 1; + + for (size_t i = 0; i < shape.size(); i++) + { + totalVals *= shape[i]; + } + + ASSERT_MSG((size_t)totalVals == bufLen, "Output buffer and tensor size do not match"); + + for (int i0 = 0; i0 < shape[0]; i0++) + { + for (int i1 = 0; i1 < shape[1]; i1++) + { + for (int i2 = 0; i2 < shape[2]; i2++) + { + for (int i3 = 0; i3 < shape[3]; i3++) + { + for (int i4 = 0; i4 < shape[4]; i4++) + { + for (int i5 = 0; i5 < shape[5]; i5++) + { + vals[idx++] = (*tensor)(i0, i1, i2, i3, i4, i5); + } + } + } + } + } + } + return 0; +} + +template <> +int TosaReference::Tensor0<float>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor0<float>(); + + if (tensor) + return 0; + else + return 1; +} +template <> +int TosaReference::Tensor1<float>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor1<float>(shape[0]); + if (tensor) + return 0; + else + return 1; +} +template <> +int TosaReference::Tensor2<float>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor2<float>(shape[0], shape[1]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor3<float>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor3<float>(shape[0], shape[1], shape[2]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor4<float>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor4<float>(shape[0], shape[1], shape[2], shape[3]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor5<float>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor5<float>(shape[0], shape[1], shape[2], shape[3], shape[4]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor6<float>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor6<float>(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor0<int32_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor0<int32_t>(); + if (tensor) + return 0; + else + return 1; +} +template <> +int TosaReference::Tensor1<int32_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor1<int32_t>(shape[0]); + if (tensor) + return 0; + else + return 1; +} +template <> +int TosaReference::Tensor2<int32_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor2<int32_t>(shape[0], shape[1]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor3<int32_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor3<int32_t>(shape[0], shape[1], shape[2]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor4<int32_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor4<int32_t>(shape[0], shape[1], shape[2], shape[3]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor5<int32_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor5<int32_t>(shape[0], shape[1], shape[2], shape[3], shape[4]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor6<int32_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor6<int32_t>(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor0<int64_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor0<int64_t>(); + if (tensor) + return 0; + else + return 1; +} +template <> +int TosaReference::Tensor1<int64_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor1<int64_t>(shape[0]); + if (tensor) + return 0; + else + return 1; +} +template <> +int TosaReference::Tensor2<int64_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor2<int64_t>(shape[0], shape[1]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor3<int64_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor3<int64_t>(shape[0], shape[1], shape[2]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor4<int64_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor4<int64_t>(shape[0], shape[1], shape[2], shape[3]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor5<int64_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor5<int64_t>(shape[0], shape[1], shape[2], shape[3], shape[4]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor6<int64_t>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor6<int64_t>(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor0<bool>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor0<bool>(); + if (tensor) + return 0; + else + return 1; +} +template <> +int TosaReference::Tensor1<bool>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor1<bool>(shape[0]); + if (tensor) + return 0; + else + return 1; +} +template <> +int TosaReference::Tensor2<bool>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor2<bool>(shape[0], shape[1]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor3<bool>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor3<bool>(shape[0], shape[1], shape[2]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor4<bool>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor4<bool>(shape[0], shape[1], shape[2], shape[3]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor5<bool>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor5<bool>(shape[0], shape[1], shape[2], shape[3], shape[4]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor6<bool>::allocate() +{ + ASSERT_MSG(tensor == nullptr, "Error: double allocate Eigen tensor"); + tensor = new ETensor6<bool>(shape[0], shape[1], shape[2], shape[3], shape[4], shape[5]); + if (tensor) + return 0; + else + return 1; +} + +template <> +int TosaReference::Tensor0<float>::dumpTensor(FILE* out) const +{ + char fp_fmt[FOF_STR_LEN]; + snprintf(fp_fmt, FOF_STR_LEN, "[ %%%sf ]\n", g_func_config.fp_format); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, fp_fmt, (*tensor)(0)); + + return 0; +} + +template <> +int TosaReference::Tensor1<float>::dumpTensor(FILE* out) const +{ + char fp_fmt[FOF_STR_LEN]; + snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, fp_fmt, (*tensor)(i0)); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor2<float>::dumpTensor(FILE* out) const +{ + char fp_fmt[FOF_STR_LEN]; + snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, fp_fmt, (*tensor)(i0, i1)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor3<float>::dumpTensor(FILE* out) const +{ + char fp_fmt[FOF_STR_LEN]; + snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, fp_fmt, (*tensor)(i0, i1, i2)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor4<float>::dumpTensor(FILE* out) const +{ + char fp_fmt[FOF_STR_LEN]; + snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, fp_fmt, (*tensor)(i0, i1, i2, i3)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor5<float>::dumpTensor(FILE* out) const +{ + char fp_fmt[FOF_STR_LEN]; + snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, "["); + for (int i4 = 0; i4 < shape[4]; i4++) + { + fprintf(out, fp_fmt, (*tensor)(i0, i1, i2, i3, i4)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor6<float>::dumpTensor(FILE* out) const +{ + char fp_fmt[FOF_STR_LEN]; + snprintf(fp_fmt, FOF_STR_LEN, " %%%sf ", g_func_config.fp_format); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, "["); + for (int i4 = 0; i4 < shape[4]; i4++) + { + fprintf(out, "["); + for (int i5 = 0; i5 < shape[5]; i5++) + { + fprintf(out, fp_fmt, (*tensor)(i0, i1, i2, i3, i4, i5)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor0<int64_t>::dumpTensor(FILE* out) const +{ + char i64_fmt[FOF_STR_LEN]; + snprintf(i64_fmt, FOF_STR_LEN, "[ %%ld ]\n"); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, i64_fmt, (*tensor)(0)); + + return 0; +} + +template <> +int TosaReference::Tensor1<int64_t>::dumpTensor(FILE* out) const +{ + char i64_fmt[FOF_STR_LEN]; + snprintf(i64_fmt, FOF_STR_LEN, " %%ld "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, i64_fmt, (*tensor)(i0)); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor2<int64_t>::dumpTensor(FILE* out) const +{ + char i64_fmt[FOF_STR_LEN]; + snprintf(i64_fmt, FOF_STR_LEN, " %%ld "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, i64_fmt, (*tensor)(i0, i1)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor3<int64_t>::dumpTensor(FILE* out) const +{ + char i64_fmt[FOF_STR_LEN]; + snprintf(i64_fmt, FOF_STR_LEN, " %%ld "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, i64_fmt, (*tensor)(i0, i1, i2)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor4<int64_t>::dumpTensor(FILE* out) const +{ + char i64_fmt[FOF_STR_LEN]; + snprintf(i64_fmt, FOF_STR_LEN, " %%ld "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, i64_fmt, (*tensor)(i0, i1, i2, i3)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor5<int64_t>::dumpTensor(FILE* out) const +{ + char i64_fmt[FOF_STR_LEN]; + snprintf(i64_fmt, FOF_STR_LEN, " %%ld "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, "["); + for (int i4 = 0; i4 < shape[4]; i4++) + { + fprintf(out, i64_fmt, (*tensor)(i0, i1, i2, i3, i4)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor6<int64_t>::dumpTensor(FILE* out) const +{ + char i64_fmt[FOF_STR_LEN]; + snprintf(i64_fmt, FOF_STR_LEN, " %%ld "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, "["); + for (int i4 = 0; i4 < shape[4]; i4++) + { + fprintf(out, "["); + for (int i5 = 0; i5 < shape[5]; i5++) + { + fprintf(out, i64_fmt, (*tensor)(i0, i1, i2, i3, i4, i5)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor0<int32_t>::dumpTensor(FILE* out) const +{ + char i32_fmt[FOF_STR_LEN]; + snprintf(i32_fmt, FOF_STR_LEN, "[ %%d ]\n"); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, i32_fmt, (*tensor)(0)); + + return 0; +} + +template <> +int TosaReference::Tensor1<int32_t>::dumpTensor(FILE* out) const +{ + char i32_fmt[FOF_STR_LEN]; + snprintf(i32_fmt, FOF_STR_LEN, " %%d "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, i32_fmt, (*tensor)(i0)); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor2<int32_t>::dumpTensor(FILE* out) const +{ + char i32_fmt[FOF_STR_LEN]; + snprintf(i32_fmt, FOF_STR_LEN, " %%d "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, i32_fmt, (*tensor)(i0, i1)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor3<int32_t>::dumpTensor(FILE* out) const +{ + char i32_fmt[FOF_STR_LEN]; + snprintf(i32_fmt, FOF_STR_LEN, " %%d "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, i32_fmt, (*tensor)(i0, i1, i2)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor4<int32_t>::dumpTensor(FILE* out) const +{ + char i32_fmt[FOF_STR_LEN]; + snprintf(i32_fmt, FOF_STR_LEN, " %%d "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, i32_fmt, (*tensor)(i0, i1, i2, i3)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor5<int32_t>::dumpTensor(FILE* out) const +{ + char i32_fmt[FOF_STR_LEN]; + snprintf(i32_fmt, FOF_STR_LEN, " %%d "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, "["); + for (int i4 = 0; i4 < shape[4]; i4++) + { + fprintf(out, i32_fmt, (*tensor)(i0, i1, i2, i3, i4)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor6<int32_t>::dumpTensor(FILE* out) const +{ + char i32_fmt[FOF_STR_LEN]; + snprintf(i32_fmt, FOF_STR_LEN, " %%d "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, "["); + for (int i4 = 0; i4 < shape[4]; i4++) + { + fprintf(out, "["); + for (int i5 = 0; i5 < shape[5]; i5++) + { + fprintf(out, i32_fmt, (*tensor)(i0, i1, i2, i3, i4, i5)); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor0<bool>::dumpTensor(FILE* out) const +{ + char bool_fmt[FOF_STR_LEN]; + snprintf(bool_fmt, FOF_STR_LEN, "[ %%s ]\n"); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, bool_fmt, bool_to_str((*tensor)(0))); + + return 0; +} + +template <> +int TosaReference::Tensor1<bool>::dumpTensor(FILE* out) const +{ + char bool_fmt[FOF_STR_LEN]; + snprintf(bool_fmt, FOF_STR_LEN, " %%s "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, bool_fmt, bool_to_str((*tensor)(i0))); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor2<bool>::dumpTensor(FILE* out) const +{ + char bool_fmt[FOF_STR_LEN]; + snprintf(bool_fmt, FOF_STR_LEN, " %%s "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1))); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor3<bool>::dumpTensor(FILE* out) const +{ + char bool_fmt[FOF_STR_LEN]; + snprintf(bool_fmt, FOF_STR_LEN, " %%s "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1, i2))); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor4<bool>::dumpTensor(FILE* out) const +{ + char bool_fmt[FOF_STR_LEN]; + snprintf(bool_fmt, FOF_STR_LEN, " %%s "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1, i2, i3))); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor5<bool>::dumpTensor(FILE* out) const +{ + char bool_fmt[FOF_STR_LEN]; + snprintf(bool_fmt, FOF_STR_LEN, " %%s "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, "["); + for (int i4 = 0; i4 < shape[4]; i4++) + { + fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1, i2, i3, i4))); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <> +int TosaReference::Tensor6<bool>::dumpTensor(FILE* out) const +{ + char bool_fmt[FOF_STR_LEN]; + snprintf(bool_fmt, FOF_STR_LEN, " %%s "); + + if (tensor == nullptr) + { + fprintf(out, "<Not allocated>\n"); + return 0; + } + + fprintf(out, "["); + for (int i0 = 0; i0 < shape[0]; i0++) + { + fprintf(out, "["); + for (int i1 = 0; i1 < shape[1]; i1++) + { + fprintf(out, "["); + for (int i2 = 0; i2 < shape[2]; i2++) + { + fprintf(out, "["); + for (int i3 = 0; i3 < shape[3]; i3++) + { + fprintf(out, "["); + for (int i4 = 0; i4 < shape[4]; i4++) + { + fprintf(out, "["); + for (int i5 = 0; i5 < shape[5]; i5++) + { + fprintf(out, bool_fmt, bool_to_str((*tensor)(i0, i1, i2, i3, i4, i5))); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + } + fprintf(out, "]\n"); + + return 0; +} + +template <class T> +int TosaReference::TensorTemplate<T>::dumpTensor(FILE* out) const +{ + return 0; +} + +// template explicit specialization +template class TosaReference::TensorTemplate<Eigen::Tensor<float, 0>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<float, 1>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<float, 2>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<float, 3>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<float, 4>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<float, 5>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<float, 6>>; + +template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 0>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 1>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 2>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 3>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 4>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 5>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int32_t, 6>>; + +template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 0>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 1>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 2>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 3>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 4>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 5>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<int64_t, 6>>; + +template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 0>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 1>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 2>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 3>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 4>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 5>>; +template class TosaReference::TensorTemplate<Eigen::Tensor<bool, 6>>; diff --git a/reference_model/src/tensor.h b/reference_model/src/tensor.h new file mode 100644 index 0000000..2fd37cd --- /dev/null +++ b/reference_model/src/tensor.h @@ -0,0 +1,815 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef TOSA_REFERENCE_TENSOR_H +#define TOSA_REFERENCE_TENSOR_H + +#include "model_common.h" +#include "ops/template_types.h" +#include "tosa_generated.h" +#include "tosa_serialization_handler.h" +#include <Eigen/CXX11/Tensor> +#include <list> +#include <vector> + +using namespace tosa; + +namespace TosaReference +{ +class GraphNode; + +class Tensor +{ +public: + Tensor(std::string tensorName_, + DType tensorDtype__, + const std::vector<Usage>& tensorUsage_, + const std::vector<Format>& tensorFormat_, + std::vector<int> shape_, + int isConst_); + + virtual ~Tensor(); + + int setIsSubgraphInput(); + int setIsSubgraphOutput(); + + int getIsSubgraphInput() const + { + return isSubgraphInput; + } + + int getIsSubgraphOutput() const + { + return isSubgraphOutput; + } + + int setProducer(GraphNode* node); + int addConsumer(GraphNode* node); + + int setIsValid() + { + isValid = 1; + return 0; + } + + int clearIsValid() + { + isValid = 0; + return 0; + } + + int getIsValid() const + { + return isValid; + } + + int getIsConst() const + { + return isConst; + } + + GraphNode* getProducer() + { + return producer; + } + + std::vector<GraphNode*>& getConsumers() + { + return consumers; + } + + const std::string& getName() const + { + return tensorName; + } + + const std::vector<int>& getShape() const + { + return shape; + } + + std::string getShapeAsString() const + { + std::string shape_str("["); + for (auto& dim : shape) + { + shape_str += (std::to_string(dim) + ", "); + } + shape_str.append("]"); + return shape_str; + } + + const std::vector<Usage>& getUsage() const + { + return tensorUsage; + } + + bool hasUsage(Usage usage) const + { + for (auto& usg : tensorUsage) + { + if (usg == usage) + { + return true; + } + } + return false; + } + + std::string getUsageAsString() const + { + std::string usage_str("["); + for (auto& usg : tensorUsage) + { + usage_str += (std::string(EnumNamesUsage()[usg]) + ", "); + } + usage_str.append("]"); + return usage_str; + } + + const std::vector<Format>& getFormat() const + { + return tensorFormat; + } + + bool hasFormat(Format format) const + { + for (auto& fmt : tensorFormat) + { + if (fmt == format) + { + return true; + } + } + return false; + } + + std::string getFormatAsString() const + { + std::string format_str("["); + for (auto& fmt : tensorFormat) + { + format_str += (std::string(EnumNamesFormat()[fmt]) + ", "); + } + format_str.append("]"); + return format_str; + } + + const uint32_t getElementCount() const + { + uint32_t elements = 1; + for (size_t i = 0; i < shape.size(); i++) + elements *= shape[i]; + + return elements; + } + + // Comparison of rank and type with other tensors + const int matchRank(const Tensor& ref) const + { + return (ref.shape.size() == shape.size()) ? 0 : 1; + } + + const int matchType(const Tensor& ref) const + { + return (ref.tensorDtype == tensorDtype) ? 0 : 1; + } + + const int matchRankType(const Tensor& ref) const + { + return (matchType(ref) || matchRank(ref)); + } + + const int matchRankTypeShape(const Tensor& ref, const bool broadcastOk = false) const + { + if (matchRankType(ref)) + return 1; + + for (size_t i = 0; i < shape.size(); i++) + { + if (shape[i] != ref.shape[i]) + { + if (!broadcastOk || + // For broadcasts, at least one operand must have size 1 + // if they don't both match + (broadcastOk && (shape[i] != 1 && ref.shape[i] != 1))) + { + return 1; + } + } + } + + return 0; + } + + // Sometimes we might want to match several semi-compatible types, + // so just check rank and size here + const int matchRankSize(const Tensor& ref) const + { + if (matchRank(ref)) + return 1; + + for (size_t i = 0; i < shape.size(); i++) + { + if (shape[i] != ref.shape[i]) + return 1; + } + + return 0; + } + + // Unary check to make sure rank matches + const int checkRequiredRank(const int exactRank) const + { + return (shape.size() == (size_t)exactRank) ? 0 : 1; + } + + const int checkRequiredRank(const int minRank, const int maxRank) const + { + return (shape.size() >= (size_t)minRank && shape.size() <= (size_t)maxRank) ? 0 : 1; + } + + const int getRank() const + { + return shape.size(); + } + + const DType getDtype() const + { + return tensorDtype; + } + + virtual int dumpTensor(FILE* out) const = 0; + virtual int dumpTensorParams(FILE* out) const; + virtual int dumpTensorParams(std::ostream& out) const; + + virtual int setTensorValueFloat(const size_t bufLen, const float* vals) = 0; + virtual int setTensorValueInt32(const size_t bufLen, const int32_t* vals) = 0; + virtual int setTensorValueInt64(const size_t bufLen, const int64_t* vals) = 0; + virtual int setTensorValueBool(const size_t bufLen, const bool* vals) = 0; + virtual int getTensorValueFloat(const size_t bufLen, float* fbuf) const = 0; + virtual int getTensorValueInt32(const size_t bufLen, int32_t* ibuf) const = 0; + virtual int getTensorValueInt64(const size_t bufLen, int64_t* ibuf) const = 0; + virtual int getTensorValueBool(const size_t bufLen, bool* ibuf) const = 0; + + virtual int readFromNpyFile(const char* filename); + virtual int writeToNpyFile(const char* filename) const; + virtual int copyValueFrom(Tensor* tensor) = 0; + + const char* bool_to_str(bool in) const + { + static const char* true_str = "true"; + static const char* false_str = "false"; + return in ? true_str : false_str; + } + + virtual int allocate() = 0; + virtual int deallocate() = 0; + virtual bool is_allocated() = 0; + +protected: + std::string tensorName; + DType tensorDtype; + std::vector<Usage> tensorUsage; + std::vector<Format> tensorFormat; + int isConst; + int isValid; + std::vector<int> shape; + int isSubgraphInput; + int isSubgraphOutput; + bool isAllocated; + + GraphNode* producer; + std::vector<GraphNode*> consumers; + + // Note: the Eigen::Tensor is not declared in Tensor + // Instead, the TensorTemplate class keeps the templated tensor + // declaration so that the graph manipulation tools are isolated + // from the templated tensor type. + // + // Operators need to be aware of the TensorTemplate<EigenTensor<type, rank>> type + // so that they can operate on the right types. +}; + +template <class T> +class TensorTemplate : public Tensor +{ +public: + TensorTemplate(std::string tensorName_, + DType tensorDtype_, + const std::vector<Usage>& tensorUsage_, + const std::vector<Format>& tensorFormat_, + std::vector<int> shape_, + int isConst_) + : Tensor(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, isConst_) + { + tensor = nullptr; + } + + virtual ~TensorTemplate() + { + deallocate(); + } + + virtual int allocate() + { + tensor = new T(); + if (tensor) + return 0; + else + return 1; + } + + virtual int deallocate() + { + if (tensor) + { + delete tensor; + } + tensor = nullptr; + return 0; + } + + virtual bool is_allocated() + { + if (tensor) + { + return true; + } + return false; + } + + T& getTensor() + { + return *tensor; + } + + virtual int dumpTensor(FILE* out) const; + + virtual int setTensorValueFloat(const size_t bufLen, const float* vals); + virtual int setTensorValueInt32(const size_t bufLen, const int32_t* vals); + virtual int setTensorValueInt64(const size_t bufLen, const int64_t* vals); + virtual int setTensorValueBool(const size_t bufLen, const bool* vals); + virtual int getTensorValueFloat(const size_t bufLen, float* fbuf) const; + virtual int getTensorValueInt32(const size_t bufLen, int32_t* ibuf) const; + virtual int getTensorValueInt64(const size_t bufLen, int64_t* ibuf) const; + virtual int getTensorValueBool(const size_t bufLen, bool* bbuf) const; + + virtual int copyValueFrom(Tensor* tensor); + +protected: + T* tensor; +}; + +// allocate() template specializations to allocate the different tensor sizes +// Let the compiler know here before the factory uses them, but define them in the .cc file. +template <> +int Tensor0<float>::allocate(); +template <> +int Tensor1<float>::allocate(); +template <> +int Tensor2<float>::allocate(); +template <> +int Tensor3<float>::allocate(); +template <> +int Tensor4<float>::allocate(); +template <> +int Tensor5<float>::allocate(); +template <> +int Tensor6<float>::allocate(); + +template <> +int Tensor0<int32_t>::allocate(); +template <> +int Tensor1<int32_t>::allocate(); +template <> +int Tensor2<int32_t>::allocate(); +template <> +int Tensor3<int32_t>::allocate(); +template <> +int Tensor4<int32_t>::allocate(); +template <> +int Tensor5<int32_t>::allocate(); +template <> +int Tensor6<int32_t>::allocate(); + +template <> +int Tensor0<int64_t>::allocate(); +template <> +int Tensor1<int64_t>::allocate(); +template <> +int Tensor2<int64_t>::allocate(); +template <> +int Tensor3<int64_t>::allocate(); +template <> +int Tensor4<int64_t>::allocate(); +template <> +int Tensor5<int64_t>::allocate(); +template <> +int Tensor6<int64_t>::allocate(); + +template <> +int Tensor0<bool>::allocate(); +template <> +int Tensor1<bool>::allocate(); +template <> +int Tensor2<bool>::allocate(); +template <> +int Tensor3<bool>::allocate(); +template <> +int Tensor4<bool>::allocate(); +template <> +int Tensor5<bool>::allocate(); +template <> +int Tensor6<bool>::allocate(); + +template <> +int Tensor0<float>::copyValueFrom(Tensor* src); +template <> +int Tensor1<float>::copyValueFrom(Tensor* src); +template <> +int Tensor2<float>::copyValueFrom(Tensor* src); +template <> +int Tensor3<float>::copyValueFrom(Tensor* src); +template <> +int Tensor4<float>::copyValueFrom(Tensor* src); +template <> +int Tensor5<float>::copyValueFrom(Tensor* src); +template <> +int Tensor6<float>::copyValueFrom(Tensor* src); + +template <> +int Tensor0<int32_t>::copyValueFrom(Tensor* src); +template <> +int Tensor1<int32_t>::copyValueFrom(Tensor* src); +template <> +int Tensor2<int32_t>::copyValueFrom(Tensor* src); +template <> +int Tensor3<int32_t>::copyValueFrom(Tensor* src); +template <> +int Tensor4<int32_t>::copyValueFrom(Tensor* src); +template <> +int Tensor5<int32_t>::copyValueFrom(Tensor* src); +template <> +int Tensor6<int32_t>::copyValueFrom(Tensor* src); + +template <> +int Tensor0<int64_t>::copyValueFrom(Tensor* src); +template <> +int Tensor1<int64_t>::copyValueFrom(Tensor* src); +template <> +int Tensor2<int64_t>::copyValueFrom(Tensor* src); +template <> +int Tensor3<int64_t>::copyValueFrom(Tensor* src); +template <> +int Tensor4<int64_t>::copyValueFrom(Tensor* src); +template <> +int Tensor5<int64_t>::copyValueFrom(Tensor* src); +template <> +int Tensor6<int64_t>::copyValueFrom(Tensor* src); + +template <> +int Tensor0<bool>::copyValueFrom(Tensor* src); +template <> +int Tensor1<bool>::copyValueFrom(Tensor* src); +template <> +int Tensor2<bool>::copyValueFrom(Tensor* src); +template <> +int Tensor3<bool>::copyValueFrom(Tensor* src); +template <> +int Tensor4<bool>::copyValueFrom(Tensor* src); +template <> +int Tensor5<bool>::copyValueFrom(Tensor* src); +template <> +int Tensor6<bool>::copyValueFrom(Tensor* src); + +template <> +int Tensor0<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals); +template <> +int Tensor1<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals); +template <> +int Tensor2<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals); +template <> +int Tensor3<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals); +template <> +int Tensor4<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals); +template <> +int Tensor5<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals); +template <> +int Tensor6<int32_t>::setTensorValueInt32(const size_t bufLen, const int32_t* vals); + +template <> +int Tensor0<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const; +template <> +int Tensor1<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const; +template <> +int Tensor2<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const; +template <> +int Tensor3<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const; +template <> +int Tensor4<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const; +template <> +int Tensor5<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const; +template <> +int Tensor6<int32_t>::getTensorValueInt32(const size_t bufLen, int32_t* vals) const; + +template <> +int Tensor0<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals); +template <> +int Tensor1<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals); +template <> +int Tensor2<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals); +template <> +int Tensor3<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals); +template <> +int Tensor4<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals); +template <> +int Tensor5<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals); +template <> +int Tensor6<int64_t>::setTensorValueInt64(const size_t bufLen, const int64_t* vals); + +template <> +int Tensor0<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const; +template <> +int Tensor1<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const; +template <> +int Tensor2<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const; +template <> +int Tensor3<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const; +template <> +int Tensor4<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const; +template <> +int Tensor5<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const; +template <> +int Tensor6<int64_t>::getTensorValueInt64(const size_t bufLen, int64_t* vals) const; + +template <> +int Tensor0<float>::setTensorValueFloat(const size_t bufLen, const float* vals); +template <> +int Tensor1<float>::setTensorValueFloat(const size_t bufLen, const float* vals); +template <> +int Tensor2<float>::setTensorValueFloat(const size_t bufLen, const float* vals); +template <> +int Tensor3<float>::setTensorValueFloat(const size_t bufLen, const float* vals); +template <> +int Tensor4<float>::setTensorValueFloat(const size_t bufLen, const float* vals); +template <> +int Tensor5<float>::setTensorValueFloat(const size_t bufLen, const float* vals); +template <> +int Tensor6<float>::setTensorValueFloat(const size_t bufLen, const float* vals); + +template <> +int Tensor0<float>::getTensorValueFloat(const size_t bufLen, float* vals) const; +template <> +int Tensor1<float>::getTensorValueFloat(const size_t bufLen, float* vals) const; +template <> +int Tensor2<float>::getTensorValueFloat(const size_t bufLen, float* vals) const; +template <> +int Tensor3<float>::getTensorValueFloat(const size_t bufLen, float* vals) const; +template <> +int Tensor4<float>::getTensorValueFloat(const size_t bufLen, float* vals) const; +template <> +int Tensor5<float>::getTensorValueFloat(const size_t bufLen, float* vals) const; +template <> +int Tensor6<float>::getTensorValueFloat(const size_t bufLen, float* vals) const; + +template <> +int Tensor0<bool>::setTensorValueBool(const size_t bufLen, const bool* vals); +template <> +int Tensor1<bool>::setTensorValueBool(const size_t bufLen, const bool* vals); +template <> +int Tensor2<bool>::setTensorValueBool(const size_t bufLen, const bool* vals); +template <> +int Tensor3<bool>::setTensorValueBool(const size_t bufLen, const bool* vals); +template <> +int Tensor4<bool>::setTensorValueBool(const size_t bufLen, const bool* vals); +template <> +int Tensor5<bool>::setTensorValueBool(const size_t bufLen, const bool* vals); +template <> +int Tensor6<bool>::setTensorValueBool(const size_t bufLen, const bool* vals); + +template <> +int Tensor0<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const; +template <> +int Tensor1<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const; +template <> +int Tensor2<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const; +template <> +int Tensor3<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const; +template <> +int Tensor4<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const; +template <> +int Tensor5<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const; +template <> +int Tensor6<bool>::getTensorValueBool(const size_t bufLen, bool* vals) const; + +// assume we only dump float type tensor now +template <> +int Tensor0<float>::dumpTensor(FILE* out) const; +template <> +int Tensor1<float>::dumpTensor(FILE* out) const; +template <> +int Tensor2<float>::dumpTensor(FILE* out) const; +template <> +int Tensor3<float>::dumpTensor(FILE* out) const; +template <> +int Tensor4<float>::dumpTensor(FILE* out) const; +template <> +int Tensor5<float>::dumpTensor(FILE* out) const; +template <> +int Tensor6<float>::dumpTensor(FILE* out) const; +template <> +int Tensor0<int32_t>::dumpTensor(FILE* out) const; +template <> +int Tensor1<int32_t>::dumpTensor(FILE* out) const; +template <> +int Tensor2<int32_t>::dumpTensor(FILE* out) const; +template <> +int Tensor3<int32_t>::dumpTensor(FILE* out) const; +template <> +int Tensor4<int32_t>::dumpTensor(FILE* out) const; +template <> +int Tensor5<int32_t>::dumpTensor(FILE* out) const; +template <> +int Tensor6<int32_t>::dumpTensor(FILE* out) const; +template <> +int Tensor0<int64_t>::dumpTensor(FILE* out) const; +template <> +int Tensor1<int64_t>::dumpTensor(FILE* out) const; +template <> +int Tensor2<int64_t>::dumpTensor(FILE* out) const; +template <> +int Tensor3<int64_t>::dumpTensor(FILE* out) const; +template <> +int Tensor4<int64_t>::dumpTensor(FILE* out) const; +template <> +int Tensor5<int64_t>::dumpTensor(FILE* out) const; +template <> +int Tensor6<int64_t>::dumpTensor(FILE* out) const; +template <> +int Tensor0<bool>::dumpTensor(FILE* out) const; +template <> +int Tensor1<bool>::dumpTensor(FILE* out) const; +template <> +int Tensor2<bool>::dumpTensor(FILE* out) const; +template <> +int Tensor3<bool>::dumpTensor(FILE* out) const; +template <> +int Tensor4<bool>::dumpTensor(FILE* out) const; +template <> +int Tensor5<bool>::dumpTensor(FILE* out) const; +template <> +int Tensor6<bool>::dumpTensor(FILE* out) const; + +class TensorFactory +{ +public: + static Tensor* newTensor(std::string tensorName_, + DType tensorDtype_, + const std::vector<Usage>& tensorUsage_, + const std::vector<Format>& tensorFormat_, + std::vector<int> shape_, + int isConst_, + const uint32_t rank) + { + switch (tensorDtype_) + { + case DType_FLOAT: + switch (rank) + { + case 0: + return new Tensor0<float>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 1: + return new Tensor1<float>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 2: + return new Tensor2<float>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 3: + return new Tensor3<float>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 4: + return new Tensor4<float>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 5: + return new Tensor5<float>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 6: + return new Tensor6<float>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + default: + goto done; + } + case DType_INT32: + case DType_AINT8: + case DType_UINT8: + case DType_INT4: + case DType_INT8: + case DType_INT16: + switch (rank) + { + case 0: + return new Tensor0<int32_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 1: + return new Tensor1<int32_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 2: + return new Tensor2<int32_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 3: + return new Tensor3<int32_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 4: + return new Tensor4<int32_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 5: + return new Tensor5<int32_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 6: + return new Tensor6<int32_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + default: + goto done; + } + case DType_INT48: + switch (rank) + { + case 0: + return new Tensor0<int64_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 1: + return new Tensor1<int64_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 2: + return new Tensor2<int64_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 3: + return new Tensor3<int64_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 4: + return new Tensor4<int64_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 5: + return new Tensor5<int64_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 6: + return new Tensor6<int64_t>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + default: + goto done; + } + case DType_BOOL: + switch (rank) + { + case 0: + return new Tensor0<bool>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 1: + return new Tensor1<bool>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 2: + return new Tensor2<bool>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 3: + return new Tensor3<bool>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 4: + return new Tensor4<bool>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 5: + return new Tensor5<bool>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + case 6: + return new Tensor6<bool>(tensorName_, tensorDtype_, tensorUsage_, tensorFormat_, shape_, + isConst_); + default: + goto done; + } + default: + goto done; + } + + done: + FATAL_ERROR("Unsupported tensor name=%s, type=%s, rank=%d", tensorName_.c_str(), EnumNamesDType()[tensorDtype_], + rank); + } + + static Tensor* newTensor(DType type, const std::vector<int> shape); +}; +}; // namespace TosaReference + +#endif diff --git a/scripts/xunit/xunit.py b/scripts/xunit/xunit.py new file mode 100644 index 0000000..c636136 --- /dev/null +++ b/scripts/xunit/xunit.py @@ -0,0 +1,91 @@ + + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +from __future__ import print_function +import xml.etree.ElementTree as ET + +class xunit_results(): + def __init__(self, name='Testsuites'): + self.name = name + self.suites = [] + def create_suite(self, name): + s = xunit_suite(name) + self.suites.append(s) + return s + def write_results(self, filename): + suites = ET.Element(self.name) + tree = ET.ElementTree(suites) + for s in self.suites: + testsuite = ET.SubElement(suites, 'testsuite', {'name' : s.name, 'errors' : '0'}) + tests = 0 + failures = 0 + skip = 0 + for t in s.tests: + test = ET.SubElement(testsuite, 'testcase', {'name' : t.name, 'classname' : t.classname, 'time' : t.time}) + tests += 1 + if t.skip: + skip += 1 + ET.SubElement(test, 'skipped', {'type' : 'Skipped test'}) + if t.fail: + failures += 1 + fail = ET.SubElement(test, 'failure', {'type' : 'Test failed'}) + fail.text = t.fail + if t.sysout: + sysout = ET.SubElement(test, 'system-out') + sysout.text = t.sysout + if t.syserr: + syserr = ET.SubElement(test, 'system-err') + syserr.text = t.syserr + testsuite.attrib['tests'] = str(tests) + testsuite.attrib['failures'] = str(failures) + testsuite.attrib['skip'] = str(skip) + tree.write(filename, 'UTF-8', True) + + +class xunit_suite(): + def __init__(self, name): + self.name = name + self.tests = [] + +class xunit_test(): + def __init__(self, name, classname=None): + self.name = name + if classname: + self.classname = classname + else: + self.classname = name + self.time = '0.000' + self.fail = None + self.skip = False + self.sysout = None + self.syserr = None + def failed(self, text): + self.fail = text + def skipped(self): + self.skip = True + + +if __name__ == '__main__': + r = xunit_results() + s = r.create_suite('selftest') + for i in range(0,10): + t = xunit_test('atest' + str(i)) + if i == 3: + t.failed('Unknown failure foo') + if i == 7: + t.skipped() + s.tests.append(t) + r.write_results('foo.xml') diff --git a/serialization/CMakeLists.txt b/serialization/CMakeLists.txt new file mode 100644 index 0000000..7bca824 --- /dev/null +++ b/serialization/CMakeLists.txt @@ -0,0 +1,32 @@ +cmake_minimum_required (VERSION 3.4) + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +project (tosa) + +set (CMAKE_CXX_STANDARD 11) +set (CMAKE_CXX_FLAGS "-g -Wall") +set (FLATBUFFERS_SRC_DIR "../thirdparty/flatbuffers") + +set (SOURCE + tosa_serialization_handler.cpp +) + +add_library(tosa_serialization STATIC ${SOURCE}) + +include_directories("./") + +target_link_libraries(tosa_serialization PRIVATE flatbuffers) diff --git a/serialization/attribute.def b/serialization/attribute.def new file mode 100644 index 0000000..88e8c81 --- /dev/null +++ b/serialization/attribute.def @@ -0,0 +1,90 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + Syntax: + DEF_ATTRIBUTE(ATTRIBUTE_NAME, NUM_ARGS_IN_ATTRIBUTES, ARG0_TYPE, ARG0_SCALAR_OR_VECTOR, ARGS0_NAME, ...) + + Description: + ATTRIBUTE_NAME: corresponding attribute name, must match corresponding "table XXXAttribute" in tosa.fbs + NUM_ARGS_IN_ATTRIBUTES: number of arguments in this attribute + ARG0_TYPE: data type of arg0 in attribute + ARG0_SCALAR_OR_VECTOR: is arg0 a scalar(S) or a vector(V) + ARG0_NAME: name of arg0 + ...: variadic variables for more arguments, depending on NUM_ARGS_IN_ATTRIBUTES +*/ + +DEF_ATTRIBUTE(Pool2d, 3, + int32_t, V, padding, + int32_t, V, kernel, + int32_t, V, stride) + +DEF_ATTRIBUTE(Conv2d, 3, + int32_t, V, padding, + int32_t, V, stride, + int32_t, V, dilation) + +DEF_ATTRIBUTE(TransposeConv2d, 4, + int32_t, V, outpad, + int32_t, V, stride, + int32_t, V, dilation, + int32_t, V, output_shape) + +DEF_ATTRIBUTE(ReluN, 2, + int32_t, S, max_int, + float, S, max_fp) + +DEF_ATTRIBUTE(Axis, 1, + int32_t, S, axis) + +DEF_ATTRIBUTE(Reshape, 1, + int32_t, V, shape) + +DEF_ATTRIBUTE(Slice, 2, + int32_t, V, begin, + int32_t, V, size) + +DEF_ATTRIBUTE(Tile, 1, + int32_t, V, multiples) + +DEF_ATTRIBUTE(Resize, 5, + int32_t, V, output_size, + int32_t, V, stride, + int32_t, V, offset, + int32_t, S, shift, + ResizeMode, S, mode) + +DEF_ATTRIBUTE(Clamp, 4, + int32_t, S, min_int, + int32_t, S, max_int, + float, S, min_fp, + float, S, max_fp) + +DEF_ATTRIBUTE(Rescale, 7, + int32_t, S, input_zp, + int32_t, S, output_zp, + int32_t, V, multiplier, + int32_t, V, shift, + bool, S, scale32, + bool, S, double_round, + bool, S, per_channel) + +DEF_ATTRIBUTE(CondIf, 2, + string, S, then_branch, + string, S, else_branch) + +DEF_ATTRIBUTE(WhileLoop, 2, + string, S, cond_branch, + string, S, body_branch) diff --git a/serialization/attribute.h b/serialization/attribute.h new file mode 100644 index 0000000..2a33a8f --- /dev/null +++ b/serialization/attribute.h @@ -0,0 +1,181 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef _TOSA_SERIALIZATION_ATTRIBUTE_H +#define _TOSA_SERIALIZATION_ATTRIBUTE_H +#include "flatbuffers/idl.h" +#include "flatbuffers/util.h" +#include "tosa_generated.h" + +using std::string; + +namespace tosa +{ + +class TosaAttributeBase +{ +public: + virtual ~TosaAttributeBase() + {} +}; + +class TosaNoneAttribute : public TosaAttributeBase +{ +public: + TosaNoneAttribute() + {} + TosaNoneAttribute(TosaNoneAttribute* p) + {} +}; + +#define DEF_ARGS_VER0_S_STR(V) _##V = p->V()->str(); +#define DEF_ARGS_VER0_S_DEFAULT(V) _##V = p->V(); + +#define DEF_ARGS_VER0_S_int32_t(V) DEF_ARGS_VER0_S_DEFAULT(V) +#define DEF_ARGS_VER0_S_float(V) DEF_ARGS_VER0_S_DEFAULT(V) +#define DEF_ARGS_VER0_S_bool(V) DEF_ARGS_VER0_S_DEFAULT(V) +#define DEF_ARGS_VER0_S_ResizeMode(V) DEF_ARGS_VER0_S_DEFAULT(V) +#define DEF_ARGS_VER0_S_string(V) DEF_ARGS_VER0_S_STR(V) + +#define DEF_ARGS_VER0_S(T, V) DEF_ARGS_VER0_S_##T(V) +#define DEF_ARGS_VER0_V(T, V) _##V = std::vector<T>(p->V()->begin(), p->V()->end()); + +#define DEF_ARGS_VER1_S(T, V) const T& V +#define DEF_ARGS_VER1_V(T, V) const std::vector<T>& V +#define DEF_ARGS_VER2_S(T, V) _##V = V; +#define DEF_ARGS_VER2_V(T, V) _##V = V; +#define DEF_ARGS_VER3_S(T, V) \ + T V() const \ + { \ + return _##V; \ + } +#define DEF_ARGS_VER3_V(T, V) \ + std::vector<T> V() const \ + { \ + return _##V; \ + } +#define DEF_ARGS_VER4_S(T, V) T _##V; +#define DEF_ARGS_VER4_V(T, V) std::vector<T> _##V; + +// another level of preprocessor indirection to handle ", " as function's input argument +#define DEF_ARGS_VER1_TRUE(T, F, V) DEF_ARGS_VER1_##F(T, V) +#define DEF_ARGS_VER1_FALSE(T, F, V) , DEF_ARGS_VER1_##F(T, V) + +#define DEF_ARGS_VER0(FIRST, T, F, V) DEF_ARGS_VER0_##F(T, V) +#define DEF_ARGS_VER1(FIRST, T, F, V) DEF_ARGS_VER1_##FIRST(T, F, V) +#define DEF_ARGS_VER2(FIRST, T, F, V) DEF_ARGS_VER2_##F(T, V) +#define DEF_ARGS_VER3(FIRST, T, F, V) DEF_ARGS_VER3_##F(T, V) +#define DEF_ARGS_VER4(FIRST, T, F, V) DEF_ARGS_VER4_##F(T, V) + +#define DEF_ARGS_0(VER, ...) +#define DEF_ARGS_1(VER, T0, F0, V0) DEF_ARGS_##VER(TRUE, T0, F0, V0) +#define DEF_ARGS_2(VER, T0, F0, V0, T1, F1, V1) DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) +#define DEF_ARGS_3(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) +#define DEF_ARGS_4(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) +#define DEF_ARGS_5(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) + +#define DEF_ARGS_6(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) + +#define DEF_ARGS_7(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) + +#define DEF_VER0_VAR_DECL_PTR(NAME) const NAME* p = static_cast<const NAME*>(options); +#define DEF_VER0_VAR_0(NAME) +#define DEF_VER0_VAR_1(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_2(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_3(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_4(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_5(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_6(NAME) DEF_VER0_VAR_DECL_PTR(NAME) +#define DEF_VER0_VAR_7(NAME) DEF_VER0_VAR_DECL_PTR(NAME) + +#define DEF_ATTRIBUTE(NAME, NUM_ARGS, ...) \ + class Tosa##NAME##Attribute : public TosaAttributeBase \ + { \ + public: \ + Tosa##NAME##Attribute(const TosaAttributeBase* options) \ + { \ + const Tosa##NAME##Attribute* p = reinterpret_cast<const Tosa##NAME##Attribute*>(options); \ + *this = *p; \ + } \ + Tosa##NAME##Attribute(const Tosa##NAME##Attribute* p) \ + { \ + *this = *p; \ + } \ + Tosa##NAME##Attribute(const void* options){ DEF_VER0_VAR_##NUM_ARGS(NAME##Attribute) \ + DEF_ARGS_##NUM_ARGS(VER0, __VA_ARGS__) } Tosa##NAME \ + ##Attribute(DEF_ARGS_##NUM_ARGS(VER1, __VA_ARGS__)) \ + { \ + DEF_ARGS_##NUM_ARGS(VER2, __VA_ARGS__) \ + } \ + virtual ~Tosa##NAME##Attribute() \ + {} \ + DEF_ARGS_##NUM_ARGS(VER3, __VA_ARGS__) private : DEF_ARGS_##NUM_ARGS(VER4, __VA_ARGS__) \ + }; + +#include "attribute.def" +#undef DEF_ATTRIBUTE +#undef DEF_ARGS_0 +#undef DEF_ARGS_1 +#undef DEF_ARGS_2 +#undef DEF_ARGS_3 +#undef DEF_ARGS_4 +#undef DEF_ARGS_5 +#undef DEF_ARGS_6 +#undef DEF_ARGS_7 +#undef DEF_ARGS_VER0 +#undef DEF_ARGS_VER1 +#undef DEF_ARGS_VER2 +#undef DEF_ARGS_VER3 +#undef DEF_ARGS_VER4 +#undef DEF_ARGS_VER0_S_int32_t +#undef DEF_ARGS_VER0_S_float +#undef DEF_ARGS_VER0_S_bool +#undef DEF_ARGS_VER0_S_ResizeMode +#undef DEF_ARGS_VER0_S_string +#undef DEF_ARGS_VER0_S_STR +#undef DEF_ARGS_VER0_S_DEFAULT +#undef DEF_ARGS_VER1_TRUE +#undef DEF_ARGS_VER1_FALSE +#undef DEF_ARGS_VER0_S +#undef DEF_ARGS_VER0_V +#undef DEF_ARGS_VER1_S +#undef DEF_ARGS_VER1_V +#undef DEF_ARGS_VER2_S +#undef DEF_ARGS_VER2_V +#undef DEF_ARGS_VER3_S +#undef DEF_ARGS_VER3_V +#undef DEF_ARGS_VER4_S +#undef DEF_ARGS_VER4_V +#undef DEF_VER0_VAR_0 +#undef DEF_VER0_VAR_1 +#undef DEF_VER0_VAR_2 +#undef DEF_VER0_VAR_3 +#undef DEF_VER0_VAR_4 +#undef DEF_VER0_VAR_5 +#undef DEF_VER0_VAR_DECL_PTR + +} // namespace tosa + +#endif // _TOSA_SERIALIZATION_ATTRIBUTE_H diff --git a/serialization/operator.def b/serialization/operator.def new file mode 100644 index 0000000..66d3784 --- /dev/null +++ b/serialization/operator.def @@ -0,0 +1,123 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + Syntax: + DEF_OPERATOR(MLIR_NAME, SCHEMA_NAME, REF_IMPL_NAME, OPTIONS, QUANT_INFO) + + Description: + MLIR_NAME: the symbolic string of this op, must match tosa_ops.td + SCHEMA_NAME: corresponding operator name, must match "enum Op" in serialization/tosa.fbs + REF_IMPL_NAME: name used internally in tosa reference implementation + OPTIONS: compile time constant options of this op, corresponding to operator_option.def + QUANT_INFO: quantization infomation of this op, corresponding to quant_info.def +*/ + + +/* tensor operators */ +DEF_OPERATOR(argmax, ARGMAX, ArgMax, Axis, None) +DEF_OPERATOR(avg_pool2d, AVG_POOL2D, AvgPool2d, Pool2d, Unary) +DEF_OPERATOR(conv2d, CONV2D, Conv2d, Conv2d, Conv) +DEF_OPERATOR(conv3d, CONV3D, Conv3d, None, None) +DEF_OPERATOR(depthwise_conv2d, DEPTHWISE_CONV2D, DepthwiseConv2d, Conv2d, Conv) +DEF_OPERATOR(fully_connected, FULLY_CONNECTED, FullyConnected, None, Conv) +DEF_OPERATOR(matmul, MATMUL, MatMul, None, MatMul) +DEF_OPERATOR(max_pool2d, MAX_POOL2D, MaxPool2d, Pool2d, None) +DEF_OPERATOR(transpose_conv2d, TRANSPOSE_CONV2D, TransposeConv2d, TransposeConv2d, Conv) + +/* activation */ +DEF_OPERATOR(clamp, CLAMP, Clamp, Clamp, None) +DEF_OPERATOR(reluN, RELUN, ReluN, ReluN, None) +DEF_OPERATOR(sigmoid, SIGMOID, Sigmoid, None, None) +DEF_OPERATOR(tanh, TANH, Tanh, None, None) + +/* elementwise - binary */ +DEF_OPERATOR(add, ADD, Add, None, None) +DEF_OPERATOR(arithmetic_right_shift, ARITHMETIC_RIGHT_SHIFT, ArithmeticRightShift, None, None) +DEF_OPERATOR(bitwise_and, BITWISE_AND, BitwiseAnd, None, None) +DEF_OPERATOR(bitwise_or, BITWISE_OR, BitwiseOr, None, None) +DEF_OPERATOR(bitwise_xor, BITWISE_XOR, BitwiseXor, None, None) +DEF_OPERATOR(logical_and, LOGICAL_AND, LogicalAnd, None, None) +DEF_OPERATOR(logical_left_shift, LOGICAL_LEFT_SHIFT, LogicalLeftShift, None, None) +DEF_OPERATOR(logical_right_shift, LOGICAL_RIGHT_SHIFT, LogicalRightShift, None, None) +DEF_OPERATOR(logical_or, LOGICAL_OR, LogicalOr, None, None) +DEF_OPERATOR(logical_xor, LOGICAL_XOR, LogicalXor, None, None) +DEF_OPERATOR(maximum, MAXIMUM, Maximum, None, None) +DEF_OPERATOR(minimum, MINIMUM, Minimum, None, None) +DEF_OPERATOR(mul, MUL, Mul, None, None) +DEF_OPERATOR(pow, POW, Pow, None, None) +DEF_OPERATOR(sub, SUB, Sub, None, None) +DEF_OPERATOR(table, TABLE, Table, None, None) + +/* elementwise - unary */ +DEF_OPERATOR(abs, ABS, Abs, None, None) +DEF_OPERATOR(bitwise_not, BITWISE_NOT, BitwiseNot, None, None) +DEF_OPERATOR(ceil, CEIL, Ceil, None, None) +DEF_OPERATOR(clz, CLZ, Clz, None, None) +DEF_OPERATOR(exp, EXP, Exp, None, None) +DEF_OPERATOR(floor, FLOOR, Floor, None, None) +DEF_OPERATOR(log, LOG, Log, None, None) +DEF_OPERATOR(logical_not, LOGICAL_NOT, LogicalNot, None, None) +DEF_OPERATOR(negate, NEGATE, Negate, None, Unary) +DEF_OPERATOR(reciprocal, RECIPROCAL, Reciprocal, None, None) +DEF_OPERATOR(rsqrt, RSQRT, Rsqrt, None, None) + +/* elementwise - ternary */ +DEF_OPERATOR(select, SELECT, Select, None, None) + +/* logical */ +DEF_OPERATOR(equal, EQUAL, Equal, None, None) +DEF_OPERATOR(greater, GREATER, Greater, None, None) +DEF_OPERATOR(greater_equal, GREATER_EQUAL, GreaterEqual, None, None) + +/* reduction */ +DEF_OPERATOR(reduce_any, REDUCE_ANY, ReduceAny, Reduce, None) +DEF_OPERATOR(reduce_all, REDUCE_ALL, ReduceAll, Reduce, None) +DEF_OPERATOR(reduce_max, REDUCE_MAX, ReduceMax, Reduce, None) +DEF_OPERATOR(reduce_min, REDUCE_MIN, ReduceMin, Reduce, None) +DEF_OPERATOR(reduce_prod, REDUCE_PRODUCT, ReduceProduct, Reduce, None) +DEF_OPERATOR(reduce_sum, REDUCE_SUM, ReduceSum, Reduce, None) + +/* memory operation */ +DEF_OPERATOR(concat, CONCAT, Concat, Axis, None) +DEF_OPERATOR(pad, PAD, Pad, None, Pad) +DEF_OPERATOR(reshape, RESHAPE, Reshape, Reshape, None) +DEF_OPERATOR(reverse, REVERSE, Reverse, Reverse, None) +DEF_OPERATOR(slice, SLICE, Slice, Slice, None) +DEF_OPERATOR(tile, TILE, Tile, Tile, None) +DEF_OPERATOR(transpose, TRANSPOSE, Transpose, None, None) + +/* gather/scatter */ +DEF_OPERATOR(gather, GATHER, Gather, Axis, None) + +/* image */ +DEF_OPERATOR(resize, RESIZE, Resize, Resize, None) + +/* quantization */ +DEF_OPERATOR(cast, CAST, Cast, None, None) +DEF_OPERATOR(rescale, RESCALE, Rescale, Rescale, None) + +/* data nodes */ +DEF_OPERATOR(const, CONST, Const, None, None) +DEF_OPERATOR(placeholder, PLACEHOLDER, Placeholder, None, None) +DEF_OPERATOR(identity, IDENTITY, Identity, None, None) +DEF_OPERATOR(identityn, IDENTITYN, IdentityN, None, None) + +/* custom operations */ +DEF_OPERATOR(custom, CUSTOM, Custom, None, None) + +/* control flow operators */ +DEF_OPERATOR(cond_if, COND_IF, CondIf, CondIf, None) +DEF_OPERATOR(while_loop, WHILE_LOOP, WhileLoop, WhileLoop, None) diff --git a/serialization/quant_info.def b/serialization/quant_info.def new file mode 100644 index 0000000..39dc101 --- /dev/null +++ b/serialization/quant_info.def @@ -0,0 +1,43 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/* + Syntax: + DEF_QUANTIZATION_INFO(NAME, NUM_ARGS_IN_OPTIONS, ARG0_TYPE, ARG0_SCALAR_OR_VECTOR, ARGS0_NAME, ...) + + Description: + NAME: corresponding quantization info name, must match corresponding "table XXXQuantInfo" in tosa.fbs + NUM_ARGS_IN_QINFO: number of arguments in this quantization info + ARG0_TYPE: data type of arg0 + ARG0_SCALAR_OR_VECTOR: is arg0 a scalar (S) or a vector (V) + ARG0_NAME: name of arg0 + ...: variadic variables for more arguments, depending on NUM_ARGS_IN_QINFO +*/ + + +DEF_QUANTIZATION_INFO(Unary, 2, + int32_t, S, input_zp, + int32_t, S, output_zp) + +DEF_QUANTIZATION_INFO(Conv, 2, + int32_t, S, input_zp, + int32_t, S, weight_zp) + +DEF_QUANTIZATION_INFO(MatMul, 2, + int32_t, S, a_zp, + int32_t, S, b_zp) + +DEF_QUANTIZATION_INFO(Pad, 1, + int32_t, S, input_zp) diff --git a/serialization/quant_info.h b/serialization/quant_info.h new file mode 100644 index 0000000..03dcab9 --- /dev/null +++ b/serialization/quant_info.h @@ -0,0 +1,164 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef _TOSA_SERIALIZATION_QUANT_INFO_H +#define _TOSA_SERIALIZATION_QUANT_INFO_H +#include "flatbuffers/idl.h" +#include "flatbuffers/util.h" +#include "tosa_generated.h" + +namespace tosa +{ + +class TosaQuantInfoBase +{ +public: + virtual ~TosaQuantInfoBase() + {} +}; + +class TosaNoneQuantInfo : public TosaQuantInfoBase +{ +public: + TosaNoneQuantInfo() + {} + TosaNoneQuantInfo(TosaNoneQuantInfo* p) + {} +}; + +#define DEF_ARGS_VER0_S(T, V) _##V = p->V(); +#define DEF_ARGS_VER0_V(T, V) _##V = std::vector<T>(p->V()->begin(), p->V()->end()); +#define DEF_ARGS_VER1_S(T, V) const T& V +#define DEF_ARGS_VER1_V(T, V) const std::vector<T>& V +#define DEF_ARGS_VER2_S(T, V) _##V = V; +#define DEF_ARGS_VER2_V(T, V) _##V = V; +#define DEF_ARGS_VER3_S(T, V) \ + T V() const \ + { \ + return _##V; \ + } +#define DEF_ARGS_VER3_V(T, V) \ + std::vector<T> V() const \ + { \ + return _##V; \ + } +#define DEF_ARGS_VER4_S(T, V) T _##V; +#define DEF_ARGS_VER4_V(T, V) std::vector<T> _##V; + +// another level of preprocessor indirection to handle ", " as function's input argument +#define DEF_ARGS_VER1_TRUE(T, F, V) DEF_ARGS_VER1_##F(T, V) +#define DEF_ARGS_VER1_FALSE(T, F, V) , DEF_ARGS_VER1_##F(T, V) + +#define DEF_ARGS_VER0(FIRST, T, F, V) DEF_ARGS_VER0_##F(T, V) +#define DEF_ARGS_VER1(FIRST, T, F, V) DEF_ARGS_VER1_##FIRST(T, F, V) +#define DEF_ARGS_VER2(FIRST, T, F, V) DEF_ARGS_VER2_##F(T, V) +#define DEF_ARGS_VER3(FIRST, T, F, V) DEF_ARGS_VER3_##F(T, V) +#define DEF_ARGS_VER4(FIRST, T, F, V) DEF_ARGS_VER4_##F(T, V) + +#define DEF_ARGS_1(VER, T0, F0, V0) DEF_ARGS_##VER(TRUE, T0, F0, V0) +#define DEF_ARGS_2(VER, T0, F0, V0, T1, F1, V1) DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) +#define DEF_ARGS_3(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) +#define DEF_ARGS_4(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) +#define DEF_ARGS_5(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) +#define DEF_ARGS_6(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) +#define DEF_ARGS_7(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) +#define DEF_ARGS_8(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6, T7, F7, \ + V7) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) DEF_ARGS_##VER(FALSE, T7, F7, V7) +#define DEF_ARGS_9(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6, T7, F7, \ + V7, T8, F8, V8) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) DEF_ARGS_##VER(FALSE, T7, F7, V7) DEF_ARGS_##VER(FALSE, T8, F8, V8) +#define DEF_ARGS_10(VER, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6, T7, F7, \ + V7, T8, F8, V8, T9, F9, V9) \ + DEF_ARGS_##VER(TRUE, T0, F0, V0) DEF_ARGS_##VER(FALSE, T1, F1, V1) DEF_ARGS_##VER(FALSE, T2, F2, V2) \ + DEF_ARGS_##VER(FALSE, T3, F3, V3) DEF_ARGS_##VER(FALSE, T4, F4, V4) DEF_ARGS_##VER(FALSE, T5, F5, V5) \ + DEF_ARGS_##VER(FALSE, T6, F6, V6) DEF_ARGS_##VER(FALSE, T7, F7, V7) DEF_ARGS_##VER(FALSE, T8, F8, V8) \ + DEF_ARGS_##VER(FALSE, T9, F9, V9) + +#define DEF_QUANTIZATION_INFO(NAME, NUM_ARGS, ...) \ + class Tosa##NAME##QuantInfo : public TosaQuantInfoBase \ + { \ + public: \ + Tosa##NAME##QuantInfo(const TosaQuantInfoBase* qinfo) \ + { \ + const Tosa##NAME##QuantInfo* p = dynamic_cast<const Tosa##NAME##QuantInfo*>(qinfo); \ + assert(p); \ + *this = *p; \ + } \ + Tosa##NAME##QuantInfo(const Tosa##NAME##QuantInfo* p) \ + { \ + *this = *p; \ + } \ + Tosa##NAME##QuantInfo(const void* qinfo) \ + { \ + const NAME##QuantInfo* p = static_cast<const NAME##QuantInfo*>(qinfo); \ + DEF_ARGS_##NUM_ARGS(VER0, __VA_ARGS__) \ + } \ + Tosa##NAME##QuantInfo(DEF_ARGS_##NUM_ARGS(VER1, __VA_ARGS__)) \ + { \ + DEF_ARGS_##NUM_ARGS(VER2, __VA_ARGS__) \ + } \ + virtual ~Tosa##NAME##QuantInfo() \ + {} \ + DEF_ARGS_##NUM_ARGS(VER3, __VA_ARGS__) private : DEF_ARGS_##NUM_ARGS(VER4, __VA_ARGS__) \ + }; + +#include "quant_info.def" +#undef DEF_QUANTIZATION_INFO +#undef DEF_ARGS_1 +#undef DEF_ARGS_2 +#undef DEF_ARGS_3 +#undef DEF_ARGS_4 +#undef DEF_ARGS_5 +#undef DEF_ARGS_6 +#undef DEF_ARGS_7 +#undef DEF_ARGS_8 +#undef DEF_ARGS_9 +#undef DEF_ARGS_10 +#undef DEF_ARGS_VER0 +#undef DEF_ARGS_VER1 +#undef DEF_ARGS_VER2 +#undef DEF_ARGS_VER3 +#undef DEF_ARGS_VER4 +#undef DEF_ARGS_VER1_TRUE +#undef DEF_ARGS_VER1_FALSE +#undef DEF_ARGS_VER0_S +#undef DEF_ARGS_VER0_V +#undef DEF_ARGS_VER1_S +#undef DEF_ARGS_VER1_V +#undef DEF_ARGS_VER2_S +#undef DEF_ARGS_VER2_V +#undef DEF_ARGS_VER3_S +#undef DEF_ARGS_VER3_V +#undef DEF_ARGS_VER4_S +#undef DEF_ARGS_VER4_V + +} // namespace tosa + +#endif diff --git a/serialization/tosa.fbs b/serialization/tosa.fbs new file mode 100644 index 0000000..841cf3d --- /dev/null +++ b/serialization/tosa.fbs @@ -0,0 +1,318 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +namespace tosa; + +// This corresponds to the version. +file_identifier "TOSA"; +// File extension of any written files. +file_extension "tosa"; + +enum DType:uint32 { + UNKNOWN = 0, + BOOL, + AINT8, + UINT8, + INT4, + INT8, + INT16, + INT32, + INT48, + FLOAT, +} + +enum Format:uint32 { + UNKNOWN = 0, + NHWC, + NDHWC, + OHWI, + HWIM, + DOHWI, +} + +enum Usage:uint32 { + UNKNOWN = 0, + ACTIVATION, + WEIGHT, + INDEX, +} + +enum ResizeMode:uint32 { + UNKNOWN = 0, + NEAREST, + BILINEAR, +} + +enum Op:uint32 { + UNKNOWN = 0, + + // Tensor Operator + ARGMAX, + AVG_POOL2D, + CONV2D, + CONV3D, + DEPTHWISE_CONV2D, + FULLY_CONNECTED, + MATMUL, + MAX_POOL2D, + TRANSPOSE_CONV2D, + + // Activation + CLAMP, + RELUN, + SIGMOID, + TANH, + + // Elementwise-Binary + ADD, + ARITHMETIC_RIGHT_SHIFT, + BITWISE_AND, + BITWISE_OR, + BITWISE_XOR, + LOGICAL_AND, + LOGICAL_LEFT_SHIFT, + LOGICAL_RIGHT_SHIFT, + LOGICAL_OR, + LOGICAL_XOR, + MAXIMUM, + MINIMUM, + MUL, + POW, + SUB, + TABLE, + + // Elementwise-Unary + ABS, + BITWISE_NOT, + CEIL, + CLZ, + EXP, + FLOOR, + LOG, + LOGICAL_NOT, + NEGATE, + RECIPROCAL, + RSQRT, + + // Elementwise-Ternary + SELECT, + + // Logical + EQUAL, + GREATER, + GREATER_EQUAL, + + // Reduction + REDUCE_ANY, + REDUCE_ALL, + REDUCE_MAX, + REDUCE_MIN, + REDUCE_PRODUCT, + REDUCE_SUM, + + // Data layout operation + CONCAT, + PAD, + RESHAPE, + REVERSE, + SLICE, + TILE, + TRANSPOSE, + + // Gather/scatter operation + GATHER, + + // Image + RESIZE, + + // Type conversion + CAST, + RESCALE, + + // Data Nodes + CONST, + PLACEHOLDER, + IDENTITY, + IDENTITYN, + + // Custom operations + CUSTOM, + + // Control flow operators + COND_IF, + WHILE_LOOP, +} + +union Attribute { + Pool2dAttribute, + Conv2dAttribute, + TransposeConv2dAttribute, + ReluNAttribute, + AxisAttribute, + ReshapeAttribute, + SliceAttribute, + TileAttribute, + ResizeAttribute, + ClampAttribute, + RescaleAttribute, + CustomAttribute, + CondIfAttribute, + WhileLoopAttribute, +} + +table Pool2dAttribute { + padding: [int32]; + kernel: [int32]; + stride: [int32]; +} + +table Conv2dAttribute { + padding: [int32]; + stride: [int32]; + dilation: [int32]; +} + +table TransposeConv2dAttribute { + outpad: [int32]; + stride: [int32]; + dilation: [int32]; + output_shape: [int32]; +} + +table ReluNAttribute { + max_int: int32; + max_fp: float; +} + +table AxisAttribute { + axis: int32; +} + +table ReshapeAttribute { + shape: [int32]; +} + +table SliceAttribute { + begin: [int32]; + size: [int32]; +} + +table TileAttribute { + multiples: [int32]; +} + +table ResizeAttribute { + output_size: [int32]; + stride: [int32]; + offset: [int32]; + shift: int32; + mode: ResizeMode; +} + +table ClampAttribute { + min_int: int32; + max_int: int32; + min_fp: float; + max_fp: float; +} + +table RescaleAttribute { + input_zp: int32; + output_zp: int32; + multiplier: [int32]; + shift: [int32]; + scale32: bool; + double_round: bool; + per_channel: bool; +} + +table CustomAttribute { + identifier: string; +} + +table CondIfAttribute { + then_branch: string; + else_branch: string; +} + +table WhileLoopAttribute { + cond_branch: string; + body_branch: string; +} + +union QuantInfo { + UnaryQuantInfo, + ConvQuantInfo, + MatMulQuantInfo, + PadQuantInfo, +} + +table UnaryQuantInfo { + input_zp: int32; + output_zp: int32; +} + +table ConvQuantInfo { + input_zp: int32; + weight_zp: int32; +} + +table MatMulQuantInfo { + a_zp: int32; + b_zp: int32; +} + +table PadQuantInfo { + input_zp: int32; +} + +table Version { + _major: int32 = 0; + _minor: int32 = 20; + _patch: int32 = 0; + _experimental: bool = false; +} + +table TosaTensor { + name:string; // name of the tensor, used for solving dependency + shape:[int32]; // shape of the tensor + type:DType; // data type of the tensor + usage:[Usage]; // vector of possible usages. for the convenience of debugging only. + format:[Format]; // vector of possible formats. for the convenience of debugging only. + npy_filename: string; // numpy array filename +} + +table TosaOperator { + op:Op; // operator enum + attribute: Attribute; // union structure. operator attribute + inputs:[string]; // list of input tensor names + outputs:[string]; // list of output tensor names + quant_info: QuantInfo; // op-based quantization information +} + +table TosaBasicBlock { + name:string; // basic block name + operators:[TosaOperator]; // operators array + tensors:[TosaTensor]; // tensors array + inputs:[string]; // name of graph inputs + outputs:[string]; // name of graph outputs +} + +table TosaGraph { + version: Version; + blocks:[TosaBasicBlock]; // basic blocks array +} + +root_type TosaGraph; diff --git a/serialization/tosa_generated.h b/serialization/tosa_generated.h new file mode 100644 index 0000000..5bb21f3 --- /dev/null +++ b/serialization/tosa_generated.h @@ -0,0 +1,2605 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// automatically generated by the FlatBuffers compiler, do not modify + + +#ifndef FLATBUFFERS_GENERATED_TOSA_TOSA_H_ +#define FLATBUFFERS_GENERATED_TOSA_TOSA_H_ + +#include "flatbuffers/flatbuffers.h" + +namespace tosa { + +struct Pool2dAttribute; + +struct Conv2dAttribute; + +struct TransposeConv2dAttribute; + +struct ReluNAttribute; + +struct AxisAttribute; + +struct ReshapeAttribute; + +struct SliceAttribute; + +struct TileAttribute; + +struct ResizeAttribute; + +struct ClampAttribute; + +struct RescaleAttribute; + +struct CustomAttribute; + +struct CondIfAttribute; + +struct WhileLoopAttribute; + +struct UnaryQuantInfo; + +struct ConvQuantInfo; + +struct MatMulQuantInfo; + +struct PadQuantInfo; + +struct Version; + +struct TosaTensor; + +struct TosaOperator; + +struct TosaBasicBlock; + +struct TosaGraph; + +enum DType { + DType_UNKNOWN = 0, + DType_BOOL = 1, + DType_AINT8 = 2, + DType_UINT8 = 3, + DType_INT4 = 4, + DType_INT8 = 5, + DType_INT16 = 6, + DType_INT32 = 7, + DType_INT48 = 8, + DType_FLOAT = 9, + DType_MIN = DType_UNKNOWN, + DType_MAX = DType_FLOAT +}; + +inline const DType (&EnumValuesDType())[10] { + static const DType values[] = { + DType_UNKNOWN, + DType_BOOL, + DType_AINT8, + DType_UINT8, + DType_INT4, + DType_INT8, + DType_INT16, + DType_INT32, + DType_INT48, + DType_FLOAT + }; + return values; +} + +inline const char * const *EnumNamesDType() { + static const char * const names[] = { + "UNKNOWN", + "BOOL", + "AINT8", + "UINT8", + "INT4", + "INT8", + "INT16", + "INT32", + "INT48", + "FLOAT", + nullptr + }; + return names; +} + +inline const char *EnumNameDType(DType e) { + if (e < DType_UNKNOWN || e > DType_FLOAT) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesDType()[index]; +} + +enum Format { + Format_UNKNOWN = 0, + Format_NHWC = 1, + Format_NDHWC = 2, + Format_OHWI = 3, + Format_HWIM = 4, + Format_DOHWI = 5, + Format_MIN = Format_UNKNOWN, + Format_MAX = Format_DOHWI +}; + +inline const Format (&EnumValuesFormat())[6] { + static const Format values[] = { + Format_UNKNOWN, + Format_NHWC, + Format_NDHWC, + Format_OHWI, + Format_HWIM, + Format_DOHWI + }; + return values; +} + +inline const char * const *EnumNamesFormat() { + static const char * const names[] = { + "UNKNOWN", + "NHWC", + "NDHWC", + "OHWI", + "HWIM", + "DOHWI", + nullptr + }; + return names; +} + +inline const char *EnumNameFormat(Format e) { + if (e < Format_UNKNOWN || e > Format_DOHWI) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesFormat()[index]; +} + +enum Usage { + Usage_UNKNOWN = 0, + Usage_ACTIVATION = 1, + Usage_WEIGHT = 2, + Usage_INDEX = 3, + Usage_MIN = Usage_UNKNOWN, + Usage_MAX = Usage_INDEX +}; + +inline const Usage (&EnumValuesUsage())[4] { + static const Usage values[] = { + Usage_UNKNOWN, + Usage_ACTIVATION, + Usage_WEIGHT, + Usage_INDEX + }; + return values; +} + +inline const char * const *EnumNamesUsage() { + static const char * const names[] = { + "UNKNOWN", + "ACTIVATION", + "WEIGHT", + "INDEX", + nullptr + }; + return names; +} + +inline const char *EnumNameUsage(Usage e) { + if (e < Usage_UNKNOWN || e > Usage_INDEX) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesUsage()[index]; +} + +enum ResizeMode { + ResizeMode_UNKNOWN = 0, + ResizeMode_NEAREST = 1, + ResizeMode_BILINEAR = 2, + ResizeMode_MIN = ResizeMode_UNKNOWN, + ResizeMode_MAX = ResizeMode_BILINEAR +}; + +inline const ResizeMode (&EnumValuesResizeMode())[3] { + static const ResizeMode values[] = { + ResizeMode_UNKNOWN, + ResizeMode_NEAREST, + ResizeMode_BILINEAR + }; + return values; +} + +inline const char * const *EnumNamesResizeMode() { + static const char * const names[] = { + "UNKNOWN", + "NEAREST", + "BILINEAR", + nullptr + }; + return names; +} + +inline const char *EnumNameResizeMode(ResizeMode e) { + if (e < ResizeMode_UNKNOWN || e > ResizeMode_BILINEAR) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesResizeMode()[index]; +} + +enum Op { + Op_UNKNOWN = 0, + Op_ARGMAX = 1, + Op_AVG_POOL2D = 2, + Op_CONV2D = 3, + Op_CONV3D = 4, + Op_DEPTHWISE_CONV2D = 5, + Op_FULLY_CONNECTED = 6, + Op_MATMUL = 7, + Op_MAX_POOL2D = 8, + Op_TRANSPOSE_CONV2D = 9, + Op_CLAMP = 10, + Op_RELUN = 11, + Op_SIGMOID = 12, + Op_TANH = 13, + Op_ADD = 14, + Op_ARITHMETIC_RIGHT_SHIFT = 15, + Op_BITWISE_AND = 16, + Op_BITWISE_OR = 17, + Op_BITWISE_XOR = 18, + Op_LOGICAL_AND = 19, + Op_LOGICAL_LEFT_SHIFT = 20, + Op_LOGICAL_RIGHT_SHIFT = 21, + Op_LOGICAL_OR = 22, + Op_LOGICAL_XOR = 23, + Op_MAXIMUM = 24, + Op_MINIMUM = 25, + Op_MUL = 26, + Op_POW = 27, + Op_SUB = 28, + Op_TABLE = 29, + Op_ABS = 30, + Op_BITWISE_NOT = 31, + Op_CEIL = 32, + Op_CLZ = 33, + Op_EXP = 34, + Op_FLOOR = 35, + Op_LOG = 36, + Op_LOGICAL_NOT = 37, + Op_NEGATE = 38, + Op_RECIPROCAL = 39, + Op_RSQRT = 40, + Op_SELECT = 41, + Op_EQUAL = 42, + Op_GREATER = 43, + Op_GREATER_EQUAL = 44, + Op_REDUCE_ANY = 45, + Op_REDUCE_ALL = 46, + Op_REDUCE_MAX = 47, + Op_REDUCE_MIN = 48, + Op_REDUCE_PRODUCT = 49, + Op_REDUCE_SUM = 50, + Op_CONCAT = 51, + Op_PAD = 52, + Op_RESHAPE = 53, + Op_REVERSE = 54, + Op_SLICE = 55, + Op_TILE = 56, + Op_TRANSPOSE = 57, + Op_GATHER = 58, + Op_RESIZE = 59, + Op_CAST = 60, + Op_RESCALE = 61, + Op_CONST = 62, + Op_PLACEHOLDER = 63, + Op_IDENTITY = 64, + Op_IDENTITYN = 65, + Op_CUSTOM = 66, + Op_COND_IF = 67, + Op_WHILE_LOOP = 68, + Op_MIN = Op_UNKNOWN, + Op_MAX = Op_WHILE_LOOP +}; + +inline const Op (&EnumValuesOp())[69] { + static const Op values[] = { + Op_UNKNOWN, + Op_ARGMAX, + Op_AVG_POOL2D, + Op_CONV2D, + Op_CONV3D, + Op_DEPTHWISE_CONV2D, + Op_FULLY_CONNECTED, + Op_MATMUL, + Op_MAX_POOL2D, + Op_TRANSPOSE_CONV2D, + Op_CLAMP, + Op_RELUN, + Op_SIGMOID, + Op_TANH, + Op_ADD, + Op_ARITHMETIC_RIGHT_SHIFT, + Op_BITWISE_AND, + Op_BITWISE_OR, + Op_BITWISE_XOR, + Op_LOGICAL_AND, + Op_LOGICAL_LEFT_SHIFT, + Op_LOGICAL_RIGHT_SHIFT, + Op_LOGICAL_OR, + Op_LOGICAL_XOR, + Op_MAXIMUM, + Op_MINIMUM, + Op_MUL, + Op_POW, + Op_SUB, + Op_TABLE, + Op_ABS, + Op_BITWISE_NOT, + Op_CEIL, + Op_CLZ, + Op_EXP, + Op_FLOOR, + Op_LOG, + Op_LOGICAL_NOT, + Op_NEGATE, + Op_RECIPROCAL, + Op_RSQRT, + Op_SELECT, + Op_EQUAL, + Op_GREATER, + Op_GREATER_EQUAL, + Op_REDUCE_ANY, + Op_REDUCE_ALL, + Op_REDUCE_MAX, + Op_REDUCE_MIN, + Op_REDUCE_PRODUCT, + Op_REDUCE_SUM, + Op_CONCAT, + Op_PAD, + Op_RESHAPE, + Op_REVERSE, + Op_SLICE, + Op_TILE, + Op_TRANSPOSE, + Op_GATHER, + Op_RESIZE, + Op_CAST, + Op_RESCALE, + Op_CONST, + Op_PLACEHOLDER, + Op_IDENTITY, + Op_IDENTITYN, + Op_CUSTOM, + Op_COND_IF, + Op_WHILE_LOOP + }; + return values; +} + +inline const char * const *EnumNamesOp() { + static const char * const names[] = { + "UNKNOWN", + "ARGMAX", + "AVG_POOL2D", + "CONV2D", + "CONV3D", + "DEPTHWISE_CONV2D", + "FULLY_CONNECTED", + "MATMUL", + "MAX_POOL2D", + "TRANSPOSE_CONV2D", + "CLAMP", + "RELUN", + "SIGMOID", + "TANH", + "ADD", + "ARITHMETIC_RIGHT_SHIFT", + "BITWISE_AND", + "BITWISE_OR", + "BITWISE_XOR", + "LOGICAL_AND", + "LOGICAL_LEFT_SHIFT", + "LOGICAL_RIGHT_SHIFT", + "LOGICAL_OR", + "LOGICAL_XOR", + "MAXIMUM", + "MINIMUM", + "MUL", + "POW", + "SUB", + "TABLE", + "ABS", + "BITWISE_NOT", + "CEIL", + "CLZ", + "EXP", + "FLOOR", + "LOG", + "LOGICAL_NOT", + "NEGATE", + "RECIPROCAL", + "RSQRT", + "SELECT", + "EQUAL", + "GREATER", + "GREATER_EQUAL", + "REDUCE_ANY", + "REDUCE_ALL", + "REDUCE_MAX", + "REDUCE_MIN", + "REDUCE_PRODUCT", + "REDUCE_SUM", + "CONCAT", + "PAD", + "RESHAPE", + "REVERSE", + "SLICE", + "TILE", + "TRANSPOSE", + "GATHER", + "RESIZE", + "CAST", + "RESCALE", + "CONST", + "PLACEHOLDER", + "IDENTITY", + "IDENTITYN", + "CUSTOM", + "COND_IF", + "WHILE_LOOP", + nullptr + }; + return names; +} + +inline const char *EnumNameOp(Op e) { + if (e < Op_UNKNOWN || e > Op_WHILE_LOOP) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesOp()[index]; +} + +enum Attribute { + Attribute_NONE = 0, + Attribute_Pool2dAttribute = 1, + Attribute_Conv2dAttribute = 2, + Attribute_TransposeConv2dAttribute = 3, + Attribute_ReluNAttribute = 4, + Attribute_AxisAttribute = 5, + Attribute_ReshapeAttribute = 6, + Attribute_SliceAttribute = 7, + Attribute_TileAttribute = 8, + Attribute_ResizeAttribute = 9, + Attribute_ClampAttribute = 10, + Attribute_RescaleAttribute = 11, + Attribute_CustomAttribute = 12, + Attribute_CondIfAttribute = 13, + Attribute_WhileLoopAttribute = 14, + Attribute_MIN = Attribute_NONE, + Attribute_MAX = Attribute_WhileLoopAttribute +}; + +inline const Attribute (&EnumValuesAttribute())[15] { + static const Attribute values[] = { + Attribute_NONE, + Attribute_Pool2dAttribute, + Attribute_Conv2dAttribute, + Attribute_TransposeConv2dAttribute, + Attribute_ReluNAttribute, + Attribute_AxisAttribute, + Attribute_ReshapeAttribute, + Attribute_SliceAttribute, + Attribute_TileAttribute, + Attribute_ResizeAttribute, + Attribute_ClampAttribute, + Attribute_RescaleAttribute, + Attribute_CustomAttribute, + Attribute_CondIfAttribute, + Attribute_WhileLoopAttribute + }; + return values; +} + +inline const char * const *EnumNamesAttribute() { + static const char * const names[] = { + "NONE", + "Pool2dAttribute", + "Conv2dAttribute", + "TransposeConv2dAttribute", + "ReluNAttribute", + "AxisAttribute", + "ReshapeAttribute", + "SliceAttribute", + "TileAttribute", + "ResizeAttribute", + "ClampAttribute", + "RescaleAttribute", + "CustomAttribute", + "CondIfAttribute", + "WhileLoopAttribute", + nullptr + }; + return names; +} + +inline const char *EnumNameAttribute(Attribute e) { + if (e < Attribute_NONE || e > Attribute_WhileLoopAttribute) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesAttribute()[index]; +} + +template<typename T> struct AttributeTraits { + static const Attribute enum_value = Attribute_NONE; +}; + +template<> struct AttributeTraits<Pool2dAttribute> { + static const Attribute enum_value = Attribute_Pool2dAttribute; +}; + +template<> struct AttributeTraits<Conv2dAttribute> { + static const Attribute enum_value = Attribute_Conv2dAttribute; +}; + +template<> struct AttributeTraits<TransposeConv2dAttribute> { + static const Attribute enum_value = Attribute_TransposeConv2dAttribute; +}; + +template<> struct AttributeTraits<ReluNAttribute> { + static const Attribute enum_value = Attribute_ReluNAttribute; +}; + +template<> struct AttributeTraits<AxisAttribute> { + static const Attribute enum_value = Attribute_AxisAttribute; +}; + +template<> struct AttributeTraits<ReshapeAttribute> { + static const Attribute enum_value = Attribute_ReshapeAttribute; +}; + +template<> struct AttributeTraits<SliceAttribute> { + static const Attribute enum_value = Attribute_SliceAttribute; +}; + +template<> struct AttributeTraits<TileAttribute> { + static const Attribute enum_value = Attribute_TileAttribute; +}; + +template<> struct AttributeTraits<ResizeAttribute> { + static const Attribute enum_value = Attribute_ResizeAttribute; +}; + +template<> struct AttributeTraits<ClampAttribute> { + static const Attribute enum_value = Attribute_ClampAttribute; +}; + +template<> struct AttributeTraits<RescaleAttribute> { + static const Attribute enum_value = Attribute_RescaleAttribute; +}; + +template<> struct AttributeTraits<CustomAttribute> { + static const Attribute enum_value = Attribute_CustomAttribute; +}; + +template<> struct AttributeTraits<CondIfAttribute> { + static const Attribute enum_value = Attribute_CondIfAttribute; +}; + +template<> struct AttributeTraits<WhileLoopAttribute> { + static const Attribute enum_value = Attribute_WhileLoopAttribute; +}; + +bool VerifyAttribute(flatbuffers::Verifier &verifier, const void *obj, Attribute type); +bool VerifyAttributeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); + +enum QuantInfo { + QuantInfo_NONE = 0, + QuantInfo_UnaryQuantInfo = 1, + QuantInfo_ConvQuantInfo = 2, + QuantInfo_MatMulQuantInfo = 3, + QuantInfo_PadQuantInfo = 4, + QuantInfo_MIN = QuantInfo_NONE, + QuantInfo_MAX = QuantInfo_PadQuantInfo +}; + +inline const QuantInfo (&EnumValuesQuantInfo())[5] { + static const QuantInfo values[] = { + QuantInfo_NONE, + QuantInfo_UnaryQuantInfo, + QuantInfo_ConvQuantInfo, + QuantInfo_MatMulQuantInfo, + QuantInfo_PadQuantInfo + }; + return values; +} + +inline const char * const *EnumNamesQuantInfo() { + static const char * const names[] = { + "NONE", + "UnaryQuantInfo", + "ConvQuantInfo", + "MatMulQuantInfo", + "PadQuantInfo", + nullptr + }; + return names; +} + +inline const char *EnumNameQuantInfo(QuantInfo e) { + if (e < QuantInfo_NONE || e > QuantInfo_PadQuantInfo) return ""; + const size_t index = static_cast<size_t>(e); + return EnumNamesQuantInfo()[index]; +} + +template<typename T> struct QuantInfoTraits { + static const QuantInfo enum_value = QuantInfo_NONE; +}; + +template<> struct QuantInfoTraits<UnaryQuantInfo> { + static const QuantInfo enum_value = QuantInfo_UnaryQuantInfo; +}; + +template<> struct QuantInfoTraits<ConvQuantInfo> { + static const QuantInfo enum_value = QuantInfo_ConvQuantInfo; +}; + +template<> struct QuantInfoTraits<MatMulQuantInfo> { + static const QuantInfo enum_value = QuantInfo_MatMulQuantInfo; +}; + +template<> struct QuantInfoTraits<PadQuantInfo> { + static const QuantInfo enum_value = QuantInfo_PadQuantInfo; +}; + +bool VerifyQuantInfo(flatbuffers::Verifier &verifier, const void *obj, QuantInfo type); +bool VerifyQuantInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types); + +struct Pool2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PADDING = 4, + VT_KERNEL = 6, + VT_STRIDE = 8 + }; + const flatbuffers::Vector<int32_t> *padding() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_PADDING); + } + const flatbuffers::Vector<int32_t> *kernel() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_KERNEL); + } + const flatbuffers::Vector<int32_t> *stride() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PADDING) && + verifier.VerifyVector(padding()) && + VerifyOffset(verifier, VT_KERNEL) && + verifier.VerifyVector(kernel()) && + VerifyOffset(verifier, VT_STRIDE) && + verifier.VerifyVector(stride()) && + verifier.EndTable(); + } +}; + +struct Pool2dAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padding(flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding) { + fbb_.AddOffset(Pool2dAttribute::VT_PADDING, padding); + } + void add_kernel(flatbuffers::Offset<flatbuffers::Vector<int32_t>> kernel) { + fbb_.AddOffset(Pool2dAttribute::VT_KERNEL, kernel); + } + void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) { + fbb_.AddOffset(Pool2dAttribute::VT_STRIDE, stride); + } + explicit Pool2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Pool2dAttributeBuilder &operator=(const Pool2dAttributeBuilder &); + flatbuffers::Offset<Pool2dAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<Pool2dAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<Pool2dAttribute> CreatePool2dAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> kernel = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0) { + Pool2dAttributeBuilder builder_(_fbb); + builder_.add_stride(stride); + builder_.add_kernel(kernel); + builder_.add_padding(padding); + return builder_.Finish(); +} + +inline flatbuffers::Offset<Pool2dAttribute> CreatePool2dAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *padding = nullptr, + const std::vector<int32_t> *kernel = nullptr, + const std::vector<int32_t> *stride = nullptr) { + auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0; + auto kernel__ = kernel ? _fbb.CreateVector<int32_t>(*kernel) : 0; + auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0; + return tosa::CreatePool2dAttribute( + _fbb, + padding__, + kernel__, + stride__); +} + +struct Conv2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_PADDING = 4, + VT_STRIDE = 6, + VT_DILATION = 8 + }; + const flatbuffers::Vector<int32_t> *padding() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_PADDING); + } + const flatbuffers::Vector<int32_t> *stride() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE); + } + const flatbuffers::Vector<int32_t> *dilation() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DILATION); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_PADDING) && + verifier.VerifyVector(padding()) && + VerifyOffset(verifier, VT_STRIDE) && + verifier.VerifyVector(stride()) && + VerifyOffset(verifier, VT_DILATION) && + verifier.VerifyVector(dilation()) && + verifier.EndTable(); + } +}; + +struct Conv2dAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_padding(flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding) { + fbb_.AddOffset(Conv2dAttribute::VT_PADDING, padding); + } + void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) { + fbb_.AddOffset(Conv2dAttribute::VT_STRIDE, stride); + } + void add_dilation(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation) { + fbb_.AddOffset(Conv2dAttribute::VT_DILATION, dilation); + } + explicit Conv2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + Conv2dAttributeBuilder &operator=(const Conv2dAttributeBuilder &); + flatbuffers::Offset<Conv2dAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<Conv2dAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<Conv2dAttribute> CreateConv2dAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> padding = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation = 0) { + Conv2dAttributeBuilder builder_(_fbb); + builder_.add_dilation(dilation); + builder_.add_stride(stride); + builder_.add_padding(padding); + return builder_.Finish(); +} + +inline flatbuffers::Offset<Conv2dAttribute> CreateConv2dAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *padding = nullptr, + const std::vector<int32_t> *stride = nullptr, + const std::vector<int32_t> *dilation = nullptr) { + auto padding__ = padding ? _fbb.CreateVector<int32_t>(*padding) : 0; + auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0; + auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0; + return tosa::CreateConv2dAttribute( + _fbb, + padding__, + stride__, + dilation__); +} + +struct TransposeConv2dAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OUTPAD = 4, + VT_STRIDE = 6, + VT_DILATION = 8, + VT_OUTPUT_SHAPE = 10 + }; + const flatbuffers::Vector<int32_t> *outpad() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPAD); + } + const flatbuffers::Vector<int32_t> *stride() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE); + } + const flatbuffers::Vector<int32_t> *dilation() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_DILATION); + } + const flatbuffers::Vector<int32_t> *output_shape() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUT_SHAPE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_OUTPAD) && + verifier.VerifyVector(outpad()) && + VerifyOffset(verifier, VT_STRIDE) && + verifier.VerifyVector(stride()) && + VerifyOffset(verifier, VT_DILATION) && + verifier.VerifyVector(dilation()) && + VerifyOffset(verifier, VT_OUTPUT_SHAPE) && + verifier.VerifyVector(output_shape()) && + verifier.EndTable(); + } +}; + +struct TransposeConv2dAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_outpad(flatbuffers::Offset<flatbuffers::Vector<int32_t>> outpad) { + fbb_.AddOffset(TransposeConv2dAttribute::VT_OUTPAD, outpad); + } + void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) { + fbb_.AddOffset(TransposeConv2dAttribute::VT_STRIDE, stride); + } + void add_dilation(flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation) { + fbb_.AddOffset(TransposeConv2dAttribute::VT_DILATION, dilation); + } + void add_output_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_shape) { + fbb_.AddOffset(TransposeConv2dAttribute::VT_OUTPUT_SHAPE, output_shape); + } + explicit TransposeConv2dAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TransposeConv2dAttributeBuilder &operator=(const TransposeConv2dAttributeBuilder &); + flatbuffers::Offset<TransposeConv2dAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TransposeConv2dAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<TransposeConv2dAttribute> CreateTransposeConv2dAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> outpad = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> dilation = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_shape = 0) { + TransposeConv2dAttributeBuilder builder_(_fbb); + builder_.add_output_shape(output_shape); + builder_.add_dilation(dilation); + builder_.add_stride(stride); + builder_.add_outpad(outpad); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TransposeConv2dAttribute> CreateTransposeConv2dAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *outpad = nullptr, + const std::vector<int32_t> *stride = nullptr, + const std::vector<int32_t> *dilation = nullptr, + const std::vector<int32_t> *output_shape = nullptr) { + auto outpad__ = outpad ? _fbb.CreateVector<int32_t>(*outpad) : 0; + auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0; + auto dilation__ = dilation ? _fbb.CreateVector<int32_t>(*dilation) : 0; + auto output_shape__ = output_shape ? _fbb.CreateVector<int32_t>(*output_shape) : 0; + return tosa::CreateTransposeConv2dAttribute( + _fbb, + outpad__, + stride__, + dilation__, + output_shape__); +} + +struct ReluNAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MAX_INT = 4, + VT_MAX_FP = 6 + }; + int32_t max_int() const { + return GetField<int32_t>(VT_MAX_INT, 0); + } + float max_fp() const { + return GetField<float>(VT_MAX_FP, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_MAX_INT) && + VerifyField<float>(verifier, VT_MAX_FP) && + verifier.EndTable(); + } +}; + +struct ReluNAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_max_int(int32_t max_int) { + fbb_.AddElement<int32_t>(ReluNAttribute::VT_MAX_INT, max_int, 0); + } + void add_max_fp(float max_fp) { + fbb_.AddElement<float>(ReluNAttribute::VT_MAX_FP, max_fp, 0.0f); + } + explicit ReluNAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ReluNAttributeBuilder &operator=(const ReluNAttributeBuilder &); + flatbuffers::Offset<ReluNAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ReluNAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<ReluNAttribute> CreateReluNAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t max_int = 0, + float max_fp = 0.0f) { + ReluNAttributeBuilder builder_(_fbb); + builder_.add_max_fp(max_fp); + builder_.add_max_int(max_int); + return builder_.Finish(); +} + +struct AxisAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_AXIS = 4 + }; + int32_t axis() const { + return GetField<int32_t>(VT_AXIS, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_AXIS) && + verifier.EndTable(); + } +}; + +struct AxisAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_axis(int32_t axis) { + fbb_.AddElement<int32_t>(AxisAttribute::VT_AXIS, axis, 0); + } + explicit AxisAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + AxisAttributeBuilder &operator=(const AxisAttributeBuilder &); + flatbuffers::Offset<AxisAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<AxisAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<AxisAttribute> CreateAxisAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t axis = 0) { + AxisAttributeBuilder builder_(_fbb); + builder_.add_axis(axis); + return builder_.Finish(); +} + +struct ReshapeAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_SHAPE = 4 + }; + const flatbuffers::Vector<int32_t> *shape() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_SHAPE) && + verifier.VerifyVector(shape()) && + verifier.EndTable(); + } +}; + +struct ReshapeAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) { + fbb_.AddOffset(ReshapeAttribute::VT_SHAPE, shape); + } + explicit ReshapeAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ReshapeAttributeBuilder &operator=(const ReshapeAttributeBuilder &); + flatbuffers::Offset<ReshapeAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ReshapeAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<ReshapeAttribute> CreateReshapeAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0) { + ReshapeAttributeBuilder builder_(_fbb); + builder_.add_shape(shape); + return builder_.Finish(); +} + +inline flatbuffers::Offset<ReshapeAttribute> CreateReshapeAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *shape = nullptr) { + auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0; + return tosa::CreateReshapeAttribute( + _fbb, + shape__); +} + +struct SliceAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_BEGIN = 4, + VT_SIZE = 6 + }; + const flatbuffers::Vector<int32_t> *begin() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_BEGIN); + } + const flatbuffers::Vector<int32_t> *size() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SIZE); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_BEGIN) && + verifier.VerifyVector(begin()) && + VerifyOffset(verifier, VT_SIZE) && + verifier.VerifyVector(size()) && + verifier.EndTable(); + } +}; + +struct SliceAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_begin(flatbuffers::Offset<flatbuffers::Vector<int32_t>> begin) { + fbb_.AddOffset(SliceAttribute::VT_BEGIN, begin); + } + void add_size(flatbuffers::Offset<flatbuffers::Vector<int32_t>> size) { + fbb_.AddOffset(SliceAttribute::VT_SIZE, size); + } + explicit SliceAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + SliceAttributeBuilder &operator=(const SliceAttributeBuilder &); + flatbuffers::Offset<SliceAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<SliceAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<SliceAttribute> CreateSliceAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> begin = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> size = 0) { + SliceAttributeBuilder builder_(_fbb); + builder_.add_size(size); + builder_.add_begin(begin); + return builder_.Finish(); +} + +inline flatbuffers::Offset<SliceAttribute> CreateSliceAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *begin = nullptr, + const std::vector<int32_t> *size = nullptr) { + auto begin__ = begin ? _fbb.CreateVector<int32_t>(*begin) : 0; + auto size__ = size ? _fbb.CreateVector<int32_t>(*size) : 0; + return tosa::CreateSliceAttribute( + _fbb, + begin__, + size__); +} + +struct TileAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MULTIPLES = 4 + }; + const flatbuffers::Vector<int32_t> *multiples() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_MULTIPLES); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_MULTIPLES) && + verifier.VerifyVector(multiples()) && + verifier.EndTable(); + } +}; + +struct TileAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_multiples(flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiples) { + fbb_.AddOffset(TileAttribute::VT_MULTIPLES, multiples); + } + explicit TileAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TileAttributeBuilder &operator=(const TileAttributeBuilder &); + flatbuffers::Offset<TileAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TileAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<TileAttribute> CreateTileAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiples = 0) { + TileAttributeBuilder builder_(_fbb); + builder_.add_multiples(multiples); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TileAttribute> CreateTileAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *multiples = nullptr) { + auto multiples__ = multiples ? _fbb.CreateVector<int32_t>(*multiples) : 0; + return tosa::CreateTileAttribute( + _fbb, + multiples__); +} + +struct ResizeAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OUTPUT_SIZE = 4, + VT_STRIDE = 6, + VT_OFFSET = 8, + VT_SHIFT = 10, + VT_MODE = 12 + }; + const flatbuffers::Vector<int32_t> *output_size() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OUTPUT_SIZE); + } + const flatbuffers::Vector<int32_t> *stride() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_STRIDE); + } + const flatbuffers::Vector<int32_t> *offset() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_OFFSET); + } + int32_t shift() const { + return GetField<int32_t>(VT_SHIFT, 0); + } + ResizeMode mode() const { + return static_cast<ResizeMode>(GetField<uint32_t>(VT_MODE, 0)); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_OUTPUT_SIZE) && + verifier.VerifyVector(output_size()) && + VerifyOffset(verifier, VT_STRIDE) && + verifier.VerifyVector(stride()) && + VerifyOffset(verifier, VT_OFFSET) && + verifier.VerifyVector(offset()) && + VerifyField<int32_t>(verifier, VT_SHIFT) && + VerifyField<uint32_t>(verifier, VT_MODE) && + verifier.EndTable(); + } +}; + +struct ResizeAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_output_size(flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_size) { + fbb_.AddOffset(ResizeAttribute::VT_OUTPUT_SIZE, output_size); + } + void add_stride(flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride) { + fbb_.AddOffset(ResizeAttribute::VT_STRIDE, stride); + } + void add_offset(flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset) { + fbb_.AddOffset(ResizeAttribute::VT_OFFSET, offset); + } + void add_shift(int32_t shift) { + fbb_.AddElement<int32_t>(ResizeAttribute::VT_SHIFT, shift, 0); + } + void add_mode(ResizeMode mode) { + fbb_.AddElement<uint32_t>(ResizeAttribute::VT_MODE, static_cast<uint32_t>(mode), 0); + } + explicit ResizeAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ResizeAttributeBuilder &operator=(const ResizeAttributeBuilder &); + flatbuffers::Offset<ResizeAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ResizeAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<ResizeAttribute> CreateResizeAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> output_size = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> stride = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> offset = 0, + int32_t shift = 0, + ResizeMode mode = ResizeMode_UNKNOWN) { + ResizeAttributeBuilder builder_(_fbb); + builder_.add_mode(mode); + builder_.add_shift(shift); + builder_.add_offset(offset); + builder_.add_stride(stride); + builder_.add_output_size(output_size); + return builder_.Finish(); +} + +inline flatbuffers::Offset<ResizeAttribute> CreateResizeAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const std::vector<int32_t> *output_size = nullptr, + const std::vector<int32_t> *stride = nullptr, + const std::vector<int32_t> *offset = nullptr, + int32_t shift = 0, + ResizeMode mode = ResizeMode_UNKNOWN) { + auto output_size__ = output_size ? _fbb.CreateVector<int32_t>(*output_size) : 0; + auto stride__ = stride ? _fbb.CreateVector<int32_t>(*stride) : 0; + auto offset__ = offset ? _fbb.CreateVector<int32_t>(*offset) : 0; + return tosa::CreateResizeAttribute( + _fbb, + output_size__, + stride__, + offset__, + shift, + mode); +} + +struct ClampAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_MIN_INT = 4, + VT_MAX_INT = 6, + VT_MIN_FP = 8, + VT_MAX_FP = 10 + }; + int32_t min_int() const { + return GetField<int32_t>(VT_MIN_INT, 0); + } + int32_t max_int() const { + return GetField<int32_t>(VT_MAX_INT, 0); + } + float min_fp() const { + return GetField<float>(VT_MIN_FP, 0.0f); + } + float max_fp() const { + return GetField<float>(VT_MAX_FP, 0.0f); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_MIN_INT) && + VerifyField<int32_t>(verifier, VT_MAX_INT) && + VerifyField<float>(verifier, VT_MIN_FP) && + VerifyField<float>(verifier, VT_MAX_FP) && + verifier.EndTable(); + } +}; + +struct ClampAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_min_int(int32_t min_int) { + fbb_.AddElement<int32_t>(ClampAttribute::VT_MIN_INT, min_int, 0); + } + void add_max_int(int32_t max_int) { + fbb_.AddElement<int32_t>(ClampAttribute::VT_MAX_INT, max_int, 0); + } + void add_min_fp(float min_fp) { + fbb_.AddElement<float>(ClampAttribute::VT_MIN_FP, min_fp, 0.0f); + } + void add_max_fp(float max_fp) { + fbb_.AddElement<float>(ClampAttribute::VT_MAX_FP, max_fp, 0.0f); + } + explicit ClampAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ClampAttributeBuilder &operator=(const ClampAttributeBuilder &); + flatbuffers::Offset<ClampAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ClampAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<ClampAttribute> CreateClampAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t min_int = 0, + int32_t max_int = 0, + float min_fp = 0.0f, + float max_fp = 0.0f) { + ClampAttributeBuilder builder_(_fbb); + builder_.add_max_fp(max_fp); + builder_.add_min_fp(min_fp); + builder_.add_max_int(max_int); + builder_.add_min_int(min_int); + return builder_.Finish(); +} + +struct RescaleAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUT_ZP = 4, + VT_OUTPUT_ZP = 6, + VT_MULTIPLIER = 8, + VT_SHIFT = 10, + VT_SCALE32 = 12, + VT_DOUBLE_ROUND = 14, + VT_PER_CHANNEL = 16 + }; + int32_t input_zp() const { + return GetField<int32_t>(VT_INPUT_ZP, 0); + } + int32_t output_zp() const { + return GetField<int32_t>(VT_OUTPUT_ZP, 0); + } + const flatbuffers::Vector<int32_t> *multiplier() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_MULTIPLIER); + } + const flatbuffers::Vector<int32_t> *shift() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHIFT); + } + bool scale32() const { + return GetField<uint8_t>(VT_SCALE32, 0) != 0; + } + bool double_round() const { + return GetField<uint8_t>(VT_DOUBLE_ROUND, 0) != 0; + } + bool per_channel() const { + return GetField<uint8_t>(VT_PER_CHANNEL, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_INPUT_ZP) && + VerifyField<int32_t>(verifier, VT_OUTPUT_ZP) && + VerifyOffset(verifier, VT_MULTIPLIER) && + verifier.VerifyVector(multiplier()) && + VerifyOffset(verifier, VT_SHIFT) && + verifier.VerifyVector(shift()) && + VerifyField<uint8_t>(verifier, VT_SCALE32) && + VerifyField<uint8_t>(verifier, VT_DOUBLE_ROUND) && + VerifyField<uint8_t>(verifier, VT_PER_CHANNEL) && + verifier.EndTable(); + } +}; + +struct RescaleAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_input_zp(int32_t input_zp) { + fbb_.AddElement<int32_t>(RescaleAttribute::VT_INPUT_ZP, input_zp, 0); + } + void add_output_zp(int32_t output_zp) { + fbb_.AddElement<int32_t>(RescaleAttribute::VT_OUTPUT_ZP, output_zp, 0); + } + void add_multiplier(flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiplier) { + fbb_.AddOffset(RescaleAttribute::VT_MULTIPLIER, multiplier); + } + void add_shift(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shift) { + fbb_.AddOffset(RescaleAttribute::VT_SHIFT, shift); + } + void add_scale32(bool scale32) { + fbb_.AddElement<uint8_t>(RescaleAttribute::VT_SCALE32, static_cast<uint8_t>(scale32), 0); + } + void add_double_round(bool double_round) { + fbb_.AddElement<uint8_t>(RescaleAttribute::VT_DOUBLE_ROUND, static_cast<uint8_t>(double_round), 0); + } + void add_per_channel(bool per_channel) { + fbb_.AddElement<uint8_t>(RescaleAttribute::VT_PER_CHANNEL, static_cast<uint8_t>(per_channel), 0); + } + explicit RescaleAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + RescaleAttributeBuilder &operator=(const RescaleAttributeBuilder &); + flatbuffers::Offset<RescaleAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<RescaleAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<RescaleAttribute> CreateRescaleAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0, + int32_t output_zp = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> multiplier = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> shift = 0, + bool scale32 = false, + bool double_round = false, + bool per_channel = false) { + RescaleAttributeBuilder builder_(_fbb); + builder_.add_shift(shift); + builder_.add_multiplier(multiplier); + builder_.add_output_zp(output_zp); + builder_.add_input_zp(input_zp); + builder_.add_per_channel(per_channel); + builder_.add_double_round(double_round); + builder_.add_scale32(scale32); + return builder_.Finish(); +} + +inline flatbuffers::Offset<RescaleAttribute> CreateRescaleAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0, + int32_t output_zp = 0, + const std::vector<int32_t> *multiplier = nullptr, + const std::vector<int32_t> *shift = nullptr, + bool scale32 = false, + bool double_round = false, + bool per_channel = false) { + auto multiplier__ = multiplier ? _fbb.CreateVector<int32_t>(*multiplier) : 0; + auto shift__ = shift ? _fbb.CreateVector<int32_t>(*shift) : 0; + return tosa::CreateRescaleAttribute( + _fbb, + input_zp, + output_zp, + multiplier__, + shift__, + scale32, + double_round, + per_channel); +} + +struct CustomAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_IDENTIFIER = 4 + }; + const flatbuffers::String *identifier() const { + return GetPointer<const flatbuffers::String *>(VT_IDENTIFIER); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_IDENTIFIER) && + verifier.VerifyString(identifier()) && + verifier.EndTable(); + } +}; + +struct CustomAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_identifier(flatbuffers::Offset<flatbuffers::String> identifier) { + fbb_.AddOffset(CustomAttribute::VT_IDENTIFIER, identifier); + } + explicit CustomAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + CustomAttributeBuilder &operator=(const CustomAttributeBuilder &); + flatbuffers::Offset<CustomAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<CustomAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<CustomAttribute> CreateCustomAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::String> identifier = 0) { + CustomAttributeBuilder builder_(_fbb); + builder_.add_identifier(identifier); + return builder_.Finish(); +} + +inline flatbuffers::Offset<CustomAttribute> CreateCustomAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *identifier = nullptr) { + auto identifier__ = identifier ? _fbb.CreateString(identifier) : 0; + return tosa::CreateCustomAttribute( + _fbb, + identifier__); +} + +struct CondIfAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_THEN_BRANCH = 4, + VT_ELSE_BRANCH = 6 + }; + const flatbuffers::String *then_branch() const { + return GetPointer<const flatbuffers::String *>(VT_THEN_BRANCH); + } + const flatbuffers::String *else_branch() const { + return GetPointer<const flatbuffers::String *>(VT_ELSE_BRANCH); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_THEN_BRANCH) && + verifier.VerifyString(then_branch()) && + VerifyOffset(verifier, VT_ELSE_BRANCH) && + verifier.VerifyString(else_branch()) && + verifier.EndTable(); + } +}; + +struct CondIfAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_then_branch(flatbuffers::Offset<flatbuffers::String> then_branch) { + fbb_.AddOffset(CondIfAttribute::VT_THEN_BRANCH, then_branch); + } + void add_else_branch(flatbuffers::Offset<flatbuffers::String> else_branch) { + fbb_.AddOffset(CondIfAttribute::VT_ELSE_BRANCH, else_branch); + } + explicit CondIfAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + CondIfAttributeBuilder &operator=(const CondIfAttributeBuilder &); + flatbuffers::Offset<CondIfAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<CondIfAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<CondIfAttribute> CreateCondIfAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::String> then_branch = 0, + flatbuffers::Offset<flatbuffers::String> else_branch = 0) { + CondIfAttributeBuilder builder_(_fbb); + builder_.add_else_branch(else_branch); + builder_.add_then_branch(then_branch); + return builder_.Finish(); +} + +inline flatbuffers::Offset<CondIfAttribute> CreateCondIfAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *then_branch = nullptr, + const char *else_branch = nullptr) { + auto then_branch__ = then_branch ? _fbb.CreateString(then_branch) : 0; + auto else_branch__ = else_branch ? _fbb.CreateString(else_branch) : 0; + return tosa::CreateCondIfAttribute( + _fbb, + then_branch__, + else_branch__); +} + +struct WhileLoopAttribute FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_COND_BRANCH = 4, + VT_BODY_BRANCH = 6 + }; + const flatbuffers::String *cond_branch() const { + return GetPointer<const flatbuffers::String *>(VT_COND_BRANCH); + } + const flatbuffers::String *body_branch() const { + return GetPointer<const flatbuffers::String *>(VT_BODY_BRANCH); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_COND_BRANCH) && + verifier.VerifyString(cond_branch()) && + VerifyOffset(verifier, VT_BODY_BRANCH) && + verifier.VerifyString(body_branch()) && + verifier.EndTable(); + } +}; + +struct WhileLoopAttributeBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_cond_branch(flatbuffers::Offset<flatbuffers::String> cond_branch) { + fbb_.AddOffset(WhileLoopAttribute::VT_COND_BRANCH, cond_branch); + } + void add_body_branch(flatbuffers::Offset<flatbuffers::String> body_branch) { + fbb_.AddOffset(WhileLoopAttribute::VT_BODY_BRANCH, body_branch); + } + explicit WhileLoopAttributeBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + WhileLoopAttributeBuilder &operator=(const WhileLoopAttributeBuilder &); + flatbuffers::Offset<WhileLoopAttribute> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<WhileLoopAttribute>(end); + return o; + } +}; + +inline flatbuffers::Offset<WhileLoopAttribute> CreateWhileLoopAttribute( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::String> cond_branch = 0, + flatbuffers::Offset<flatbuffers::String> body_branch = 0) { + WhileLoopAttributeBuilder builder_(_fbb); + builder_.add_body_branch(body_branch); + builder_.add_cond_branch(cond_branch); + return builder_.Finish(); +} + +inline flatbuffers::Offset<WhileLoopAttribute> CreateWhileLoopAttributeDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *cond_branch = nullptr, + const char *body_branch = nullptr) { + auto cond_branch__ = cond_branch ? _fbb.CreateString(cond_branch) : 0; + auto body_branch__ = body_branch ? _fbb.CreateString(body_branch) : 0; + return tosa::CreateWhileLoopAttribute( + _fbb, + cond_branch__, + body_branch__); +} + +struct UnaryQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUT_ZP = 4, + VT_OUTPUT_ZP = 6 + }; + int32_t input_zp() const { + return GetField<int32_t>(VT_INPUT_ZP, 0); + } + int32_t output_zp() const { + return GetField<int32_t>(VT_OUTPUT_ZP, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_INPUT_ZP) && + VerifyField<int32_t>(verifier, VT_OUTPUT_ZP) && + verifier.EndTable(); + } +}; + +struct UnaryQuantInfoBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_input_zp(int32_t input_zp) { + fbb_.AddElement<int32_t>(UnaryQuantInfo::VT_INPUT_ZP, input_zp, 0); + } + void add_output_zp(int32_t output_zp) { + fbb_.AddElement<int32_t>(UnaryQuantInfo::VT_OUTPUT_ZP, output_zp, 0); + } + explicit UnaryQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + UnaryQuantInfoBuilder &operator=(const UnaryQuantInfoBuilder &); + flatbuffers::Offset<UnaryQuantInfo> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<UnaryQuantInfo>(end); + return o; + } +}; + +inline flatbuffers::Offset<UnaryQuantInfo> CreateUnaryQuantInfo( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0, + int32_t output_zp = 0) { + UnaryQuantInfoBuilder builder_(_fbb); + builder_.add_output_zp(output_zp); + builder_.add_input_zp(input_zp); + return builder_.Finish(); +} + +struct ConvQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUT_ZP = 4, + VT_WEIGHT_ZP = 6 + }; + int32_t input_zp() const { + return GetField<int32_t>(VT_INPUT_ZP, 0); + } + int32_t weight_zp() const { + return GetField<int32_t>(VT_WEIGHT_ZP, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_INPUT_ZP) && + VerifyField<int32_t>(verifier, VT_WEIGHT_ZP) && + verifier.EndTable(); + } +}; + +struct ConvQuantInfoBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_input_zp(int32_t input_zp) { + fbb_.AddElement<int32_t>(ConvQuantInfo::VT_INPUT_ZP, input_zp, 0); + } + void add_weight_zp(int32_t weight_zp) { + fbb_.AddElement<int32_t>(ConvQuantInfo::VT_WEIGHT_ZP, weight_zp, 0); + } + explicit ConvQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ConvQuantInfoBuilder &operator=(const ConvQuantInfoBuilder &); + flatbuffers::Offset<ConvQuantInfo> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<ConvQuantInfo>(end); + return o; + } +}; + +inline flatbuffers::Offset<ConvQuantInfo> CreateConvQuantInfo( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0, + int32_t weight_zp = 0) { + ConvQuantInfoBuilder builder_(_fbb); + builder_.add_weight_zp(weight_zp); + builder_.add_input_zp(input_zp); + return builder_.Finish(); +} + +struct MatMulQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_A_ZP = 4, + VT_B_ZP = 6 + }; + int32_t a_zp() const { + return GetField<int32_t>(VT_A_ZP, 0); + } + int32_t b_zp() const { + return GetField<int32_t>(VT_B_ZP, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_A_ZP) && + VerifyField<int32_t>(verifier, VT_B_ZP) && + verifier.EndTable(); + } +}; + +struct MatMulQuantInfoBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_a_zp(int32_t a_zp) { + fbb_.AddElement<int32_t>(MatMulQuantInfo::VT_A_ZP, a_zp, 0); + } + void add_b_zp(int32_t b_zp) { + fbb_.AddElement<int32_t>(MatMulQuantInfo::VT_B_ZP, b_zp, 0); + } + explicit MatMulQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + MatMulQuantInfoBuilder &operator=(const MatMulQuantInfoBuilder &); + flatbuffers::Offset<MatMulQuantInfo> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<MatMulQuantInfo>(end); + return o; + } +}; + +inline flatbuffers::Offset<MatMulQuantInfo> CreateMatMulQuantInfo( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t a_zp = 0, + int32_t b_zp = 0) { + MatMulQuantInfoBuilder builder_(_fbb); + builder_.add_b_zp(b_zp); + builder_.add_a_zp(a_zp); + return builder_.Finish(); +} + +struct PadQuantInfo FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_INPUT_ZP = 4 + }; + int32_t input_zp() const { + return GetField<int32_t>(VT_INPUT_ZP, 0); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT_INPUT_ZP) && + verifier.EndTable(); + } +}; + +struct PadQuantInfoBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_input_zp(int32_t input_zp) { + fbb_.AddElement<int32_t>(PadQuantInfo::VT_INPUT_ZP, input_zp, 0); + } + explicit PadQuantInfoBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + PadQuantInfoBuilder &operator=(const PadQuantInfoBuilder &); + flatbuffers::Offset<PadQuantInfo> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<PadQuantInfo>(end); + return o; + } +}; + +inline flatbuffers::Offset<PadQuantInfo> CreatePadQuantInfo( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t input_zp = 0) { + PadQuantInfoBuilder builder_(_fbb); + builder_.add_input_zp(input_zp); + return builder_.Finish(); +} + +struct Version FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT__MAJOR = 4, + VT__MINOR = 6, + VT__PATCH = 8, + VT__EXPERIMENTAL = 10 + }; + int32_t _major() const { + return GetField<int32_t>(VT__MAJOR, 0); + } + int32_t _minor() const { + return GetField<int32_t>(VT__MINOR, 20); + } + int32_t _patch() const { + return GetField<int32_t>(VT__PATCH, 0); + } + bool _experimental() const { + return GetField<uint8_t>(VT__EXPERIMENTAL, 0) != 0; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<int32_t>(verifier, VT__MAJOR) && + VerifyField<int32_t>(verifier, VT__MINOR) && + VerifyField<int32_t>(verifier, VT__PATCH) && + VerifyField<uint8_t>(verifier, VT__EXPERIMENTAL) && + verifier.EndTable(); + } +}; + +struct VersionBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add__major(int32_t _major) { + fbb_.AddElement<int32_t>(Version::VT__MAJOR, _major, 0); + } + void add__minor(int32_t _minor) { + fbb_.AddElement<int32_t>(Version::VT__MINOR, _minor, 20); + } + void add__patch(int32_t _patch) { + fbb_.AddElement<int32_t>(Version::VT__PATCH, _patch, 0); + } + void add__experimental(bool _experimental) { + fbb_.AddElement<uint8_t>(Version::VT__EXPERIMENTAL, static_cast<uint8_t>(_experimental), 0); + } + explicit VersionBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + VersionBuilder &operator=(const VersionBuilder &); + flatbuffers::Offset<Version> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<Version>(end); + return o; + } +}; + +inline flatbuffers::Offset<Version> CreateVersion( + flatbuffers::FlatBufferBuilder &_fbb, + int32_t _major = 0, + int32_t _minor = 20, + int32_t _patch = 0, + bool _experimental = false) { + VersionBuilder builder_(_fbb); + builder_.add__patch(_patch); + builder_.add__minor(_minor); + builder_.add__major(_major); + builder_.add__experimental(_experimental); + return builder_.Finish(); +} + +struct TosaTensor FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_SHAPE = 6, + VT_TYPE = 8, + VT_USAGE = 10, + VT_FORMAT = 12, + VT_NPY_FILENAME = 14 + }; + const flatbuffers::String *name() const { + return GetPointer<const flatbuffers::String *>(VT_NAME); + } + const flatbuffers::Vector<int32_t> *shape() const { + return GetPointer<const flatbuffers::Vector<int32_t> *>(VT_SHAPE); + } + DType type() const { + return static_cast<DType>(GetField<uint32_t>(VT_TYPE, 0)); + } + const flatbuffers::Vector<uint32_t> *usage() const { + return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_USAGE); + } + const flatbuffers::Vector<uint32_t> *format() const { + return GetPointer<const flatbuffers::Vector<uint32_t> *>(VT_FORMAT); + } + const flatbuffers::String *npy_filename() const { + return GetPointer<const flatbuffers::String *>(VT_NPY_FILENAME); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_SHAPE) && + verifier.VerifyVector(shape()) && + VerifyField<uint32_t>(verifier, VT_TYPE) && + VerifyOffset(verifier, VT_USAGE) && + verifier.VerifyVector(usage()) && + VerifyOffset(verifier, VT_FORMAT) && + verifier.VerifyVector(format()) && + VerifyOffset(verifier, VT_NPY_FILENAME) && + verifier.VerifyString(npy_filename()) && + verifier.EndTable(); + } +}; + +struct TosaTensorBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset<flatbuffers::String> name) { + fbb_.AddOffset(TosaTensor::VT_NAME, name); + } + void add_shape(flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape) { + fbb_.AddOffset(TosaTensor::VT_SHAPE, shape); + } + void add_type(DType type) { + fbb_.AddElement<uint32_t>(TosaTensor::VT_TYPE, static_cast<uint32_t>(type), 0); + } + void add_usage(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> usage) { + fbb_.AddOffset(TosaTensor::VT_USAGE, usage); + } + void add_format(flatbuffers::Offset<flatbuffers::Vector<uint32_t>> format) { + fbb_.AddOffset(TosaTensor::VT_FORMAT, format); + } + void add_npy_filename(flatbuffers::Offset<flatbuffers::String> npy_filename) { + fbb_.AddOffset(TosaTensor::VT_NPY_FILENAME, npy_filename); + } + explicit TosaTensorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TosaTensorBuilder &operator=(const TosaTensorBuilder &); + flatbuffers::Offset<TosaTensor> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TosaTensor>(end); + return o; + } +}; + +inline flatbuffers::Offset<TosaTensor> CreateTosaTensor( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::String> name = 0, + flatbuffers::Offset<flatbuffers::Vector<int32_t>> shape = 0, + DType type = DType_UNKNOWN, + flatbuffers::Offset<flatbuffers::Vector<uint32_t>> usage = 0, + flatbuffers::Offset<flatbuffers::Vector<uint32_t>> format = 0, + flatbuffers::Offset<flatbuffers::String> npy_filename = 0) { + TosaTensorBuilder builder_(_fbb); + builder_.add_npy_filename(npy_filename); + builder_.add_format(format); + builder_.add_usage(usage); + builder_.add_type(type); + builder_.add_shape(shape); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TosaTensor> CreateTosaTensorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + const std::vector<int32_t> *shape = nullptr, + DType type = DType_UNKNOWN, + const std::vector<uint32_t> *usage = nullptr, + const std::vector<uint32_t> *format = nullptr, + const char *npy_filename = nullptr) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto shape__ = shape ? _fbb.CreateVector<int32_t>(*shape) : 0; + auto usage__ = usage ? _fbb.CreateVector<uint32_t>(*usage) : 0; + auto format__ = format ? _fbb.CreateVector<uint32_t>(*format) : 0; + auto npy_filename__ = npy_filename ? _fbb.CreateString(npy_filename) : 0; + return tosa::CreateTosaTensor( + _fbb, + name__, + shape__, + type, + usage__, + format__, + npy_filename__); +} + +struct TosaOperator FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_OP = 4, + VT_ATTRIBUTE_TYPE = 6, + VT_ATTRIBUTE = 8, + VT_INPUTS = 10, + VT_OUTPUTS = 12, + VT_QUANT_INFO_TYPE = 14, + VT_QUANT_INFO = 16 + }; + Op op() const { + return static_cast<Op>(GetField<uint32_t>(VT_OP, 0)); + } + Attribute attribute_type() const { + return static_cast<Attribute>(GetField<uint8_t>(VT_ATTRIBUTE_TYPE, 0)); + } + const void *attribute() const { + return GetPointer<const void *>(VT_ATTRIBUTE); + } + template<typename T> const T *attribute_as() const; + const Pool2dAttribute *attribute_as_Pool2dAttribute() const { + return attribute_type() == Attribute_Pool2dAttribute ? static_cast<const Pool2dAttribute *>(attribute()) : nullptr; + } + const Conv2dAttribute *attribute_as_Conv2dAttribute() const { + return attribute_type() == Attribute_Conv2dAttribute ? static_cast<const Conv2dAttribute *>(attribute()) : nullptr; + } + const TransposeConv2dAttribute *attribute_as_TransposeConv2dAttribute() const { + return attribute_type() == Attribute_TransposeConv2dAttribute ? static_cast<const TransposeConv2dAttribute *>(attribute()) : nullptr; + } + const ReluNAttribute *attribute_as_ReluNAttribute() const { + return attribute_type() == Attribute_ReluNAttribute ? static_cast<const ReluNAttribute *>(attribute()) : nullptr; + } + const AxisAttribute *attribute_as_AxisAttribute() const { + return attribute_type() == Attribute_AxisAttribute ? static_cast<const AxisAttribute *>(attribute()) : nullptr; + } + const ReshapeAttribute *attribute_as_ReshapeAttribute() const { + return attribute_type() == Attribute_ReshapeAttribute ? static_cast<const ReshapeAttribute *>(attribute()) : nullptr; + } + const SliceAttribute *attribute_as_SliceAttribute() const { + return attribute_type() == Attribute_SliceAttribute ? static_cast<const SliceAttribute *>(attribute()) : nullptr; + } + const TileAttribute *attribute_as_TileAttribute() const { + return attribute_type() == Attribute_TileAttribute ? static_cast<const TileAttribute *>(attribute()) : nullptr; + } + const ResizeAttribute *attribute_as_ResizeAttribute() const { + return attribute_type() == Attribute_ResizeAttribute ? static_cast<const ResizeAttribute *>(attribute()) : nullptr; + } + const ClampAttribute *attribute_as_ClampAttribute() const { + return attribute_type() == Attribute_ClampAttribute ? static_cast<const ClampAttribute *>(attribute()) : nullptr; + } + const RescaleAttribute *attribute_as_RescaleAttribute() const { + return attribute_type() == Attribute_RescaleAttribute ? static_cast<const RescaleAttribute *>(attribute()) : nullptr; + } + const CustomAttribute *attribute_as_CustomAttribute() const { + return attribute_type() == Attribute_CustomAttribute ? static_cast<const CustomAttribute *>(attribute()) : nullptr; + } + const CondIfAttribute *attribute_as_CondIfAttribute() const { + return attribute_type() == Attribute_CondIfAttribute ? static_cast<const CondIfAttribute *>(attribute()) : nullptr; + } + const WhileLoopAttribute *attribute_as_WhileLoopAttribute() const { + return attribute_type() == Attribute_WhileLoopAttribute ? static_cast<const WhileLoopAttribute *>(attribute()) : nullptr; + } + const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *inputs() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_INPUTS); + } + const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputs() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OUTPUTS); + } + QuantInfo quant_info_type() const { + return static_cast<QuantInfo>(GetField<uint8_t>(VT_QUANT_INFO_TYPE, 0)); + } + const void *quant_info() const { + return GetPointer<const void *>(VT_QUANT_INFO); + } + template<typename T> const T *quant_info_as() const; + const UnaryQuantInfo *quant_info_as_UnaryQuantInfo() const { + return quant_info_type() == QuantInfo_UnaryQuantInfo ? static_cast<const UnaryQuantInfo *>(quant_info()) : nullptr; + } + const ConvQuantInfo *quant_info_as_ConvQuantInfo() const { + return quant_info_type() == QuantInfo_ConvQuantInfo ? static_cast<const ConvQuantInfo *>(quant_info()) : nullptr; + } + const MatMulQuantInfo *quant_info_as_MatMulQuantInfo() const { + return quant_info_type() == QuantInfo_MatMulQuantInfo ? static_cast<const MatMulQuantInfo *>(quant_info()) : nullptr; + } + const PadQuantInfo *quant_info_as_PadQuantInfo() const { + return quant_info_type() == QuantInfo_PadQuantInfo ? static_cast<const PadQuantInfo *>(quant_info()) : nullptr; + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField<uint32_t>(verifier, VT_OP) && + VerifyField<uint8_t>(verifier, VT_ATTRIBUTE_TYPE) && + VerifyOffset(verifier, VT_ATTRIBUTE) && + VerifyAttribute(verifier, attribute(), attribute_type()) && + VerifyOffset(verifier, VT_INPUTS) && + verifier.VerifyVector(inputs()) && + verifier.VerifyVectorOfStrings(inputs()) && + VerifyOffset(verifier, VT_OUTPUTS) && + verifier.VerifyVector(outputs()) && + verifier.VerifyVectorOfStrings(outputs()) && + VerifyField<uint8_t>(verifier, VT_QUANT_INFO_TYPE) && + VerifyOffset(verifier, VT_QUANT_INFO) && + VerifyQuantInfo(verifier, quant_info(), quant_info_type()) && + verifier.EndTable(); + } +}; + +template<> inline const Pool2dAttribute *TosaOperator::attribute_as<Pool2dAttribute>() const { + return attribute_as_Pool2dAttribute(); +} + +template<> inline const Conv2dAttribute *TosaOperator::attribute_as<Conv2dAttribute>() const { + return attribute_as_Conv2dAttribute(); +} + +template<> inline const TransposeConv2dAttribute *TosaOperator::attribute_as<TransposeConv2dAttribute>() const { + return attribute_as_TransposeConv2dAttribute(); +} + +template<> inline const ReluNAttribute *TosaOperator::attribute_as<ReluNAttribute>() const { + return attribute_as_ReluNAttribute(); +} + +template<> inline const AxisAttribute *TosaOperator::attribute_as<AxisAttribute>() const { + return attribute_as_AxisAttribute(); +} + +template<> inline const ReshapeAttribute *TosaOperator::attribute_as<ReshapeAttribute>() const { + return attribute_as_ReshapeAttribute(); +} + +template<> inline const SliceAttribute *TosaOperator::attribute_as<SliceAttribute>() const { + return attribute_as_SliceAttribute(); +} + +template<> inline const TileAttribute *TosaOperator::attribute_as<TileAttribute>() const { + return attribute_as_TileAttribute(); +} + +template<> inline const ResizeAttribute *TosaOperator::attribute_as<ResizeAttribute>() const { + return attribute_as_ResizeAttribute(); +} + +template<> inline const ClampAttribute *TosaOperator::attribute_as<ClampAttribute>() const { + return attribute_as_ClampAttribute(); +} + +template<> inline const RescaleAttribute *TosaOperator::attribute_as<RescaleAttribute>() const { + return attribute_as_RescaleAttribute(); +} + +template<> inline const CustomAttribute *TosaOperator::attribute_as<CustomAttribute>() const { + return attribute_as_CustomAttribute(); +} + +template<> inline const CondIfAttribute *TosaOperator::attribute_as<CondIfAttribute>() const { + return attribute_as_CondIfAttribute(); +} + +template<> inline const WhileLoopAttribute *TosaOperator::attribute_as<WhileLoopAttribute>() const { + return attribute_as_WhileLoopAttribute(); +} + +template<> inline const UnaryQuantInfo *TosaOperator::quant_info_as<UnaryQuantInfo>() const { + return quant_info_as_UnaryQuantInfo(); +} + +template<> inline const ConvQuantInfo *TosaOperator::quant_info_as<ConvQuantInfo>() const { + return quant_info_as_ConvQuantInfo(); +} + +template<> inline const MatMulQuantInfo *TosaOperator::quant_info_as<MatMulQuantInfo>() const { + return quant_info_as_MatMulQuantInfo(); +} + +template<> inline const PadQuantInfo *TosaOperator::quant_info_as<PadQuantInfo>() const { + return quant_info_as_PadQuantInfo(); +} + +struct TosaOperatorBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_op(Op op) { + fbb_.AddElement<uint32_t>(TosaOperator::VT_OP, static_cast<uint32_t>(op), 0); + } + void add_attribute_type(Attribute attribute_type) { + fbb_.AddElement<uint8_t>(TosaOperator::VT_ATTRIBUTE_TYPE, static_cast<uint8_t>(attribute_type), 0); + } + void add_attribute(flatbuffers::Offset<void> attribute) { + fbb_.AddOffset(TosaOperator::VT_ATTRIBUTE, attribute); + } + void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs) { + fbb_.AddOffset(TosaOperator::VT_INPUTS, inputs); + } + void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs) { + fbb_.AddOffset(TosaOperator::VT_OUTPUTS, outputs); + } + void add_quant_info_type(QuantInfo quant_info_type) { + fbb_.AddElement<uint8_t>(TosaOperator::VT_QUANT_INFO_TYPE, static_cast<uint8_t>(quant_info_type), 0); + } + void add_quant_info(flatbuffers::Offset<void> quant_info) { + fbb_.AddOffset(TosaOperator::VT_QUANT_INFO, quant_info); + } + explicit TosaOperatorBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TosaOperatorBuilder &operator=(const TosaOperatorBuilder &); + flatbuffers::Offset<TosaOperator> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TosaOperator>(end); + return o; + } +}; + +inline flatbuffers::Offset<TosaOperator> CreateTosaOperator( + flatbuffers::FlatBufferBuilder &_fbb, + Op op = Op_UNKNOWN, + Attribute attribute_type = Attribute_NONE, + flatbuffers::Offset<void> attribute = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs = 0, + QuantInfo quant_info_type = QuantInfo_NONE, + flatbuffers::Offset<void> quant_info = 0) { + TosaOperatorBuilder builder_(_fbb); + builder_.add_quant_info(quant_info); + builder_.add_outputs(outputs); + builder_.add_inputs(inputs); + builder_.add_attribute(attribute); + builder_.add_op(op); + builder_.add_quant_info_type(quant_info_type); + builder_.add_attribute_type(attribute_type); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TosaOperator> CreateTosaOperatorDirect( + flatbuffers::FlatBufferBuilder &_fbb, + Op op = Op_UNKNOWN, + Attribute attribute_type = Attribute_NONE, + flatbuffers::Offset<void> attribute = 0, + const std::vector<flatbuffers::Offset<flatbuffers::String>> *inputs = nullptr, + const std::vector<flatbuffers::Offset<flatbuffers::String>> *outputs = nullptr, + QuantInfo quant_info_type = QuantInfo_NONE, + flatbuffers::Offset<void> quant_info = 0) { + auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*inputs) : 0; + auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*outputs) : 0; + return tosa::CreateTosaOperator( + _fbb, + op, + attribute_type, + attribute, + inputs__, + outputs__, + quant_info_type, + quant_info); +} + +struct TosaBasicBlock FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_NAME = 4, + VT_OPERATORS = 6, + VT_TENSORS = 8, + VT_INPUTS = 10, + VT_OUTPUTS = 12 + }; + const flatbuffers::String *name() const { + return GetPointer<const flatbuffers::String *>(VT_NAME); + } + const flatbuffers::Vector<flatbuffers::Offset<TosaOperator>> *operators() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TosaOperator>> *>(VT_OPERATORS); + } + const flatbuffers::Vector<flatbuffers::Offset<TosaTensor>> *tensors() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TosaTensor>> *>(VT_TENSORS); + } + const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *inputs() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_INPUTS); + } + const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *outputs() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>> *>(VT_OUTPUTS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_NAME) && + verifier.VerifyString(name()) && + VerifyOffset(verifier, VT_OPERATORS) && + verifier.VerifyVector(operators()) && + verifier.VerifyVectorOfTables(operators()) && + VerifyOffset(verifier, VT_TENSORS) && + verifier.VerifyVector(tensors()) && + verifier.VerifyVectorOfTables(tensors()) && + VerifyOffset(verifier, VT_INPUTS) && + verifier.VerifyVector(inputs()) && + verifier.VerifyVectorOfStrings(inputs()) && + VerifyOffset(verifier, VT_OUTPUTS) && + verifier.VerifyVector(outputs()) && + verifier.VerifyVectorOfStrings(outputs()) && + verifier.EndTable(); + } +}; + +struct TosaBasicBlockBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_name(flatbuffers::Offset<flatbuffers::String> name) { + fbb_.AddOffset(TosaBasicBlock::VT_NAME, name); + } + void add_operators(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaOperator>>> operators) { + fbb_.AddOffset(TosaBasicBlock::VT_OPERATORS, operators); + } + void add_tensors(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaTensor>>> tensors) { + fbb_.AddOffset(TosaBasicBlock::VT_TENSORS, tensors); + } + void add_inputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs) { + fbb_.AddOffset(TosaBasicBlock::VT_INPUTS, inputs); + } + void add_outputs(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs) { + fbb_.AddOffset(TosaBasicBlock::VT_OUTPUTS, outputs); + } + explicit TosaBasicBlockBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TosaBasicBlockBuilder &operator=(const TosaBasicBlockBuilder &); + flatbuffers::Offset<TosaBasicBlock> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TosaBasicBlock>(end); + return o; + } +}; + +inline flatbuffers::Offset<TosaBasicBlock> CreateTosaBasicBlock( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<flatbuffers::String> name = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaOperator>>> operators = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaTensor>>> tensors = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> inputs = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<flatbuffers::String>>> outputs = 0) { + TosaBasicBlockBuilder builder_(_fbb); + builder_.add_outputs(outputs); + builder_.add_inputs(inputs); + builder_.add_tensors(tensors); + builder_.add_operators(operators); + builder_.add_name(name); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TosaBasicBlock> CreateTosaBasicBlockDirect( + flatbuffers::FlatBufferBuilder &_fbb, + const char *name = nullptr, + const std::vector<flatbuffers::Offset<TosaOperator>> *operators = nullptr, + const std::vector<flatbuffers::Offset<TosaTensor>> *tensors = nullptr, + const std::vector<flatbuffers::Offset<flatbuffers::String>> *inputs = nullptr, + const std::vector<flatbuffers::Offset<flatbuffers::String>> *outputs = nullptr) { + auto name__ = name ? _fbb.CreateString(name) : 0; + auto operators__ = operators ? _fbb.CreateVector<flatbuffers::Offset<TosaOperator>>(*operators) : 0; + auto tensors__ = tensors ? _fbb.CreateVector<flatbuffers::Offset<TosaTensor>>(*tensors) : 0; + auto inputs__ = inputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*inputs) : 0; + auto outputs__ = outputs ? _fbb.CreateVector<flatbuffers::Offset<flatbuffers::String>>(*outputs) : 0; + return tosa::CreateTosaBasicBlock( + _fbb, + name__, + operators__, + tensors__, + inputs__, + outputs__); +} + +struct TosaGraph FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table { + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_VERSION = 4, + VT_BLOCKS = 6 + }; + const Version *version() const { + return GetPointer<const Version *>(VT_VERSION); + } + const flatbuffers::Vector<flatbuffers::Offset<TosaBasicBlock>> *blocks() const { + return GetPointer<const flatbuffers::Vector<flatbuffers::Offset<TosaBasicBlock>> *>(VT_BLOCKS); + } + bool Verify(flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyOffset(verifier, VT_VERSION) && + verifier.VerifyTable(version()) && + VerifyOffset(verifier, VT_BLOCKS) && + verifier.VerifyVector(blocks()) && + verifier.VerifyVectorOfTables(blocks()) && + verifier.EndTable(); + } +}; + +struct TosaGraphBuilder { + flatbuffers::FlatBufferBuilder &fbb_; + flatbuffers::uoffset_t start_; + void add_version(flatbuffers::Offset<Version> version) { + fbb_.AddOffset(TosaGraph::VT_VERSION, version); + } + void add_blocks(flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaBasicBlock>>> blocks) { + fbb_.AddOffset(TosaGraph::VT_BLOCKS, blocks); + } + explicit TosaGraphBuilder(flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + TosaGraphBuilder &operator=(const TosaGraphBuilder &); + flatbuffers::Offset<TosaGraph> Finish() { + const auto end = fbb_.EndTable(start_); + auto o = flatbuffers::Offset<TosaGraph>(end); + return o; + } +}; + +inline flatbuffers::Offset<TosaGraph> CreateTosaGraph( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<Version> version = 0, + flatbuffers::Offset<flatbuffers::Vector<flatbuffers::Offset<TosaBasicBlock>>> blocks = 0) { + TosaGraphBuilder builder_(_fbb); + builder_.add_blocks(blocks); + builder_.add_version(version); + return builder_.Finish(); +} + +inline flatbuffers::Offset<TosaGraph> CreateTosaGraphDirect( + flatbuffers::FlatBufferBuilder &_fbb, + flatbuffers::Offset<Version> version = 0, + const std::vector<flatbuffers::Offset<TosaBasicBlock>> *blocks = nullptr) { + auto blocks__ = blocks ? _fbb.CreateVector<flatbuffers::Offset<TosaBasicBlock>>(*blocks) : 0; + return tosa::CreateTosaGraph( + _fbb, + version, + blocks__); +} + +inline bool VerifyAttribute(flatbuffers::Verifier &verifier, const void *obj, Attribute type) { + switch (type) { + case Attribute_NONE: { + return true; + } + case Attribute_Pool2dAttribute: { + auto ptr = reinterpret_cast<const Pool2dAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_Conv2dAttribute: { + auto ptr = reinterpret_cast<const Conv2dAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_TransposeConv2dAttribute: { + auto ptr = reinterpret_cast<const TransposeConv2dAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_ReluNAttribute: { + auto ptr = reinterpret_cast<const ReluNAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_AxisAttribute: { + auto ptr = reinterpret_cast<const AxisAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_ReshapeAttribute: { + auto ptr = reinterpret_cast<const ReshapeAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_SliceAttribute: { + auto ptr = reinterpret_cast<const SliceAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_TileAttribute: { + auto ptr = reinterpret_cast<const TileAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_ResizeAttribute: { + auto ptr = reinterpret_cast<const ResizeAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_ClampAttribute: { + auto ptr = reinterpret_cast<const ClampAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_RescaleAttribute: { + auto ptr = reinterpret_cast<const RescaleAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_CustomAttribute: { + auto ptr = reinterpret_cast<const CustomAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_CondIfAttribute: { + auto ptr = reinterpret_cast<const CondIfAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + case Attribute_WhileLoopAttribute: { + auto ptr = reinterpret_cast<const WhileLoopAttribute *>(obj); + return verifier.VerifyTable(ptr); + } + default: return false; + } +} + +inline bool VerifyAttributeVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyAttribute( + verifier, values->Get(i), types->GetEnum<Attribute>(i))) { + return false; + } + } + return true; +} + +inline bool VerifyQuantInfo(flatbuffers::Verifier &verifier, const void *obj, QuantInfo type) { + switch (type) { + case QuantInfo_NONE: { + return true; + } + case QuantInfo_UnaryQuantInfo: { + auto ptr = reinterpret_cast<const UnaryQuantInfo *>(obj); + return verifier.VerifyTable(ptr); + } + case QuantInfo_ConvQuantInfo: { + auto ptr = reinterpret_cast<const ConvQuantInfo *>(obj); + return verifier.VerifyTable(ptr); + } + case QuantInfo_MatMulQuantInfo: { + auto ptr = reinterpret_cast<const MatMulQuantInfo *>(obj); + return verifier.VerifyTable(ptr); + } + case QuantInfo_PadQuantInfo: { + auto ptr = reinterpret_cast<const PadQuantInfo *>(obj); + return verifier.VerifyTable(ptr); + } + default: return false; + } +} + +inline bool VerifyQuantInfoVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types) { + if (!values || !types) return !values && !types; + if (values->size() != types->size()) return false; + for (flatbuffers::uoffset_t i = 0; i < values->size(); ++i) { + if (!VerifyQuantInfo( + verifier, values->Get(i), types->GetEnum<QuantInfo>(i))) { + return false; + } + } + return true; +} + +inline const tosa::TosaGraph *GetTosaGraph(const void *buf) { + return flatbuffers::GetRoot<tosa::TosaGraph>(buf); +} + +inline const tosa::TosaGraph *GetSizePrefixedTosaGraph(const void *buf) { + return flatbuffers::GetSizePrefixedRoot<tosa::TosaGraph>(buf); +} + +inline const char *TosaGraphIdentifier() { + return "TOSA"; +} + +inline bool TosaGraphBufferHasIdentifier(const void *buf) { + return flatbuffers::BufferHasIdentifier( + buf, TosaGraphIdentifier()); +} + +inline bool VerifyTosaGraphBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifyBuffer<tosa::TosaGraph>(TosaGraphIdentifier()); +} + +inline bool VerifySizePrefixedTosaGraphBuffer( + flatbuffers::Verifier &verifier) { + return verifier.VerifySizePrefixedBuffer<tosa::TosaGraph>(TosaGraphIdentifier()); +} + +inline const char *TosaGraphExtension() { + return "tosa"; +} + +inline void FinishTosaGraphBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset<tosa::TosaGraph> root) { + fbb.Finish(root, TosaGraphIdentifier()); +} + +inline void FinishSizePrefixedTosaGraphBuffer( + flatbuffers::FlatBufferBuilder &fbb, + flatbuffers::Offset<tosa::TosaGraph> root) { + fbb.FinishSizePrefixed(root, TosaGraphIdentifier()); +} + +} // namespace tosa + +#endif // FLATBUFFERS_GENERATED_TOSA_TOSA_H_ diff --git a/serialization/tosa_serialization_handler.cpp b/serialization/tosa_serialization_handler.cpp new file mode 100644 index 0000000..7fe9f47 --- /dev/null +++ b/serialization/tosa_serialization_handler.cpp @@ -0,0 +1,1526 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#include "tosa_serialization_handler.h" + +#include <iostream> +using namespace tosa; + +TosaSerializationTensor::TosaSerializationTensor(const flatbuffers::String* name, + const flatbuffers::Vector<uint32_t>& usage, + const flatbuffers::Vector<int32_t>& shape, + DType dtype, + const flatbuffers::Vector<uint32_t>& format, + const flatbuffers::String* npy_filename) +{ + _dtype = dtype; + + _usage = new std::vector<Usage>(usage.size()); + for (uint32_t us : usage) + { + _usage->push_back((Usage)us); + } + assert(_usage); + + _format = new std::vector<Format>(format.size()); + for (uint32_t fm : format) + { + _format->push_back((Format)fm); + } + assert(_format); + + _shape = new std::vector<int32_t>(shape.begin(), shape.end()); + + _shape = new std::vector<int32_t>(shape.begin(), shape.end()); + assert(_shape); + + assert(name); + _name = new std::string(name->str()); + assert(_name); + + if (npy_filename) + { + _npy_filename = new std::string(npy_filename->str()); + assert(_npy_filename); + } + else + { + _npy_filename = nullptr; + } +} + +TosaSerializationTensor::TosaSerializationTensor(std::string name, + const std::vector<Usage>& usage, + const std::vector<int32_t>& shape, + DType dtype, + const std::vector<Format>& format, + const std::string* npy_filename) +{ + + _dtype = dtype; + + _usage = new std::vector<Usage>(usage); + assert(_usage); + + _format = new std::vector<Format>(format); + assert(_format); + + _shape = new std::vector<int32_t>(shape); + assert(_shape); + + _name = new std::string(name); + assert(_name); + + if (npy_filename) + { + _npy_filename = new std::string(*npy_filename); + assert(_npy_filename); + } + else + { + _npy_filename = nullptr; + } +} + +TosaSerializationTensor::TosaSerializationTensor() +{ + _dtype = DType_UNKNOWN; + + _usage = new std::vector<Usage>(); + _format = new std::vector<Format>(); + _shape = new std::vector<int32_t>(); + _name = new std::string("UNKNOWN"); + assert(_usage && _format && _shape && _name); + + _npy_filename = nullptr; +} + +TosaSerializationTensor::TosaSerializationTensor(const TosaSerializationTensor& rhs) +{ + _dtype = rhs._dtype; + + assert(rhs._usage); + _usage = new std::vector<Usage>(*rhs._usage); + assert(_usage); + + assert(rhs._format); + _format = new std::vector<Format>(*rhs._format); + assert(_format); + + assert(rhs._shape); + _shape = new std::vector<int32_t>(*rhs._shape); + assert(_shape); + + assert(rhs._name); + _name = new std::string(*rhs._name); + assert(_name); + + if (rhs._npy_filename) + { + _npy_filename = new std::string(*rhs._npy_filename); + assert(_npy_filename); + } + else + { + _npy_filename = nullptr; + } +} + +TosaSerializationTensor& TosaSerializationTensor::operator=(const TosaSerializationTensor& rhs) +{ + _dtype = rhs._dtype; + + delete _usage; + assert(rhs._usage); + _usage = new std::vector<Usage>(*rhs._usage); + assert(_usage); + + delete _format; + assert(rhs._format); + _format = new std::vector<Format>(*rhs._format); + assert(_format); + + delete _shape; + assert(rhs._shape); + _shape = new std::vector<int32_t>(*rhs._shape); + assert(_shape); + + delete _name; + assert(rhs._name); + _name = new std::string(*rhs._name); + assert(_name); + + if (_npy_filename) + delete _npy_filename; + + if (rhs._npy_filename) + { + _npy_filename = new std::string(*rhs._npy_filename); + } + else + { + _npy_filename = nullptr; + } + return *this; +} + +TosaSerializationTensor::TosaSerializationTensor(TosaSerializationTensor&& rhs) +{ + _dtype = rhs._dtype; + std::swap(_format, rhs._format); + std::swap(_usage, rhs._usage); + std::swap(_shape, rhs._shape); + std::swap(_name, rhs._name); + std::swap(_npy_filename, rhs._npy_filename); +} + +TosaSerializationTensor& TosaSerializationTensor::operator=(TosaSerializationTensor&& rhs) +{ + _dtype = rhs._dtype; + std::swap(_format, rhs._format); + std::swap(_usage, rhs._usage); + std::swap(_shape, rhs._shape); + std::swap(_name, rhs._name); + std::swap(_npy_filename, rhs._npy_filename); + return *this; +} + +TosaSerializationTensor::~TosaSerializationTensor() +{ + delete _usage; + delete _format; + delete _shape; + delete _name; + if (_npy_filename) + delete _npy_filename; +} + +TosaSerializationOperator::TosaSerializationOperator(Op op, + Attribute attribute_type, + const TosaAttributeBase* attribute, + QuantInfo qinfo_type, + const TosaQuantInfoBase* qinfo, + std::vector<std::string> input_tensor_names, + std::vector<std::string> output_tensor_names) +{ + _op = op; + _attribute_type = attribute_type; + + switch (attribute_type) + { + case Attribute_NONE: + _attribute = new TosaNoneAttribute(); + break; +#define DEF_ATTRIBUTE(NAME, ...) \ + case Attribute_##NAME##Attribute: \ + _attribute = new Tosa##NAME##Attribute(attribute); \ + break; +#include "attribute.def" +#undef DEF_ATTRIBUTE + default: + printf("TosaSerializationOperator::TosaSerializationOperator(): Attribute %s not implemented yet\n", + EnumNamesAttribute()[attribute_type]); + assert(0); + } + + _qinfo_type = qinfo_type; + switch (qinfo_type) + { + case QuantInfo_NONE: + _qinfo = new TosaNoneQuantInfo(); + break; +#define DEF_QUANTIZATION_INFO(NAME, ...) \ + case QuantInfo_##NAME##QuantInfo: \ + _qinfo = new Tosa##NAME##QuantInfo(qinfo); \ + break; +#include "quant_info.def" +#undef DEF_QUANTIZATION_INFO + default: + printf("TosaSerializationOperator::TosaSerializationOperator(): QuantInfo %s not implemented yet\n", + EnumNamesQuantInfo()[qinfo_type]); + assert(0); + } + + assert(_attribute && _qinfo); + + _input_tensor_names = new std::vector<std::string>(input_tensor_names); + _output_tensor_names = new std::vector<std::string>(output_tensor_names); + + assert(_input_tensor_names && _output_tensor_names); + + _input_tensors = new std::vector<TosaSerializationTensor*>(); + _output_tensors = new std::vector<TosaSerializationTensor*>(); + + assert(_input_tensors && _output_tensors); +} + +TosaSerializationOperator::~TosaSerializationOperator() +{ + delete _attribute; + delete _qinfo; + delete _input_tensor_names; + delete _output_tensor_names; + // TosaSerializationTensor should be free'd in TosaSerializationSerializationHandler destructor + delete _input_tensors; + delete _output_tensors; +} + +TosaSerializationBasicBlock::TosaSerializationBasicBlock(std::string name, + std::vector<TosaSerializationOperator*> operators, + std::vector<TosaSerializationTensor*> tensors, + std::vector<std::string> inputs, + std::vector<std::string> outputs) +{ + + _name = new std::string(name); + assert(_name); + + _operators = new std::vector<TosaSerializationOperator*>(operators); + assert(_operators); + + _tensors = new std::vector<TosaSerializationTensor*>(tensors); + assert(_tensors); + + _inputs = new std::vector<std::string>(inputs); + assert(_inputs); + + _outputs = new std::vector<std::string>(outputs); + assert(_outputs); +} + +TosaSerializationBasicBlock::~TosaSerializationBasicBlock() +{ + delete _name; + + // deallocate all operators + for (auto op : GetOperators()) + { + delete op; // ~TosaSerializationOperator() + } + delete _operators; + + // deallocate all tensors + for (auto ts : GetTensors()) + { + delete ts; // ~TosaSerializationTensor() + } + _tensors->clear(); + + delete _inputs; + delete _outputs; +} + +TosaSerializationHandler::TosaSerializationHandler() +{ + _schemaLoaded = false; + _builder = new flatbuffers::FlatBufferBuilder(); + _parser = new flatbuffers::Parser(); + _blocks = new std::vector<TosaSerializationBasicBlock*>(); + + assert(_builder && _parser && _blocks); + + SetTosaVersion(); +} + +TosaSerializationHandler::~TosaSerializationHandler() +{ + if (_version) + delete _version; + delete _builder; + delete _parser; + + Clear(); // deallocate all basic blocks + + delete _blocks; +} + +tosa_err_t TosaSerializationHandler::SetTosaVersion() +{ + // version is specified within .fbs + // and it's encoded as defaulted value of CreateTosaVersion() + // need to write out one object to read that value out + // TODO: very costly now. is there any better way to encode constant in .fbs? + auto fboffset_version = CreateVersion(*_builder); + auto fboffset_tosa_graph = CreateTosaGraphDirect(*_builder, fboffset_version, nullptr); + _builder->Finish(fboffset_tosa_graph); + std::string jsongen; + uint8_t* buf = _builder->GetBufferPointer(); + auto fb_tosa_graph = GetTosaGraph(buf); + auto fb_tosa_version = fb_tosa_graph->version(); + + _version = new TosaVersion(fb_tosa_version->_major(), fb_tosa_version->_minor(), fb_tosa_version->_patch(), + fb_tosa_version->_experimental()); + + assert(_version); + return TOSA_OK; +} + +tosa_err_t TosaSerializationHandler::LoadFileSchema(const char* schema_filename) +{ + std::string schema; + bool ok; + + ok = flatbuffers::LoadFile(schema_filename, false, &schema); + if (!ok) + { + printf("Error loading schema file: %s\n", schema_filename); + return TOSA_FILE_ERROR; + } + + ok = _parser->Parse(schema.c_str()); + if (!ok) + { + printf("Error parsing ISA schema file: %s\n", schema_filename); + return TOSA_FILE_ERROR; + } + _schemaLoaded = true; + + return TOSA_OK; +} + +tosa_err_t TosaSerializationHandler::LoadFileJson(const char* filename) +{ + std::string jsonfile; + bool ok; + tosa_err_t err; + + if (!_schemaLoaded) + { + return TOSA_SCHEMA_MISSING; + } + + ok = flatbuffers::LoadFile(filename, false, &jsonfile); + if (!ok) + { + printf("Error loading json file: %s\n", filename); + return TOSA_FILE_ERROR; + } + + ok = _parser->Parse(jsonfile.c_str()); + if (!ok) + { + printf("Error parsing json file: %s\n", filename); + return TOSA_FILE_ERROR; + } + + uint8_t* buf = _parser->builder_.GetBufferPointer(); + + err = InitWithBuf(buf); + if (err != TOSA_OK) + { + return err; + } + + return TOSA_OK; +} + +tosa_err_t TosaSerializationHandler::SaveFileJson(const char* filename) +{ + std::string jsongen; + tosa_err_t err; + + if (!_schemaLoaded) + { + return TOSA_SCHEMA_MISSING; + } + + err = FreezeBuilder(); + if (err != TOSA_OK) + { + return err; + } + + uint8_t* buf = _builder->GetBufferPointer(); + + if (!GenerateText(*_parser, buf, &jsongen)) + { + printf("Couldn't serialize parsed data to JSON!\n"); + return TOSA_FILE_ERROR; + } + + FILE* file = fopen(filename, "wb"); + + if (!file) + { + printf("Couldn't open output file: %s\n", filename); + return TOSA_FILE_ERROR; + } + + if (fwrite(jsongen.c_str(), sizeof(char), jsongen.size(), file) != jsongen.size()) + { + printf("Error writing to json output file: %s\n", filename); + fclose(file); + return TOSA_FILE_ERROR; + } + + if (file) + fclose(file); + + return TOSA_OK; +} + +tosa_err_t TosaSerializationHandler::LoadFileTosaFlatbuffer(const char* filename) +{ + std::string read_buffer; + tosa_err_t err; + uint8_t* buf; + bool ok; + + ok = flatbuffers::LoadFile(filename, false, &read_buffer); + if (!ok) + { + printf("Error loading flatbuffer file: %s\n", filename); + return TOSA_FILE_ERROR; + } + + buf = (uint8_t*)read_buffer.data(); + + err = InitWithBuf(buf); + if (err != TOSA_OK) + { + return err; + } + + return TOSA_OK; +} + +tosa_err_t TosaSerializationHandler::SaveFileTosaFlatbuffer(const char* filename) +{ + tosa_err_t err; + + err = FreezeBuilder(); + if (err != TOSA_OK) + { + return err; + } + + uint8_t* buf = _builder->GetBufferPointer(); + + bool ok = flatbuffers::SaveFile(filename, (const char*)buf, _builder->GetSize(), false); + if (!ok) + { + printf("Error saving floatbuffer file: %s\n", filename); + return TOSA_FILE_ERROR; + } + + return TOSA_OK; +} + +tosa_err_t TosaSerializationHandler::Clear() +{ + // deallocate all basic blocks + for (auto bb : GetBlocks()) + { + delete bb; + } + _blocks->clear(); + + return TOSA_OK; +} + +tosa_err_t TosaSerializationHandler::CheckTosaVersion(const TosaVersion& read_version) +{ + if ((*_version) != read_version) + { + printf("WARNING: read tosa version: %s != schema tosa version %s\n", read_version.to_string().c_str(), + this->_version->to_string().c_str()); + return TOSA_VERSION_MISMATCH; + } + + return TOSA_OK; +} + +tosa_err_t TosaSerializationHandler::InitWithBuf(const uint8_t* buf) +{ + auto fb_tosa_graph = GetTosaGraph(buf); + auto fb_tosa_version = fb_tosa_graph->version(); + auto fb_tosa_blocks = fb_tosa_graph->blocks(); + + std::vector<std::string> operator_inputs_container; + std::vector<std::string> operator_outputs_container; + + std::vector<TosaSerializationOperator*> block_operators_container; + std::vector<TosaSerializationTensor*> block_tensors_container; + std::vector<std::string> block_inputs_container; + std::vector<std::string> block_outputs_container; + + TosaAttributeBase* typed_attribute = NULL; + TosaQuantInfoBase* typed_qinfo = NULL; + TosaSerializationOperator* new_operator = NULL; + TosaSerializationBasicBlock* new_block = NULL; + TosaSerializationTensor* new_tensor = NULL; + + // erase container + Clear(); + + TosaVersion read_version(fb_tosa_version->_major(), fb_tosa_version->_minor(), fb_tosa_version->_patch(), + fb_tosa_version->_experimental()); + tosa_err_t err = CheckTosaVersion(read_version); + + if (err != TOSA_OK) + return err; + + for (size_t i = 0; i < fb_tosa_blocks->size(); i++) + { + auto curr_block = fb_tosa_blocks->Get(i); + + auto block_name = curr_block->name()->str(); + + auto fb_tosa_operators = curr_block->operators(); + block_operators_container.clear(); + for (size_t j = 0; j < fb_tosa_operators->size(); j++) + { + auto curr_operator = fb_tosa_operators->Get(j); + + auto operator_op = curr_operator->op(); + auto attribute_type = curr_operator->attribute_type(); + auto attribute = curr_operator->attribute(); + auto operator_qinfo_type = curr_operator->quant_info_type(); + auto operator_qinfo = curr_operator->quant_info(); + + // input tensors + auto operator_inputs = curr_operator->inputs(); + operator_inputs_container.clear(); + if (operator_inputs) + { + for (size_t k = 0; k < operator_inputs->size(); k++) + { + auto curr_input = operator_inputs->Get(k); + operator_inputs_container.push_back(curr_input->str()); + } + } + + // output tensors + auto operator_outputs = curr_operator->outputs(); + operator_outputs_container.clear(); + if (operator_outputs) + { + for (size_t k = 0; k < operator_outputs->size(); k++) + { + auto curr_output = operator_outputs->Get(k); + operator_outputs_container.push_back(curr_output->str()); + } + } + + switch (attribute_type) + { + case Attribute_NONE: + typed_attribute = new TosaNoneAttribute(); + break; +#define DEF_ATTRIBUTE(NAME, ...) \ + case Attribute_##NAME##Attribute: \ + typed_attribute = new Tosa##NAME##Attribute(attribute); \ + break; +#include "attribute.def" +#undef DEF_ATTRIBUTE + default: + printf("TosaSerializationHandler::InitWithBuf(): Attribute %s not implemented yet\n", + EnumNamesAttribute()[attribute_type]); + return TOSA_INTERNAL_ERROR; + } + + switch (operator_qinfo_type) + { + case QuantInfo_NONE: + typed_qinfo = new TosaNoneQuantInfo(); + break; +#define DEF_QUANTIZATION_INFO(NAME, ...) \ + case QuantInfo_##NAME##QuantInfo: \ + typed_qinfo = new Tosa##NAME##QuantInfo(operator_qinfo); \ + break; + +#include "quant_info.def" +#undef DEF_QUANTIZATION_INFO + default: + printf("TosaSerializationHandler::InitWithBuf(): QuantInfo %s not implemented yet\n", + EnumNamesQuantInfo()[operator_qinfo_type]); + return TOSA_INTERNAL_ERROR; + } + + new_operator = + new TosaSerializationOperator(operator_op, attribute_type, typed_attribute, operator_qinfo_type, + typed_qinfo, operator_inputs_container, operator_outputs_container); + if (new_operator) + { + block_operators_container.push_back(new_operator); + } + else + { + return TOSA_MEMORY_ERROR; + } + + if (typed_attribute) + delete typed_attribute; + if (typed_qinfo) + delete typed_qinfo; + } + + auto fb_tosa_tensors = curr_block->tensors(); + block_tensors_container.clear(); + for (size_t j = 0; j < fb_tosa_tensors->size(); j++) + { + auto curr_tensor = fb_tosa_tensors->Get(j); + + auto tensor_name = curr_tensor->name(); + auto tensor_usage = curr_tensor->usage(); + auto tensor_shape = curr_tensor->shape(); + auto tensor_type = curr_tensor->type(); + auto tensor_format = curr_tensor->format(); + auto tensor_npy_filename = curr_tensor->npy_filename(); + + new_tensor = new TosaSerializationTensor(tensor_name, *tensor_usage, *tensor_shape, tensor_type, + *tensor_format, tensor_npy_filename); + if (new_tensor) + { + block_tensors_container.push_back(new_tensor); + } + else + { + return TOSA_MEMORY_ERROR; + } + } + + auto block_inputs = curr_block->inputs(); + auto block_outputs = curr_block->outputs(); + + block_inputs_container.clear(); + block_outputs_container.clear(); + + for (size_t j = 0; j < block_inputs->size(); j++) + { + auto curr_block_input = block_inputs->Get(j); + block_inputs_container.push_back(curr_block_input->str()); + } + for (size_t j = 0; j < block_outputs->size(); j++) + { + auto curr_block_output = block_outputs->Get(j); + block_outputs_container.push_back(curr_block_output->str()); + } + + new_block = new TosaSerializationBasicBlock(block_name, block_operators_container, block_tensors_container, + block_inputs_container, block_outputs_container); + if (new_block) + { + this->GetBlocks().push_back(new_block); + } + else + { + return TOSA_MEMORY_ERROR; + } + } + + return TOSA_OK; +} + +tosa_err_t TosaSerializationHandler::FreezeBuilder() +{ + std::vector<flatbuffers::Offset<TosaBasicBlock>> fboffset_blocks; + + std::vector<flatbuffers::Offset<TosaOperator>> fboffset_block_operators; + std::vector<flatbuffers::Offset<TosaTensor>> fboffset_block_tensors; + std::vector<flatbuffers::Offset<flatbuffers::String>> fboffset_block_inputs; + std::vector<flatbuffers::Offset<flatbuffers::String>> fboffset_block_outputs; + + std::vector<flatbuffers::Offset<flatbuffers::String>> fboffset_operator_inputs; + std::vector<flatbuffers::Offset<flatbuffers::String>> fboffset_operator_outputs; + + // translate TosaFlatbufferOperator to flatbuffers::Offset<TosaOperator> + for (auto block : GetBlocks()) + { + fboffset_block_operators.clear(); + fboffset_block_tensors.clear(); + fboffset_block_inputs.clear(); + fboffset_block_outputs.clear(); + + auto block_name = _builder->CreateString(block->GetName().c_str()); + + for (auto tensor_str : block->GetInputs()) + { + auto tensor_name = _builder->CreateString(tensor_str.c_str()); + fboffset_block_inputs.push_back(tensor_name); + } + + for (auto tensor_str : block->GetOutputs()) + { + auto tensor_name = _builder->CreateString(tensor_str.c_str()); + fboffset_block_outputs.push_back(tensor_name); + } + + auto fb_block_inputs = _builder->CreateVector(fboffset_block_inputs); + auto fb_block_outputs = _builder->CreateVector(fboffset_block_outputs); + + for (auto op : block->GetOperators()) + { + fboffset_operator_inputs.clear(); + fboffset_operator_outputs.clear(); + + auto operator_op = op->GetOp(); + auto attribute_type = op->GetAttributeType(); + + for (auto tensor_str : op->GetInputTensorNames()) + { + auto tensor_name = _builder->CreateString(tensor_str.c_str()); + fboffset_operator_inputs.push_back(tensor_name); + } + + for (auto tensor_str : op->GetOutputTensorNames()) + { + auto tensor_name = _builder->CreateString(tensor_str.c_str()); + fboffset_operator_outputs.push_back(tensor_name); + } + + auto fb_operator_inputs = _builder->CreateVector(fboffset_operator_inputs); + auto fb_operator_outputs = _builder->CreateVector(fboffset_operator_outputs); + + flatbuffers::Offset<void> fb_attribute; + switch (attribute_type) + { + case Attribute_NONE: + fb_attribute = 0; + break; + +#define DEF_ARGS_S_STR(NAME, V) , _builder->CreateString(reinterpret_cast<Tosa##NAME*>(op->GetAttribute())->V().c_str()) +#define DEF_ARGS_S_DEFAULT(NAME, V) , reinterpret_cast<Tosa##NAME*>(op->GetAttribute())->V() + +#define DEF_ARGS_S_int32_t(NAME, V) DEF_ARGS_S_DEFAULT(NAME, V) +#define DEF_ARGS_S_float(NAME, V) DEF_ARGS_S_DEFAULT(NAME, V) +#define DEF_ARGS_S_bool(NAME, V) DEF_ARGS_S_DEFAULT(NAME, V) +#define DEF_ARGS_S_ResizeMode(NAME, V) DEF_ARGS_S_DEFAULT(NAME, V) +#define DEF_ARGS_S_string(NAME, V) DEF_ARGS_S_STR(NAME, V) + +#define DEF_ARGS_S(NAME, T, V) DEF_ARGS_S_##T(NAME, V) +#define DEF_ARGS_V(NAME, T, V) , _builder->CreateVector<T>(reinterpret_cast<Tosa##NAME*>(op->GetAttribute())->V()) + +#define DEF_ARGS_1(NAME, T0, F0, V0) DEF_ARGS_##F0(NAME, T0, V0) +#define DEF_ARGS_2(NAME, T0, F0, V0, T1, F1, V1) DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) +#define DEF_ARGS_3(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) +#define DEF_ARGS_4(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) +#define DEF_ARGS_5(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) \ + DEF_ARGS_##F4(NAME, T4, V4) +#define DEF_ARGS_6(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) \ + DEF_ARGS_##F4(NAME, T4, V4) DEF_ARGS_##F5(NAME, T5, V5) +#define DEF_ARGS_7(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) \ + DEF_ARGS_##F4(NAME, T4, V4) DEF_ARGS_##F5(NAME, T5, V5) DEF_ARGS_##F6(NAME, T6, V6) +#define DEF_ATTRIBUTE(NAME, NUM_ARGS, ...) \ + case Attribute_##NAME##Attribute: \ + fb_attribute = Create##NAME##Attribute(*_builder DEF_ARGS_##NUM_ARGS(NAME##Attribute, __VA_ARGS__)).Union(); \ + break; + +#include "attribute.def" +#undef DEF_ATTRIBUTE +#undef DEF_ARGS_1 +#undef DEF_ARGS_2 +#undef DEF_ARGS_3 +#undef DEF_ARGS_4 +#undef DEF_ARGS_5 +#undef DEF_ARGS_6 +#undef DEF_ARGS_7 +#undef DEF_ARGS_S +#undef DEF_ARGS_V +#undef DEF_ARGS_S_int32_t +#undef DEF_ARGS_S_float +#undef DEF_ARGS_S_bool +#undef DEF_ARGS_S_ResizeMode +#undef DEF_ARGS_S_string +#undef DEF_ARGS_S_STR +#undef DEF_ARGS_S_DEFAULT + default: + printf("TosaSerializationHandler::FreezeBuilder(): Attribute %s not implemented yet\n", + EnumNamesAttribute()[attribute_type]); + return TOSA_INTERNAL_ERROR; + } + + auto qinfo_type = op->GetQInfoType(); + flatbuffers::Offset<void> fb_operator_qinfo; + switch (qinfo_type) + { + case QuantInfo_NONE: + fb_operator_qinfo = 0; + break; +#define DEF_ARGS_S(NAME, T, V) , reinterpret_cast<Tosa##NAME*>(op->GetQInfo())->V() +#define DEF_ARGS_V(NAME, T, V) , _builder->CreateVector<T>(reinterpret_cast<Tosa##NAME*>(op->GetQInfo())->V()) + +#define DEF_ARGS_1(NAME, T0, F0, V0) DEF_ARGS_##F0(NAME, T0, V0) +#define DEF_ARGS_2(NAME, T0, F0, V0, T1, F1, V1) DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) +#define DEF_ARGS_3(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) +#define DEF_ARGS_4(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) +#define DEF_ARGS_5(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) \ + DEF_ARGS_##F4(NAME, T4, V4) +#define DEF_ARGS_6(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) \ + DEF_ARGS_##F4(NAME, T4, V4) DEF_ARGS_##F5(NAME, T5, V5) +#define DEF_ARGS_7(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) \ + DEF_ARGS_##F4(NAME, T4, V4) DEF_ARGS_##F5(NAME, T5, V5) DEF_ARGS_##F6(NAME, T6, V6) +#define DEF_ARGS_8(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6, T7, F7, \ + V7) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) \ + DEF_ARGS_##F4(NAME, T4, V4) DEF_ARGS_##F5(NAME, T5, V5) DEF_ARGS_##F6(NAME, T6, V6) \ + DEF_ARGS_##F7(NAME, T7, V7) +#define DEF_ARGS_9(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6, T7, F7, \ + V7, T8, F8, V8) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) \ + DEF_ARGS_##F4(NAME, T4, V4) DEF_ARGS_##F5(NAME, T5, V5) DEF_ARGS_##F6(NAME, T6, V6) \ + DEF_ARGS_##F7(NAME, T7, V7) DEF_ARGS_##F8(NAME, T8, V8) +#define DEF_ARGS_10(NAME, T0, F0, V0, T1, F1, V1, T2, F2, V2, T3, F3, V3, T4, F4, V4, T5, F5, V5, T6, F6, V6, T7, F7, \ + V7, T8, F8, V8, T9, F9, V9) \ + DEF_ARGS_##F0(NAME, T0, V0) DEF_ARGS_##F1(NAME, T1, V1) DEF_ARGS_##F2(NAME, T2, V2) DEF_ARGS_##F3(NAME, T3, V3) \ + DEF_ARGS_##F4(NAME, T4, V4) DEF_ARGS_##F5(NAME, T5, V5) DEF_ARGS_##F6(NAME, T6, V6) \ + DEF_ARGS_##F7(NAME, T7, V7) DEF_ARGS_##F8(NAME, T8, V8) DEF_ARGS_##F9(NAME, T9, V9) +#define DEF_QUANTIZATION_INFO(NAME, NUM_ARGS, ...) \ + case QuantInfo_##NAME##QuantInfo: \ + fb_operator_qinfo = \ + Create##NAME##QuantInfo(*_builder DEF_ARGS_##NUM_ARGS(NAME##QuantInfo, __VA_ARGS__)).Union(); \ + break; + +#include "quant_info.def" +#undef DEF_QUANTIZATION_INFO +#undef DEF_ARGS_1 +#undef DEF_ARGS_2 +#undef DEF_ARGS_3 +#undef DEF_ARGS_4 +#undef DEF_ARGS_5 +#undef DEF_ARGS_6 +#undef DEF_ARGS_7 +#undef DEF_ARGS_8 +#undef DEF_ARGS_9 +#undef DEF_ARGS_10 +#undef DEF_ARGS_S +#undef DEF_ARGS_V + default: + printf("TosaSerializationHandler::FreezeBuilder(): Attribute %s not implemented yet\n", + EnumNamesAttribute()[attribute_type]); + return TOSA_INTERNAL_ERROR; + } + + auto fboffset_operator = + CreateTosaOperator(*_builder, operator_op, attribute_type, fb_attribute, fb_operator_inputs, + fb_operator_outputs, qinfo_type, fb_operator_qinfo); + fboffset_block_operators.push_back(fboffset_operator); + } + + auto fb_block_operators = _builder->CreateVector(fboffset_block_operators); + + for (auto tensor : block->GetTensors()) + { + + auto tensor_name = _builder->CreateString(tensor->GetName().c_str()); + auto tensor_usage = + _builder->CreateVector(std::vector<uint32_t>(tensor->GetUsage().begin(), tensor->GetUsage().end())); + auto tensor_shape = _builder->CreateVector(tensor->GetShape()); + auto tensor_dtype = tensor->GetDtype(); + auto tensor_format = + _builder->CreateVector(std::vector<uint32_t>(tensor->GetFormat().begin(), tensor->GetFormat().end())); + flatbuffers::Offset<flatbuffers::String> tensor_npy_filename = 0; + if (tensor->GetNpyFilePtr()) + tensor_npy_filename = _builder->CreateString(tensor->GetNpyFilePtr()->c_str()); + + auto fboffset_tensor = CreateTosaTensor(*_builder, tensor_name, tensor_shape, tensor_dtype, tensor_usage, + tensor_format, tensor_npy_filename); + fboffset_block_tensors.push_back(fboffset_tensor); + } + + auto fb_block_tensors = _builder->CreateVector(fboffset_block_tensors); + + auto fboffset_block = CreateTosaBasicBlock(*_builder, block_name, fb_block_operators, fb_block_tensors, + fb_block_inputs, fb_block_outputs); + fboffset_blocks.push_back(fboffset_block); + } + + auto fb_blocks = _builder->CreateVector(fboffset_blocks); + + auto fb_version = CreateVersion(*_builder, GetTosaVersion()->_major, GetTosaVersion()->_minor, + GetTosaVersion()->_patch, GetTosaVersion()->_experimental); + + auto fb_graph = CreateTosaGraph(*_builder, fb_version, fb_blocks); + _builder->Finish(fb_graph); + + return TOSA_OK; +} + +// Magic NUMPY header +static const char NUMPY_HEADER_STR[] = "\x93NUMPY\x1\x0\x76\x0{"; +static const int NUMPY_HEADER_SZ = 128; + +NumpyUtilities::NPError NumpyUtilities::readFromNpyFile(const char* filename, const uint32_t elems, bool* databuf) +{ + const char dtype_str[] = "'|b1'"; + FILE* infile = nullptr; + NPError rc = NO_ERROR; + + assert(filename); + assert(databuf); + + infile = fopen(filename, "rb"); + if (!infile) + { + rc = FILE_NOT_FOUND; + goto done; + } + + rc = checkNpyHeader(infile, elems, dtype_str); + if (rc != NO_ERROR) + { + goto done; + } + + // Read in the data from numpy byte array to native bool + // array format + for (uint32_t i = 0; i < elems; i++) + { + int val = fgetc(infile); + + if (val == EOF) + { + rc = FILE_IO_ERROR; + goto done; + } + + databuf[i] = val; + } + +done: + + if (infile) + fclose(infile); + + return rc; +} + +NumpyUtilities::NPError NumpyUtilities::readFromNpyFile(const char* filename, const uint32_t elems, int32_t* databuf) +{ + const char dtype_str[] = "'<i4'"; + FILE* infile = nullptr; + NPError rc = NO_ERROR; + + assert(filename); + assert(databuf); + + infile = fopen(filename, "rb"); + if (!infile) + { + rc = FILE_NOT_FOUND; + goto done; + } + + rc = checkNpyHeader(infile, elems, dtype_str); + if (rc != NO_ERROR) + { + goto done; + } + + // Now we are at the beginning of the data + // Parse based on the datatype and number of dimensions + if (fread(databuf, sizeof(int32_t), elems, infile) != elems) + { + rc = FILE_IO_ERROR; + goto done; + } + +done: + + if (infile) + fclose(infile); + + return rc; +} + +NumpyUtilities::NPError NumpyUtilities::readFromNpyFile(const char* filename, const uint32_t elems, int64_t* databuf) +{ + const char dtype_str[] = "'<i8'"; + FILE* infile = nullptr; + NPError rc = NO_ERROR; + + assert(filename); + assert(databuf); + + infile = fopen(filename, "rb"); + if (!infile) + { + rc = FILE_NOT_FOUND; + goto done; + } + + rc = checkNpyHeader(infile, elems, dtype_str); + if (rc != NO_ERROR) + { + goto done; + } + + // Now we are at the beginning of the data + // Parse based on the datatype and number of dimensions + if (fread(databuf, sizeof(int64_t), elems, infile) != elems) + { + rc = FILE_IO_ERROR; + goto done; + } + +done: + + if (infile) + fclose(infile); + + return rc; +} + +NumpyUtilities::NPError NumpyUtilities::readFromNpyFile(const char* filename, const uint32_t elems, float* databuf) +{ + const char dtype_str[] = "'<f4'"; + FILE* infile = nullptr; + NPError rc = NO_ERROR; + + assert(filename); + assert(databuf); + + infile = fopen(filename, "rb"); + if (!infile) + { + rc = FILE_NOT_FOUND; + goto done; + } + + rc = checkNpyHeader(infile, elems, dtype_str); + if (rc != NO_ERROR) + { + goto done; + } + + // Now we are at the beginning of the data + // Parse based on the datatype and number of dimensions + if (fread(databuf, sizeof(float), elems, infile) != elems) + { + rc = FILE_IO_ERROR; + goto done; + } + +done: + + if (infile) + fclose(infile); + + return rc; +} + +NumpyUtilities::NPError NumpyUtilities::checkNpyHeader(FILE* infile, const uint32_t elems, const char* dtype_str) +{ + char buf[NUMPY_HEADER_SZ + 1]; + char* ptr = nullptr; + NPError rc = NO_ERROR; + bool foundFormat = false; + bool foundOrder = false; + bool foundShape = false; + bool fortranOrder = false; + std::vector<int> shape; + uint32_t totalElems = 1; + char* outer_end = NULL; + + assert(infile); + assert(elems > 0); + + if (fread(buf, NUMPY_HEADER_SZ, 1, infile) != 1) + { + rc = HEADER_PARSE_ERROR; + goto done; + } + + if (memcmp(buf, NUMPY_HEADER_STR, sizeof(NUMPY_HEADER_STR) - 1)) + { + rc = HEADER_PARSE_ERROR; + goto done; + } + + ptr = strtok_r(buf + sizeof(NUMPY_HEADER_STR) - 1, ":", &outer_end); + + // Read in the data type, order, and shape + while (ptr && (!foundFormat || !foundOrder || !foundShape)) + { + + // End of string? + if (!ptr) + break; + + // Skip whitespace + while (isspace(*ptr)) + ptr++; + + // Parse the dictionary field name + if (!strcmp(ptr, "'descr'")) + { + ptr = strtok_r(NULL, ",", &outer_end); + if (!ptr) + break; + + while (isspace(*ptr)) + ptr++; + + if (strcmp(ptr, dtype_str)) + { + rc = FILE_TYPE_MISMATCH; + goto done; + } + + foundFormat = true; + } + else if (!strcmp(ptr, "'fortran_order'")) + { + ptr = strtok_r(NULL, ",", &outer_end); + if (!ptr) + break; + + while (isspace(*ptr)) + ptr++; + + if (!strcmp(ptr, "False")) + { + fortranOrder = false; + } + else + { + rc = FILE_TYPE_MISMATCH; + goto done; + } + + foundOrder = true; + } + else if (!strcmp(ptr, "'shape'")) + { + + ptr = strtok_r(NULL, "(", &outer_end); + if (!ptr) + break; + ptr = strtok_r(NULL, ")", &outer_end); + if (!ptr) + break; + + while (isspace(*ptr)) + ptr++; + + // The shape contains N comma-separated integers. Read up to 4. + char* end = NULL; + + ptr = strtok_r(ptr, ",", &end); + for (int i = 0; i < 4; i++) + { + // Out of dimensions + if (!ptr) + break; + + shape.push_back(atoi(ptr)); + totalElems *= atoi(ptr); + ptr = strtok_r(NULL, ",", &end); + } + + foundShape = true; + } + else + { + rc = HEADER_PARSE_ERROR; + goto done; + } + + if (!ptr) + break; + + ptr = strtok_r(NULL, ":", &outer_end); + } + + if (!foundShape || !foundFormat || !foundOrder) + { + rc = HEADER_PARSE_ERROR; + goto done; + } + + // Validate header + if (fortranOrder != false) + { + rc = FILE_TYPE_MISMATCH; + goto done; + } + + if (totalElems != elems) + { + rc = BUFFER_SIZE_MISMATCH; + goto done; + } + + // Go back to the begininng and read until the end of the header dictionary + rewind(infile); + int val; + + do + { + val = fgetc(infile); + } while (val != EOF && val != '\n'); + +done: + + return rc; +} + +NumpyUtilities::NPError NumpyUtilities::writeToNpyFile(const char* filename, const uint32_t elems, const bool* databuf) +{ + std::vector<int32_t> shape = { (int32_t)elems }; + return writeToNpyFile(filename, shape, databuf); +} + +NumpyUtilities::NPError + NumpyUtilities::writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const bool* databuf) +{ + const char dtype_str[] = "'|b1'"; + FILE* outfile = nullptr; + NPError rc = NO_ERROR; + uint32_t totalElems = 1; + + assert(filename); + assert(shape.size() >= 0); + assert(databuf); + + outfile = fopen(filename, "wb"); + + if (!outfile) + { + rc = FILE_NOT_FOUND; + goto done; + } + + for (uint32_t i = 0; i < shape.size(); i++) + { + totalElems *= shape[i]; + } + + rc = writeNpyHeader(outfile, shape, dtype_str); + + // Numpy save format stores booleans as a byte array + // with one byte per boolean. This somewhat inefficiently + // remaps from system bool[] to this format. + for (uint32_t i = 0; i < totalElems; i++) + { + int val = databuf[i] ? 1 : 0; + if (fputc(val, outfile) == EOF) + { + rc = FILE_IO_ERROR; + goto done; + } + } + +done: + + if (outfile) + fclose(outfile); + + return rc; +} + +NumpyUtilities::NPError + NumpyUtilities::writeToNpyFile(const char* filename, const uint32_t elems, const int32_t* databuf) +{ + std::vector<int32_t> shape = { (int32_t)elems }; + return writeToNpyFile(filename, shape, databuf); +} + +NumpyUtilities::NPError + NumpyUtilities::writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const int32_t* databuf) +{ + const char dtype_str[] = "'<i4'"; + FILE* outfile = nullptr; + NPError rc = NO_ERROR; + uint32_t totalElems = 1; + + assert(filename); + assert(shape.size() >= 0); + assert(databuf); + + outfile = fopen(filename, "wb"); + + if (!outfile) + { + rc = FILE_NOT_FOUND; + goto done; + } + + for (uint32_t i = 0; i < shape.size(); i++) + { + totalElems *= shape[i]; + } + + rc = writeNpyHeader(outfile, shape, dtype_str); + + if (fwrite(databuf, sizeof(int32_t), totalElems, outfile) != totalElems) + { + rc = FILE_IO_ERROR; + goto done; + } + +done: + + if (outfile) + fclose(outfile); + + return rc; +} + +NumpyUtilities::NPError + NumpyUtilities::writeToNpyFile(const char* filename, const uint32_t elems, const int64_t* databuf) +{ + std::vector<int32_t> shape = { (int32_t)elems }; + return writeToNpyFile(filename, shape, databuf); +} + +NumpyUtilities::NPError + NumpyUtilities::writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const int64_t* databuf) +{ + const char dtype_str[] = "'<i8'"; + FILE* outfile = nullptr; + NPError rc = NO_ERROR; + uint32_t totalElems = 1; + + assert(filename); + assert(shape.size() >= 0); + assert(databuf); + + outfile = fopen(filename, "wb"); + + if (!outfile) + { + rc = FILE_NOT_FOUND; + goto done; + } + + for (uint32_t i = 0; i < shape.size(); i++) + { + totalElems *= shape[i]; + } + + rc = writeNpyHeader(outfile, shape, dtype_str); + + if (fwrite(databuf, sizeof(int64_t), totalElems, outfile) != totalElems) + { + rc = FILE_IO_ERROR; + goto done; + } + +done: + + if (outfile) + fclose(outfile); + + return rc; +} + +NumpyUtilities::NPError NumpyUtilities::writeToNpyFile(const char* filename, const uint32_t elems, const float* databuf) +{ + std::vector<int32_t> shape = { (int32_t)elems }; + return writeToNpyFile(filename, shape, databuf); +} + +NumpyUtilities::NPError + NumpyUtilities::writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const float* databuf) +{ + const char dtype_str[] = "'<f4'"; + FILE* outfile = nullptr; + NPError rc = NO_ERROR; + uint32_t totalElems = 1; + + assert(filename); + assert(shape.size() >= 0); + assert(databuf); + + outfile = fopen(filename, "wb"); + + if (!outfile) + { + rc = FILE_NOT_FOUND; + goto done; + } + + for (uint32_t i = 0; i < shape.size(); i++) + { + totalElems *= shape[i]; + } + + rc = writeNpyHeader(outfile, shape, dtype_str); + + if (fwrite(databuf, sizeof(float), totalElems, outfile) != totalElems) + { + rc = FILE_IO_ERROR; + goto done; + } + +done: + + if (outfile) + fclose(outfile); + + return rc; +} + +NumpyUtilities::NPError + NumpyUtilities::writeNpyHeader(FILE* outfile, const std::vector<int32_t>& shape, const char* dtype_str) +{ + NPError rc = NO_ERROR; + uint32_t i; + char header[NUMPY_HEADER_SZ + 1]; + int headerPos = 0; + + assert(outfile); + assert(shape.size() >= 0); + + // Space-fill the header and end with a newline to start per numpy spec + memset(header, 0x20, NUMPY_HEADER_SZ); + header[NUMPY_HEADER_SZ - 1] = '\n'; + header[NUMPY_HEADER_SZ] = 0; + + // Write out the hard-coded header. We only support a 128-byte 1.0 header + // for now, which should be sufficient for simple tensor types of any + // reasonable rank. + memcpy(header, NUMPY_HEADER_STR, sizeof(NUMPY_HEADER_STR) - 1); + headerPos += sizeof(NUMPY_HEADER_STR) - 1; + + // Output the format dictionary + // Hard-coded for I32 for now + headerPos += + snprintf(header + headerPos, NUMPY_HEADER_SZ - headerPos, "'descr': %s, 'fortran_order': False, 'shape': (%d,", + dtype_str, shape.size() > 0 ? shape[0] : 1); + + // Remainder of shape array + for (i = 1; i < shape.size(); i++) + { + headerPos += snprintf(header + headerPos, NUMPY_HEADER_SZ - headerPos, " %d,", shape[i]); + } + + // Close off the dictionary + headerPos += snprintf(header + headerPos, NUMPY_HEADER_SZ - headerPos, "), }"); + + // snprintf leaves a NULL at the end. Replace with a space + header[headerPos] = 0x20; + + if (fwrite(header, NUMPY_HEADER_SZ, 1, outfile) != 1) + { + rc = FILE_IO_ERROR; + goto done; + } + +done: + + return rc; +} diff --git a/serialization/tosa_serialization_handler.h b/serialization/tosa_serialization_handler.h new file mode 100644 index 0000000..124b8e0 --- /dev/null +++ b/serialization/tosa_serialization_handler.h @@ -0,0 +1,423 @@ + +// Copyright (c) 2020, ARM Limited. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +#ifndef _TOSA_SERIALIZATION_HANDLER_H +#define _TOSA_SERIALIZATION_HANDLER_H +#include "attribute.h" +#include "flatbuffers/idl.h" +#include "flatbuffers/util.h" +#include "quant_info.h" +#include "tosa_generated.h" +#include <cstdint> +#include <memory> +#include <string> +#include <vector> + +namespace tosa +{ + +enum tosa_err_t +{ + TOSA_OK, + TOSA_USER_ERROR, + TOSA_FILE_ERROR, + TOSA_MEMORY_ERROR, + TOSA_SCHEMA_MISSING, + TOSA_INTERNAL_ERROR, + TOSA_VERSION_MISMATCH, + NUM_TOSA_ERROR +}; + +struct TosaVersion +{ + int32_t _major; + int32_t _minor; + int32_t _patch; + bool _experimental; + + TosaVersion() = delete; + TosaVersion(int32_t major, int32_t minor, int32_t patch, bool experimental) + { + _major = major; + _minor = minor; + _patch = patch; + _experimental = experimental; + } + + std::string to_string() const + { + std::string str; + str += std::to_string(_major) + "."; + str += std::to_string(_minor) + "."; + str += std::to_string(_patch); + if (_experimental) + str += "(experimental)"; + return str; + }; + + bool operator==(const TosaVersion& rhs) + { + if (rhs._major == _major && rhs._minor == _minor && rhs._patch == _patch && rhs._experimental == _experimental) + { + return true; + } + return false; + } + + bool operator!=(const TosaVersion& rhs) + { + return !((*this) == rhs); + } +}; + +class TosaSerializationHandler; + +class TosaSerializationTensor +{ +public: + // constructor and destructor + TosaSerializationTensor(const flatbuffers::String* name, + const flatbuffers::Vector<uint32_t>& usage, + const flatbuffers::Vector<int32_t>& shape, + DType dtype, + const flatbuffers::Vector<uint32_t>& format, + const flatbuffers::String* npy_filename); + TosaSerializationTensor(std::string name, + const std::vector<Usage>& usage, + const std::vector<int32_t>& shape, + DType dtype, + const std::vector<Format>& format, + const std::string* npy_filename); + TosaSerializationTensor(); + ~TosaSerializationTensor(); + + // copy constructor/assignment + TosaSerializationTensor(const TosaSerializationTensor& rhs); + TosaSerializationTensor& operator=(const TosaSerializationTensor& rhs); + + // move constructor/assignment + TosaSerializationTensor(TosaSerializationTensor&& rhs); + TosaSerializationTensor& operator=(TosaSerializationTensor&& rhs); + + // accessor + std::string GetName() const + { + return *_name; + } + const std::vector<int32_t>& GetShape() const + { + return *_shape; + } + DType GetDtype() + { + return _dtype; + } + bool HasFormat(Format format) + { + for (Format us : *_format) + { + if (us == format) + return true; + } + return false; + } + std::vector<Format>& GetFormat() + { + return *_format; + } + bool HasUsage(Usage usage) + { + for (Usage us : *_usage) + { + if (us == usage) + return true; + } + return false; + } + std::vector<Usage>& GetUsage() + { + return *_usage; + } + std::string* GetNpyFilePtr() const + { + return _npy_filename; + } + + // modifier + void SetDtype(DType dtype) + { + _dtype = dtype; + } + void SetName(std::string name) + { + *_name = name; + } + +private: + DType _dtype; /* data type enumeration, see tosa_isa_generated.h */ + std::vector<Format>* _format; /* list of possible tensor format */ + std::vector<Usage>* _usage; /* list of possible tensor usage */ + std::vector<int32_t>* _shape; /* shape of the tensor */ + std::string* _name; /* name of the tensor, used for solving dependency */ + std::string* _npy_filename; /* numpy array filename if not null. so null is the distinguisher */ +}; + +class TosaSerializationOperator +{ +public: + // use default copy, void constructor + // constructor and destructor + TosaSerializationOperator(Op op_name, + Attribute attribute_type, + const TosaAttributeBase* attribute, + QuantInfo qinfo_type, + const TosaQuantInfoBase* qinfo, + std::vector<std::string> input_tensor_names, + std::vector<std::string> output_tensor_names); + ~TosaSerializationOperator(); + + // accessor + Op GetOp() const + { + return _op; + } + Attribute GetAttributeType() const + { + return _attribute_type; + } + TosaAttributeBase* GetAttribute() const + { + return _attribute; + } + QuantInfo GetQInfoType() const + { + return _qinfo_type; + } + TosaQuantInfoBase* GetQInfo() const + { + return _qinfo; + } + std::vector<std::string>& GetInputTensorNames() const + { + return *_input_tensor_names; + } + std::vector<std::string>& GetOutputTensorNames() const + { + return *_output_tensor_names; + } + std::vector<TosaSerializationTensor*>& GetInputTensors() const + { + return *_input_tensors; + } + std::vector<TosaSerializationTensor*>& GetOutputTensors() const + { + return *_output_tensors; + } + +private: + Op _op; /* operator enum, see tosa_isa_generated.h for enumeration table */ + Attribute _attribute_type; /* operator attribute enum, used for dynamic casting TosaAttributeBase class */ + TosaAttributeBase* _attribute; /* real attribute class goes here */ + QuantInfo _qinfo_type; /* QuantInfo enum */ + TosaQuantInfoBase* _qinfo; /* base class pointer of QuantInfo */ + std::vector<std::string>* _input_tensor_names; /* array of input tensor names */ + std::vector<std::string>* _output_tensor_names; /* array of output tensor names */ + + std::vector<TosaSerializationTensor*>* _input_tensors; /* array of input TosaSerializationTensor */ + std::vector<TosaSerializationTensor*>* _output_tensors; /* array of output TosaSerializationTensor */ +}; + +class TosaSerializationBasicBlock +{ +public: + // constructor and destructor + TosaSerializationBasicBlock(std::string name, + std::vector<TosaSerializationOperator*> operators, + std::vector<TosaSerializationTensor*> tensors, + std::vector<std::string> inputs, + std::vector<std::string> outputs); + ~TosaSerializationBasicBlock(); + + // accessor + std::string GetName() const + { + return *_name; + } + std::vector<TosaSerializationOperator*>& GetOperators() + { + return *_operators; + } + std::vector<TosaSerializationTensor*>& GetTensors() + { + return *_tensors; + } + + TosaSerializationTensor* GetTensorByName(std::string name) + { + TosaSerializationTensor* result = nullptr; + for (auto tensor : GetTensors()) + { + if (tensor->GetName() == name) + { + result = tensor; + break; + } + } + return result; + } + + std::vector<std::string>& GetInputs() + { + return *_inputs; + } + std::vector<std::string>& GetOutputs() + { + return *_outputs; + } + +private: + std::string* _name; /* name of basic block */ + std::vector<TosaSerializationOperator*>* _operators; /* TosaSerializationOperator list */ + std::vector<TosaSerializationTensor*>* _tensors; /* TosaSerializationTensor list */ + std::vector<std::string>* _inputs; /* array of string to specify block inputs */ + std::vector<std::string>* _outputs; /* array of string to specify block outputs */ +}; + +/* + * this is a helper class for writing/reading Tosa ISA + * supported format: .tosa (flatbuffer), .json + * and provide high-level std::vector-like interface + * to access internal data structure + */ +class TosaSerializationHandler +{ +public: + // constructor and destructor + TosaSerializationHandler(); + ~TosaSerializationHandler(); + + // file io + tosa_err_t LoadFileJson(const char* filename); + tosa_err_t LoadFileTosaFlatbuffer(const char* filename); + tosa_err_t SaveFileJson(const char* filename); + tosa_err_t SaveFileTosaFlatbuffer(const char* filename); + tosa_err_t LoadFileSchema(const char* filename); + + // version + TosaVersion* GetTosaVersion() const + { + return _version; + } + + // accessor + std::vector<TosaSerializationBasicBlock*>& GetBlocks() + { + return *_blocks; + } + + TosaSerializationBasicBlock* GetBlockByName(std::string name) + { + TosaSerializationBasicBlock* result = nullptr; + for (auto block : GetBlocks()) + { + if (block->GetName() == name) + { + result = block; + break; + } + } + return result; + } + TosaSerializationBasicBlock* GetMainBlock() + { + TosaSerializationBasicBlock* main_block = GetBlockByName(std::string("main")); + assert(main_block); + return main_block; + } + + std::vector<std::string>& GetInputs() + { + return GetMainBlock()->GetInputs(); + } + std::vector<std::string>& GetOutputs() + { + return GetMainBlock()->GetOutputs(); + } + + bool GetSchemaLoaded() const + { + return _schemaLoaded; + } + +protected: + tosa_err_t Clear(); + tosa_err_t InitWithBuf(const uint8_t* buf); + tosa_err_t FreezeBuilder(); + tosa_err_t SetTosaVersion(); + tosa_err_t CheckTosaVersion(const TosaVersion& read_version); + +private: + TosaVersion* _version; /* tosa version */ + flatbuffers::FlatBufferBuilder* _builder; /* flatbuffer builder */ + flatbuffers::Parser* _parser; /* flatbuffer parser, used for json parsing */ + std::vector<TosaSerializationBasicBlock*>* _blocks; /* array structure to store all TosaSerializationBasicBlock */ + bool _schemaLoaded; /* is the schema properly loaded? */ +}; + +class NumpyUtilities +{ +public: + enum NPError + { + NO_ERROR = 0, + FILE_NOT_FOUND, + FILE_IO_ERROR, + FILE_TYPE_MISMATCH, + HEADER_PARSE_ERROR, + BUFFER_SIZE_MISMATCH, + }; + + static NPError readFromNpyFile(const char* filename, const uint32_t elems, float* buf); + + static NPError readFromNpyFile(const char* filename, const uint32_t elems, int32_t* buf); + + static NPError readFromNpyFile(const char* filename, const uint32_t elems, int64_t* buf); + + static NPError readFromNpyFile(const char* filename, const uint32_t elems, bool* buf); + + static NPError writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const bool* buf); + + static NPError writeToNpyFile(const char* filename, const uint32_t elems, const bool* buf); + + static NPError writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const int32_t* buf); + + static NPError writeToNpyFile(const char* filename, const uint32_t elems, const int32_t* buf); + + static NPError writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const int64_t* buf); + + static NPError writeToNpyFile(const char* filename, const uint32_t elems, const int64_t* buf); + + static NPError writeToNpyFile(const char* filename, const std::vector<int32_t>& shape, const float* buf); + + static NPError writeToNpyFile(const char* filename, const uint32_t elems, const float* buf); + +private: + static NPError checkNpyHeader(FILE* infile, const uint32_t elems, const char* dtype_str); + static NPError writeNpyHeader(FILE* infile, const std::vector<int32_t>& shape, const char* dtype_str); +}; + +} // namespace tosa + +#endif // _TOSA_SERIALIZATION_HANDLER_H diff --git a/thirdparty/CMakeLists.txt b/thirdparty/CMakeLists.txt new file mode 100644 index 0000000..8c7bee3 --- /dev/null +++ b/thirdparty/CMakeLists.txt @@ -0,0 +1,10 @@ +cmake_minimum_required (VERSION 3.4) + +set(CMAKE_INSTALL_PREFIX "./thirdparty" CACHE PATH "..." FORCE) + +project(thirdparty LANGUAGES CXX) + +# Flatbuffers tests are not needed +set(FLATBUFFERS_BUILD_TESTS OFF) + +add_subdirectory(flatbuffers) diff --git a/thirdparty/eigen b/thirdparty/eigen new file mode 160000 +Subproject 21ae2afd4edaa1b69782c67a54182d34efe43f9 diff --git a/thirdparty/flatbuffers b/thirdparty/flatbuffers new file mode 160000 +Subproject bf9eb67ab9371755c6bcece13cadc7693bcbf26 diff --git a/verif/tosa/Attribute.py b/verif/tosa/Attribute.py new file mode 100644 index 0000000..a4d96e0 --- /dev/null +++ b/verif/tosa/Attribute.py @@ -0,0 +1,36 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +class Attribute(object): + NONE = 0 + Pool2dAttribute = 1 + Conv2dAttribute = 2 + TransposeConv2dAttribute = 3 + ReluNAttribute = 4 + AxisAttribute = 5 + ReshapeAttribute = 6 + SliceAttribute = 7 + TileAttribute = 8 + ResizeAttribute = 9 + ClampAttribute = 10 + RescaleAttribute = 11 + CustomAttribute = 12 + CondIfAttribute = 13 + WhileLoopAttribute = 14 + diff --git a/verif/tosa/AxisAttribute.py b/verif/tosa/AxisAttribute.py new file mode 100644 index 0000000..d47eb81 --- /dev/null +++ b/verif/tosa/AxisAttribute.py @@ -0,0 +1,45 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class AxisAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsAxisAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = AxisAttribute() + x.Init(buf, n + offset) + return x + + # AxisAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # AxisAttribute + def Axis(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def AxisAttributeStart(builder): builder.StartObject(1) +def AxisAttributeAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0) +def AxisAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/ClampAttribute.py b/verif/tosa/ClampAttribute.py new file mode 100644 index 0000000..ddc95cf --- /dev/null +++ b/verif/tosa/ClampAttribute.py @@ -0,0 +1,69 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class ClampAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsClampAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ClampAttribute() + x.Init(buf, n + offset) + return x + + # ClampAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ClampAttribute + def MinInt(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # ClampAttribute + def MaxInt(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # ClampAttribute + def MinFp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + + # ClampAttribute + def MaxFp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + +def ClampAttributeStart(builder): builder.StartObject(4) +def ClampAttributeAddMinInt(builder, minInt): builder.PrependInt32Slot(0, minInt, 0) +def ClampAttributeAddMaxInt(builder, maxInt): builder.PrependInt32Slot(1, maxInt, 0) +def ClampAttributeAddMinFp(builder, minFp): builder.PrependFloat32Slot(2, minFp, 0.0) +def ClampAttributeAddMaxFp(builder, maxFp): builder.PrependFloat32Slot(3, maxFp, 0.0) +def ClampAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/CondIfAttribute.py b/verif/tosa/CondIfAttribute.py new file mode 100644 index 0000000..0bf4566 --- /dev/null +++ b/verif/tosa/CondIfAttribute.py @@ -0,0 +1,53 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class CondIfAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsCondIfAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CondIfAttribute() + x.Init(buf, n + offset) + return x + + # CondIfAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CondIfAttribute + def ThenBranch(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # CondIfAttribute + def ElseBranch(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def CondIfAttributeStart(builder): builder.StartObject(2) +def CondIfAttributeAddThenBranch(builder, thenBranch): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(thenBranch), 0) +def CondIfAttributeAddElseBranch(builder, elseBranch): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(elseBranch), 0) +def CondIfAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/Conv2dAttribute.py b/verif/tosa/Conv2dAttribute.py new file mode 100644 index 0000000..c7861a5 --- /dev/null +++ b/verif/tosa/Conv2dAttribute.py @@ -0,0 +1,109 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class Conv2dAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsConv2dAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Conv2dAttribute() + x.Init(buf, n + offset) + return x + + # Conv2dAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Conv2dAttribute + def Padding(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Conv2dAttribute + def PaddingAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Conv2dAttribute + def PaddingLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Conv2dAttribute + def Stride(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Conv2dAttribute + def StrideAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Conv2dAttribute + def StrideLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Conv2dAttribute + def Dilation(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Conv2dAttribute + def DilationAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Conv2dAttribute + def DilationLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + +def Conv2dAttributeStart(builder): builder.StartObject(3) +def Conv2dAttributeAddPadding(builder, padding): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) +def Conv2dAttributeStartPaddingVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def Conv2dAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) +def Conv2dAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def Conv2dAttributeAddDilation(builder, dilation): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dilation), 0) +def Conv2dAttributeStartDilationVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def Conv2dAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/ConvQuantInfo.py b/verif/tosa/ConvQuantInfo.py new file mode 100644 index 0000000..a88bfa6 --- /dev/null +++ b/verif/tosa/ConvQuantInfo.py @@ -0,0 +1,53 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class ConvQuantInfo(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsConvQuantInfo(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ConvQuantInfo() + x.Init(buf, n + offset) + return x + + # ConvQuantInfo + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ConvQuantInfo + def InputZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # ConvQuantInfo + def WeightZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def ConvQuantInfoStart(builder): builder.StartObject(2) +def ConvQuantInfoAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) +def ConvQuantInfoAddWeightZp(builder, weightZp): builder.PrependInt32Slot(1, weightZp, 0) +def ConvQuantInfoEnd(builder): return builder.EndObject() diff --git a/verif/tosa/CustomAttribute.py b/verif/tosa/CustomAttribute.py new file mode 100644 index 0000000..25f6759 --- /dev/null +++ b/verif/tosa/CustomAttribute.py @@ -0,0 +1,45 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class CustomAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsCustomAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = CustomAttribute() + x.Init(buf, n + offset) + return x + + # CustomAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # CustomAttribute + def Identifier(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def CustomAttributeStart(builder): builder.StartObject(1) +def CustomAttributeAddIdentifier(builder, identifier): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(identifier), 0) +def CustomAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/DType.py b/verif/tosa/DType.py new file mode 100644 index 0000000..44d9970 --- /dev/null +++ b/verif/tosa/DType.py @@ -0,0 +1,31 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +class DType(object): + UNKNOWN = 0 + BOOL = 1 + AINT8 = 2 + UINT8 = 3 + INT4 = 4 + INT8 = 5 + INT16 = 6 + INT32 = 7 + INT48 = 8 + FLOAT = 9 + diff --git a/verif/tosa/Format.py b/verif/tosa/Format.py new file mode 100644 index 0000000..5db4f27 --- /dev/null +++ b/verif/tosa/Format.py @@ -0,0 +1,27 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +class Format(object): + UNKNOWN = 0 + NHWC = 1 + NDHWC = 2 + OHWI = 3 + HWIM = 4 + DOHWI = 5 + diff --git a/verif/tosa/MatMulQuantInfo.py b/verif/tosa/MatMulQuantInfo.py new file mode 100644 index 0000000..b8390a9 --- /dev/null +++ b/verif/tosa/MatMulQuantInfo.py @@ -0,0 +1,53 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class MatMulQuantInfo(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsMatMulQuantInfo(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = MatMulQuantInfo() + x.Init(buf, n + offset) + return x + + # MatMulQuantInfo + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # MatMulQuantInfo + def AZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # MatMulQuantInfo + def BZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def MatMulQuantInfoStart(builder): builder.StartObject(2) +def MatMulQuantInfoAddAZp(builder, aZp): builder.PrependInt32Slot(0, aZp, 0) +def MatMulQuantInfoAddBZp(builder, bZp): builder.PrependInt32Slot(1, bZp, 0) +def MatMulQuantInfoEnd(builder): return builder.EndObject() diff --git a/verif/tosa/Op.py b/verif/tosa/Op.py new file mode 100644 index 0000000..09f1364 --- /dev/null +++ b/verif/tosa/Op.py @@ -0,0 +1,90 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +class Op(object): + UNKNOWN = 0 + ARGMAX = 1 + AVG_POOL2D = 2 + CONV2D = 3 + CONV3D = 4 + DEPTHWISE_CONV2D = 5 + FULLY_CONNECTED = 6 + MATMUL = 7 + MAX_POOL2D = 8 + TRANSPOSE_CONV2D = 9 + CLAMP = 10 + RELUN = 11 + SIGMOID = 12 + TANH = 13 + ADD = 14 + ARITHMETIC_RIGHT_SHIFT = 15 + BITWISE_AND = 16 + BITWISE_OR = 17 + BITWISE_XOR = 18 + LOGICAL_AND = 19 + LOGICAL_LEFT_SHIFT = 20 + LOGICAL_RIGHT_SHIFT = 21 + LOGICAL_OR = 22 + LOGICAL_XOR = 23 + MAXIMUM = 24 + MINIMUM = 25 + MUL = 26 + POW = 27 + SUB = 28 + TABLE = 29 + ABS = 30 + BITWISE_NOT = 31 + CEIL = 32 + CLZ = 33 + EXP = 34 + FLOOR = 35 + LOG = 36 + LOGICAL_NOT = 37 + NEGATE = 38 + RECIPROCAL = 39 + RSQRT = 40 + SELECT = 41 + EQUAL = 42 + GREATER = 43 + GREATER_EQUAL = 44 + REDUCE_ANY = 45 + REDUCE_ALL = 46 + REDUCE_MAX = 47 + REDUCE_MIN = 48 + REDUCE_PRODUCT = 49 + REDUCE_SUM = 50 + CONCAT = 51 + PAD = 52 + RESHAPE = 53 + REVERSE = 54 + SLICE = 55 + TILE = 56 + TRANSPOSE = 57 + GATHER = 58 + RESIZE = 59 + CAST = 60 + RESCALE = 61 + CONST = 62 + PLACEHOLDER = 63 + IDENTITY = 64 + IDENTITYN = 65 + CUSTOM = 66 + COND_IF = 67 + WHILE_LOOP = 68 + diff --git a/verif/tosa/PadQuantInfo.py b/verif/tosa/PadQuantInfo.py new file mode 100644 index 0000000..df61926 --- /dev/null +++ b/verif/tosa/PadQuantInfo.py @@ -0,0 +1,45 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class PadQuantInfo(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsPadQuantInfo(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = PadQuantInfo() + x.Init(buf, n + offset) + return x + + # PadQuantInfo + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # PadQuantInfo + def InputZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def PadQuantInfoStart(builder): builder.StartObject(1) +def PadQuantInfoAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) +def PadQuantInfoEnd(builder): return builder.EndObject() diff --git a/verif/tosa/Pool2dAttribute.py b/verif/tosa/Pool2dAttribute.py new file mode 100644 index 0000000..1520de2 --- /dev/null +++ b/verif/tosa/Pool2dAttribute.py @@ -0,0 +1,109 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class Pool2dAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsPool2dAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Pool2dAttribute() + x.Init(buf, n + offset) + return x + + # Pool2dAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Pool2dAttribute + def Padding(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Pool2dAttribute + def PaddingAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Pool2dAttribute + def PaddingLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Pool2dAttribute + def Kernel(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Pool2dAttribute + def KernelAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Pool2dAttribute + def KernelLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # Pool2dAttribute + def Stride(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # Pool2dAttribute + def StrideAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # Pool2dAttribute + def StrideLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + +def Pool2dAttributeStart(builder): builder.StartObject(3) +def Pool2dAttributeAddPadding(builder, padding): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(padding), 0) +def Pool2dAttributeStartPaddingVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def Pool2dAttributeAddKernel(builder, kernel): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(kernel), 0) +def Pool2dAttributeStartKernelVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def Pool2dAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) +def Pool2dAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def Pool2dAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/QuantInfo.py b/verif/tosa/QuantInfo.py new file mode 100644 index 0000000..0544cce --- /dev/null +++ b/verif/tosa/QuantInfo.py @@ -0,0 +1,26 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +class QuantInfo(object): + NONE = 0 + UnaryQuantInfo = 1 + ConvQuantInfo = 2 + MatMulQuantInfo = 3 + PadQuantInfo = 4 + diff --git a/verif/tosa/README.md b/verif/tosa/README.md new file mode 100644 index 0000000..de8c1f9 --- /dev/null +++ b/verif/tosa/README.md @@ -0,0 +1,14 @@ +TOSA FlatBuffers python serialization library +============================================= + +Files in this directory are automatically generated by running: + +``` bash +../build/thirdparty/flatbuffers/flatc --python ../serialization/tosa.fbs +``` + +From the ``verif/`` directory. Flatc is compiled along with the *TOSA +Reference Model*. + +*Because they are automatically generated, please do not edit the +python files in this directory by hand.* diff --git a/verif/tosa/ReluNAttribute.py b/verif/tosa/ReluNAttribute.py new file mode 100644 index 0000000..e446c03 --- /dev/null +++ b/verif/tosa/ReluNAttribute.py @@ -0,0 +1,53 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class ReluNAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsReluNAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ReluNAttribute() + x.Init(buf, n + offset) + return x + + # ReluNAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ReluNAttribute + def MaxInt(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # ReluNAttribute + def MaxFp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos) + return 0.0 + +def ReluNAttributeStart(builder): builder.StartObject(2) +def ReluNAttributeAddMaxInt(builder, maxInt): builder.PrependInt32Slot(0, maxInt, 0) +def ReluNAttributeAddMaxFp(builder, maxFp): builder.PrependFloat32Slot(1, maxFp, 0.0) +def ReluNAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/RescaleAttribute.py b/verif/tosa/RescaleAttribute.py new file mode 100644 index 0000000..0ec8c2b --- /dev/null +++ b/verif/tosa/RescaleAttribute.py @@ -0,0 +1,125 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class RescaleAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsRescaleAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = RescaleAttribute() + x.Init(buf, n + offset) + return x + + # RescaleAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # RescaleAttribute + def InputZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # RescaleAttribute + def OutputZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # RescaleAttribute + def Multiplier(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # RescaleAttribute + def MultiplierAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # RescaleAttribute + def MultiplierLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # RescaleAttribute + def Shift(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # RescaleAttribute + def ShiftAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # RescaleAttribute + def ShiftLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # RescaleAttribute + def Scale32(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # RescaleAttribute + def DoubleRound(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + + # RescaleAttribute + def PerChannel(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def RescaleAttributeStart(builder): builder.StartObject(7) +def RescaleAttributeAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) +def RescaleAttributeAddOutputZp(builder, outputZp): builder.PrependInt32Slot(1, outputZp, 0) +def RescaleAttributeAddMultiplier(builder, multiplier): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(multiplier), 0) +def RescaleAttributeStartMultiplierVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def RescaleAttributeAddShift(builder, shift): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(shift), 0) +def RescaleAttributeStartShiftVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def RescaleAttributeAddScale32(builder, scale32): builder.PrependBoolSlot(4, scale32, 0) +def RescaleAttributeAddDoubleRound(builder, doubleRound): builder.PrependBoolSlot(5, doubleRound, 0) +def RescaleAttributeAddPerChannel(builder, perChannel): builder.PrependBoolSlot(6, perChannel, 0) +def RescaleAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/ReshapeAttribute.py b/verif/tosa/ReshapeAttribute.py new file mode 100644 index 0000000..2c50cef --- /dev/null +++ b/verif/tosa/ReshapeAttribute.py @@ -0,0 +1,61 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class ReshapeAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsReshapeAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ReshapeAttribute() + x.Init(buf, n + offset) + return x + + # ReshapeAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ReshapeAttribute + def Shape(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # ReshapeAttribute + def ShapeAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # ReshapeAttribute + def ShapeLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + +def ReshapeAttributeStart(builder): builder.StartObject(1) +def ReshapeAttributeAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) +def ReshapeAttributeStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def ReshapeAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/ResizeAttribute.py b/verif/tosa/ResizeAttribute.py new file mode 100644 index 0000000..1e6941f --- /dev/null +++ b/verif/tosa/ResizeAttribute.py @@ -0,0 +1,125 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class ResizeAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsResizeAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = ResizeAttribute() + x.Init(buf, n + offset) + return x + + # ResizeAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # ResizeAttribute + def OutputSize(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # ResizeAttribute + def OutputSizeAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # ResizeAttribute + def OutputSizeLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # ResizeAttribute + def Stride(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # ResizeAttribute + def StrideAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # ResizeAttribute + def StrideLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # ResizeAttribute + def Offset(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # ResizeAttribute + def OffsetAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # ResizeAttribute + def OffsetLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # ResizeAttribute + def Shift(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # ResizeAttribute + def Mode(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + +def ResizeAttributeStart(builder): builder.StartObject(5) +def ResizeAttributeAddOutputSize(builder, outputSize): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(outputSize), 0) +def ResizeAttributeStartOutputSizeVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def ResizeAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) +def ResizeAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def ResizeAttributeAddOffset(builder, offset): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(offset), 0) +def ResizeAttributeStartOffsetVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def ResizeAttributeAddShift(builder, shift): builder.PrependInt32Slot(3, shift, 0) +def ResizeAttributeAddMode(builder, mode): builder.PrependUint32Slot(4, mode, 0) +def ResizeAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/ResizeMode.py b/verif/tosa/ResizeMode.py new file mode 100644 index 0000000..02bed51 --- /dev/null +++ b/verif/tosa/ResizeMode.py @@ -0,0 +1,24 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +class ResizeMode(object): + UNKNOWN = 0 + NEAREST = 1 + BILINEAR = 2 + diff --git a/verif/tosa/SliceAttribute.py b/verif/tosa/SliceAttribute.py new file mode 100644 index 0000000..d156a4a --- /dev/null +++ b/verif/tosa/SliceAttribute.py @@ -0,0 +1,85 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class SliceAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsSliceAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = SliceAttribute() + x.Init(buf, n + offset) + return x + + # SliceAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # SliceAttribute + def Begin(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # SliceAttribute + def BeginAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # SliceAttribute + def BeginLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # SliceAttribute + def Size(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # SliceAttribute + def SizeAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # SliceAttribute + def SizeLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + +def SliceAttributeStart(builder): builder.StartObject(2) +def SliceAttributeAddBegin(builder, begin): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(begin), 0) +def SliceAttributeStartBeginVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SliceAttributeAddSize(builder, size): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(size), 0) +def SliceAttributeStartSizeVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def SliceAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/TileAttribute.py b/verif/tosa/TileAttribute.py new file mode 100644 index 0000000..6385edd --- /dev/null +++ b/verif/tosa/TileAttribute.py @@ -0,0 +1,61 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class TileAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTileAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TileAttribute() + x.Init(buf, n + offset) + return x + + # TileAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TileAttribute + def Multiples(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # TileAttribute + def MultiplesAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # TileAttribute + def MultiplesLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + +def TileAttributeStart(builder): builder.StartObject(1) +def TileAttributeAddMultiples(builder, multiples): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(multiples), 0) +def TileAttributeStartMultiplesVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TileAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/TosaBasicBlock.py b/verif/tosa/TosaBasicBlock.py new file mode 100644 index 0000000..42a7379 --- /dev/null +++ b/verif/tosa/TosaBasicBlock.py @@ -0,0 +1,123 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class TosaBasicBlock(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTosaBasicBlock(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TosaBasicBlock() + x.Init(buf, n + offset) + return x + + # TosaBasicBlock + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TosaBasicBlock + def Name(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # TosaBasicBlock + def Operators(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from .TosaOperator import TosaOperator + obj = TosaOperator() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # TosaBasicBlock + def OperatorsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaBasicBlock + def Tensors(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from .TosaTensor import TosaTensor + obj = TosaTensor() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # TosaBasicBlock + def TensorsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaBasicBlock + def Inputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return "" + + # TosaBasicBlock + def InputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaBasicBlock + def Outputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return "" + + # TosaBasicBlock + def OutputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + +def TosaBasicBlockStart(builder): builder.StartObject(5) +def TosaBasicBlockAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def TosaBasicBlockAddOperators(builder, operators): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0) +def TosaBasicBlockStartOperatorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaBasicBlockAddTensors(builder, tensors): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0) +def TosaBasicBlockStartTensorsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaBasicBlockAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) +def TosaBasicBlockStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaBasicBlockAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) +def TosaBasicBlockStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaBasicBlockEnd(builder): return builder.EndObject() diff --git a/verif/tosa/TosaGraph.py b/verif/tosa/TosaGraph.py new file mode 100644 index 0000000..92568b9 --- /dev/null +++ b/verif/tosa/TosaGraph.py @@ -0,0 +1,71 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class TosaGraph(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTosaGraph(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TosaGraph() + x.Init(buf, n + offset) + return x + + # TosaGraph + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TosaGraph + def Version(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + x = self._tab.Indirect(o + self._tab.Pos) + from .Version import Version + obj = Version() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # TosaGraph + def Blocks(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + x = self._tab.Vector(o) + x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4 + x = self._tab.Indirect(x) + from .TosaBasicBlock import TosaBasicBlock + obj = TosaBasicBlock() + obj.Init(self._tab.Bytes, x) + return obj + return None + + # TosaGraph + def BlocksLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + +def TosaGraphStart(builder): builder.StartObject(2) +def TosaGraphAddVersion(builder, version): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(version), 0) +def TosaGraphAddBlocks(builder, blocks): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(blocks), 0) +def TosaGraphStartBlocksVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaGraphEnd(builder): return builder.EndObject() diff --git a/verif/tosa/TosaOperator.py b/verif/tosa/TosaOperator.py new file mode 100644 index 0000000..ab4a160 --- /dev/null +++ b/verif/tosa/TosaOperator.py @@ -0,0 +1,117 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class TosaOperator(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTosaOperator(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TosaOperator() + x.Init(buf, n + offset) + return x + + # TosaOperator + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TosaOperator + def Op(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # TosaOperator + def AttributeType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # TosaOperator + def Attribute(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + + # TosaOperator + def Inputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return "" + + # TosaOperator + def InputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaOperator + def Outputs(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.String(a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return "" + + # TosaOperator + def OutputsLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaOperator + def QuantInfoType(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos) + return 0 + + # TosaOperator + def QuantInfo(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16)) + if o != 0: + from flatbuffers.table import Table + obj = Table(bytearray(), 0) + self._tab.Union(obj, o) + return obj + return None + +def TosaOperatorStart(builder): builder.StartObject(7) +def TosaOperatorAddOp(builder, op): builder.PrependUint32Slot(0, op, 0) +def TosaOperatorAddAttributeType(builder, attributeType): builder.PrependUint8Slot(1, attributeType, 0) +def TosaOperatorAddAttribute(builder, attribute): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(attribute), 0) +def TosaOperatorAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0) +def TosaOperatorStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaOperatorAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0) +def TosaOperatorStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaOperatorAddQuantInfoType(builder, quantInfoType): builder.PrependUint8Slot(5, quantInfoType, 0) +def TosaOperatorAddQuantInfo(builder, quantInfo): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(quantInfo), 0) +def TosaOperatorEnd(builder): return builder.EndObject() diff --git a/verif/tosa/TosaTensor.py b/verif/tosa/TosaTensor.py new file mode 100644 index 0000000..0b30266 --- /dev/null +++ b/verif/tosa/TosaTensor.py @@ -0,0 +1,133 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class TosaTensor(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTosaTensor(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TosaTensor() + x.Init(buf, n + offset) + return x + + # TosaTensor + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TosaTensor + def Name(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # TosaTensor + def Shape(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # TosaTensor + def ShapeAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # TosaTensor + def ShapeLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaTensor + def Type(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos) + return 0 + + # TosaTensor + def Usage(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # TosaTensor + def UsageAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o) + return 0 + + # TosaTensor + def UsageLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaTensor + def Format(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Uint32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # TosaTensor + def FormatAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint32Flags, o) + return 0 + + # TosaTensor + def FormatLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TosaTensor + def NpyFilename(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def TosaTensorStart(builder): builder.StartObject(6) +def TosaTensorAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0) +def TosaTensorAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0) +def TosaTensorStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaTensorAddType(builder, type): builder.PrependUint32Slot(2, type, 0) +def TosaTensorAddUsage(builder, usage): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(usage), 0) +def TosaTensorStartUsageVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaTensorAddFormat(builder, format): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(format), 0) +def TosaTensorStartFormatVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TosaTensorAddNpyFilename(builder, npyFilename): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(npyFilename), 0) +def TosaTensorEnd(builder): return builder.EndObject() diff --git a/verif/tosa/TransposeConv2dAttribute.py b/verif/tosa/TransposeConv2dAttribute.py new file mode 100644 index 0000000..043d8e8 --- /dev/null +++ b/verif/tosa/TransposeConv2dAttribute.py @@ -0,0 +1,133 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class TransposeConv2dAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsTransposeConv2dAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = TransposeConv2dAttribute() + x.Init(buf, n + offset) + return x + + # TransposeConv2dAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # TransposeConv2dAttribute + def Outpad(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # TransposeConv2dAttribute + def OutpadAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # TransposeConv2dAttribute + def OutpadLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TransposeConv2dAttribute + def Stride(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # TransposeConv2dAttribute + def StrideAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # TransposeConv2dAttribute + def StrideLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TransposeConv2dAttribute + def Dilation(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # TransposeConv2dAttribute + def DilationAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # TransposeConv2dAttribute + def DilationLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + + # TransposeConv2dAttribute + def OutputShape(self, j): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + a = self._tab.Vector(o) + return self._tab.Get(flatbuffers.number_types.Int32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4)) + return 0 + + # TransposeConv2dAttribute + def OutputShapeAsNumpy(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o) + return 0 + + # TransposeConv2dAttribute + def OutputShapeLength(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return self._tab.VectorLen(o) + return 0 + +def TransposeConv2dAttributeStart(builder): builder.StartObject(4) +def TransposeConv2dAttributeAddOutpad(builder, outpad): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(outpad), 0) +def TransposeConv2dAttributeStartOutpadVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TransposeConv2dAttributeAddStride(builder, stride): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(stride), 0) +def TransposeConv2dAttributeStartStrideVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TransposeConv2dAttributeAddDilation(builder, dilation): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dilation), 0) +def TransposeConv2dAttributeStartDilationVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TransposeConv2dAttributeAddOutputShape(builder, outputShape): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(outputShape), 0) +def TransposeConv2dAttributeStartOutputShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4) +def TransposeConv2dAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/UnaryQuantInfo.py b/verif/tosa/UnaryQuantInfo.py new file mode 100644 index 0000000..9ae0214 --- /dev/null +++ b/verif/tosa/UnaryQuantInfo.py @@ -0,0 +1,53 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class UnaryQuantInfo(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsUnaryQuantInfo(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = UnaryQuantInfo() + x.Init(buf, n + offset) + return x + + # UnaryQuantInfo + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # UnaryQuantInfo + def InputZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # UnaryQuantInfo + def OutputZp(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + +def UnaryQuantInfoStart(builder): builder.StartObject(2) +def UnaryQuantInfoAddInputZp(builder, inputZp): builder.PrependInt32Slot(0, inputZp, 0) +def UnaryQuantInfoAddOutputZp(builder, outputZp): builder.PrependInt32Slot(1, outputZp, 0) +def UnaryQuantInfoEnd(builder): return builder.EndObject() diff --git a/verif/tosa/Usage.py b/verif/tosa/Usage.py new file mode 100644 index 0000000..4c42daa --- /dev/null +++ b/verif/tosa/Usage.py @@ -0,0 +1,25 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +class Usage(object): + UNKNOWN = 0 + ACTIVATION = 1 + WEIGHT = 2 + INDEX = 3 + diff --git a/verif/tosa/Version.py b/verif/tosa/Version.py new file mode 100644 index 0000000..ddfdb2d --- /dev/null +++ b/verif/tosa/Version.py @@ -0,0 +1,69 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class Version(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsVersion(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = Version() + x.Init(buf, n + offset) + return x + + # Version + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # Version + def _major(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # Version + def _minor(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 20 + + # Version + def _patch(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8)) + if o != 0: + return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos) + return 0 + + # Version + def _experimental(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10)) + if o != 0: + return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos)) + return False + +def VersionStart(builder): builder.StartObject(4) +def VersionAdd_major(builder, Major): builder.PrependInt32Slot(0, Major, 0) +def VersionAdd_minor(builder, Minor): builder.PrependInt32Slot(1, Minor, 20) +def VersionAdd_patch(builder, Patch): builder.PrependInt32Slot(2, Patch, 0) +def VersionAdd_experimental(builder, Experimental): builder.PrependBoolSlot(3, Experimental, 0) +def VersionEnd(builder): return builder.EndObject() diff --git a/verif/tosa/WhileLoopAttribute.py b/verif/tosa/WhileLoopAttribute.py new file mode 100644 index 0000000..c37977f --- /dev/null +++ b/verif/tosa/WhileLoopAttribute.py @@ -0,0 +1,53 @@ +# automatically generated by the FlatBuffers compiler, do not modify + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +# namespace: tosa + +import flatbuffers + +class WhileLoopAttribute(object): + __slots__ = ['_tab'] + + @classmethod + def GetRootAsWhileLoopAttribute(cls, buf, offset): + n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset) + x = WhileLoopAttribute() + x.Init(buf, n + offset) + return x + + # WhileLoopAttribute + def Init(self, buf, pos): + self._tab = flatbuffers.table.Table(buf, pos) + + # WhileLoopAttribute + def CondBranch(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + + # WhileLoopAttribute + def BodyBranch(self): + o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6)) + if o != 0: + return self._tab.String(o + self._tab.Pos) + return None + +def WhileLoopAttributeStart(builder): builder.StartObject(2) +def WhileLoopAttributeAddCondBranch(builder, condBranch): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(condBranch), 0) +def WhileLoopAttributeAddBodyBranch(builder, bodyBranch): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(bodyBranch), 0) +def WhileLoopAttributeEnd(builder): return builder.EndObject() diff --git a/verif/tosa/__init__.py b/verif/tosa/__init__.py new file mode 100644 index 0000000..ee1ab30 --- /dev/null +++ b/verif/tosa/__init__.py @@ -0,0 +1,15 @@ + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + diff --git a/verif/tosa_ref_run.py b/verif/tosa_ref_run.py new file mode 100644 index 0000000..99f504b --- /dev/null +++ b/verif/tosa_ref_run.py @@ -0,0 +1,66 @@ +import os + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import shlex +import subprocess +from tosa_test_runner import TosaTestRunner, run_sh_command + +class TosaRefRunner(TosaTestRunner): + def __init__(self, args, runnerArgs, testDir): + super().__init__(args, runnerArgs, testDir) + + def runModel(self): + # Build up the TOSA reference command line + # Uses arguments from the argParser args, not the runnerArgs + args = self.args + + ref_cmd = [ args.ref_model_path, + '-Csubgraph_file={}'.format(self.testDesc['tosa_file']), + '-Csubgraph_dir={}'.format(self.testDir), + '-Cinput_dir={}'.format(self.testDir), + '-Coutput_dir={}'.format(self.testDir), + '-Coutput_tensor_prefix=ref-', # Naming agreement with TosaSerializer + ] + + # Build up input tensor_name/filename list + inputTensors = [] + for i in range(len(self.testDesc['ifm_placeholder'])): + inputTensors.append('{}:{}'.format(self.testDesc['ifm_placeholder'][i], self.testDesc['ifm_file'][i])) + + ref_cmd.append('-Cinput_tensor={}'.format(','.join(inputTensors))) + + if args.ref_debug: + ref_cmd.extend(['-dALL', '-l{}'.format(args.ref_debug)]) + + if args.ref_intermediates: + ref_cmd.extend(['-Ddump_intermediates=1']) + + expectedFailure = self.testDesc['expected_failure'] + + try: + run_sh_command(self.args, ref_cmd) + if expectedFailure: + result = TosaTestRunner.Result.UNEXPECTED_PASS + else: + result = TosaTestRunner.Result.EXPECTED_PASS + except Exception as e: + if expectedFailure: + result = TosaTestRunner.Result.EXPECTED_FAILURE + else: + result = TosaTestRunner.Result.EXPECTED_PASS + + return result diff --git a/verif/tosa_serializer.py b/verif/tosa_serializer.py new file mode 100644 index 0000000..7ba68c3 --- /dev/null +++ b/verif/tosa_serializer.py @@ -0,0 +1,718 @@ + + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +#!/usr/bin/env python3 + +import flatbuffers +import numpy as np +from enum import Enum, IntEnum, unique +from tosa import TosaGraph, TosaBasicBlock, TosaTensor, TosaOperator, DType, Format, Usage, Op, ResizeMode, Version +import tosa +import os +import json + +# With the way flatc generates its python types, there is no programatic way +# to get string names for the integer types. Manually maintain a string table +# here. +DTypeNames = [ 'UNKNOWN', + 'BOOL', + 'AINT8', + 'UINT8', + 'INT4', + 'INT8', + 'INT16', + 'INT32', + 'INT48', + 'FLOAT' ] + +def dtype_str_to_val(name): + + for i in range(len(DTypeNames)): + if name.casefold() == DTypeNames[i].casefold(): + return i + raise Exception('Unable to parse DType name {}'.format(name)) + + +class TosaSerializerUnion: + '''This class handles encapsulating and serializing union types into flatbuffers''' + def __init__(self): + + # A tuple of the start and end functions. Set by the options constructors below + self.optFcns = None + + # The type from the tosa.Options enumeration. Set by the options constructors below. + self.utype = None + + # Each of these lists is a tuple of the add function and the + # value being added. Set by the options constructors below. + self.ints = [] + self.bools = [] + self.floats = [] + self.strings = [] + self.intvecs = [] + + def serialize(self, builder): + + # We have to build strings and vectors first + strList = [] + intVecList = [] + + for fcn, val in self.strings: + strList.append((fcn, builder.CreateString(val))) + + for fcn, val in self.intvecs: + intVecList.append((fcn, TosaSerializer.serializeInt32Vec(builder, val))) + + startFcn, endFcn = self.optFcns + + # Then serialize the options object from the list of primitives and + # other serialized values + startFcn(builder) + for fcn, val in self.ints: + fcn(builder, val) + + for fcn, val in self.bools: + fcn(builder, val) + + for fcn, val in self.floats: + fcn(builder, val) + + for fcn, val in strList: + fcn(builder, val) + + for fcn, val in intVecList: + fcn(builder, val) + + return endFcn(builder) + +class TosaSerializerAttribute(TosaSerializerUnion): + '''This class handles encapsulating all of the enumerated types for attributes''' + + def __init__(self): + super().__init__() + + def Pool2dAttribute(self, kernel, stride, padding): + from tosa import Pool2dAttribute as a, Attribute + + self.utype = Attribute.Attribute().Pool2dAttribute + + self.optFcns = (a.Pool2dAttributeStart, a.Pool2dAttributeEnd) + self.intvecs.append((a.Pool2dAttributeAddPadding, + padding)) + self.intvecs.append((a.Pool2dAttributeAddKernel, + kernel)) + self.intvecs.append((a.Pool2dAttributeAddStride, + stride)) + + def Conv2dAttribute(self, padding, stride, dilation): + from tosa import Conv2dAttribute as a, Attribute + + self.utype = Attribute.Attribute().Conv2dAttribute + self.optFcns = (a.Conv2dAttributeStart, a.Conv2dAttributeEnd) + + self.intvecs.append((a.Conv2dAttributeAddPadding, + padding)) + self.intvecs.append((a.Conv2dAttributeAddStride, + stride)) + self.intvecs.append((a.Conv2dAttributeAddDilation, + dilation)) + + def TransposeConv2DAttribute(self, outpad, stride, dilation, output_shape): + from tosa import TransposeConv2dAttribute as a, Attribute + + self.utype = Attribute.Attribute().TransposeConv2dAttribute + self.optFcns = (a.TransposeConv2dAttributeStart, a.TransposeConv2dAttributeEnd) + + self.intvecs.append((a.TransposeConv2dAttributeAddOutpad, + outpad)) + self.intvecs.append((a.TransposeConv2dAttributeAddStride, + stride)) + self.intvecs.append((a.TransposeConv2dAttributeAddDilation, + dilation)) + self.intvecs.append((a.TransposeConv2dAttributeAddOutputShape, + output_shape)) + + def ReluNAttribute(self, maxint, maxfp): + from tosa import ReluNAttribute as a, Attribute + + self.utype = Attribute.Attribute().ReluNAttribute + self.optFcns = (a.ReluNAttributeStart, a.ReluNAttributeEnd) + + self.ints.append((a.ReluNAttributeAddMaxInt, maxint)) + self.ints.append((a.ReluNAttributeAddMaxFp, maxfp)) + + + def AxisAttribute(self, axis): + from tosa import AxisAttribute as a, Attribute + + self.utype = Attribute.Attribute().AxisAttribute + self.optFcns = (a.AxisAttributeStart, a.AxisAttributeEnd) + + self.ints.append((a.AxisAttributeAddAxis, + axis)) + + def ReshapeAttribute(self, shape): + from tosa import ReshapeAttribute as a, Attribute + + self.utype = Attribute.Attribute().ReshapeAttribute + self.optFcns = (a.ReshapeAttributeStart, a.ReshapeAttributeEnd) + + self.intvecs.append((a.ReshapeAttributeAddShape, + shape)) + + def SliceAttribute(self, begin, size): + from tosa import SliceAttribute as a, Attribute + + self.utype = Attribute.Attribute().SliceAttribute + self.optFcns = (a.SliceAttributeStart, a.SliceAttributeEnd) + + self.intvecs.append((a.SliceAttributeAddBegin, + begin)) + self.intvecs.append((a.SliceAttributeAddSize, + size)) + + def TileAttribute(self, multiples): + from tosa import TileAttribute as a, Attribute + + self.utype = Attribute.Attribute().TileAttribute + self.optFcns = (a.TileAttributeStart, a.TileAttributeEnd) + + self.intvecs.append((a.TileAttributeAddMultiples, + multiples)) + + def ResizeAttribute(self, output_size, stride, offset, shift, mode): + from tosa import ResizeAttribute as a, Attribute + + self.utype = Attribute.Attribute().ResizeAttribute + self.optFcns = (a.ResizeAttributeStart, a.ResizeAttributeEnd) + + self.intvecs.append((a.ResizeAttributeAddOutputSize, + output_size)) + self.intvecs.append((a.ResizeAttributeAddStride, + stride)) + self.intvecs.append((a.ResizeAttributeAddOffset, + offset)) + self.ints.append((a.ResizeAttributeAddShift, + shift)) + self.ints.append((a.ResizeAttributeAddMode, + mode)) + + def ClampAttribute(self, minint, maxint, minfp, maxfp): + from tosa import ClampAttribute as a, Attribute + + self.utype = Attribute.Attribute().ClampAttribute + self.optFcns = (a.ClampAttributeStart, a.ClampAttributeEnd) + + self.ints.append((a.ClampAttributeAddMinInt, + minint)) + self.ints.append((a.ClampAttributeAddMaxInt, + maxint)) + + self.ints.append((a.ClampAttributeAddMinFp, + minfp)) + self.ints.append((a.ClampAttributeAddMaxFp, + maxfp)) + + def RescaleAttribute(self, input_zp, output_zp, multiplier, shift, scale32, double_round, per_channel): + from tosa import RescaleAttribute as a, Attribute + + self.utype = Attribute.Attribute().RescaleAttribute + self.optFcns = (a.RescaleAttributeStart, a.RescaleAttributeEnd) + + self.ints.append((a.RescaleAttributeAddInputZp, + input_zp)) + self.ints.append((a.RescaleAttributeAddOutputZp, + output_zp)) + self.intvecs.append((a.RescaleAttributeAddMultiplier, + multiplier)) + self.intvecs.append((a.RescaleAttributeAddShift, + shift)) + self.bools.append((a.RescaleAttributeAddScale32, + scale32)) + self.bools.append((a.RescaleAttributeAddDoubleRound, + double_round)) + self.bools.append((a.RescaleAttributeAddPerChannel, + per_channel)) + + def CustomAttribute(self, identifier): + from tosa import CustomAttribute as a, Attribute + + self.utype = Attribute.Attribute().CustomAttribute + self.optFcns = (a.CustomAttributeStart, a.CustomAttributeEnd) + + self.strings.append((a.CustomAttributeAddIdentifier, + identifier)) + + def CondIfAttribute(self, then_branch, else_branch): + from tosa import CondIfAttribute as a, Attribute + + self.utype = Attribute.Attribute().CondIfAttribute + self.optFcns = (a.CondIfAttributeStart, a.CondIfAttributeEnd) + + self.strings.append((a.CondIfAttributeAddThenBranch, + then_branch)) + self.strings.append((a.CondIfAttributeAddElseBranch, + else_branch)) + + def WhileLoopAttribute(self, cond_branch, body_branch): + from tosa import WhileLoopAttribute as a, Attribute + + self.utype = Attribute.Attribute().WhileLoopAttribute + self.optFcns = (a.WhileLoopAttributeStart, a.WhileLoopAttributeEnd) + + self.strings.append((a.WhileLoopAttributeAddCondBranch, + cond_branch)) + self.strings.append((a.WhileLoopAttributeAddBodyBranch, + body_branch)) + +class TosaSerializerQuantInfo(TosaSerializerUnion): + '''This class handles encapsulating all of the enumerated types for quantinfo types''' + def __init__(self): + super().__init__() + + def ConvQuantInfo(self, input_zp, weight_zp): + from tosa import ConvQuantInfo as q, QuantInfo + + self.utype = QuantInfo.QuantInfo().ConvQuantInfo + self.optFcns = (q.ConvQuantInfoStart, q.ConvQuantInfoEnd) + self.ints.append((q.ConvQuantInfoAddInputZp, input_zp)) + self.ints.append((q.ConvQuantInfoAddWeightZp, weight_zp)) + + def UnaryQuantInfo(self, input_zp, output_zp): + from tosa import UnaryQuantInfo as q, QuantInfo + + self.utype = QuantInfo.QuantInfo().UnaryQuantInfo + self.optFcns = (q.UnaryQuantInfoStart, q.UnaryQuantInfoEnd) + self.ints.append((q.UnaryQuantInfoAddInputZp, input_zp)) + self.ints.append((q.UnaryQuantInfoAddOutputZp, output_zp)) + + def MatMulQuantInfo(self, a_zp, b_zp): + from tosa import MatMulQuantInfo as q, QuantInfo + + self.utype = QuantInfo.QuantInfo().MatMulQuantInfo + self.optFcns = (q.MatMulQuantInfoStart, q.MatMulQuantInfoEnd) + self.ints.append((q.MatMulQuantInfoAddAZp, a_zp)) + self.ints.append((q.MatMulQuantInfoAddBZp, b_zp)) + + def PadQuantInfo(self, input_zp): + from tosa import PadQuantInfo as q, QuantInfo + + self.utype = QuantInfo.QuantInfo().PadQuantInfo + self.optFcns = (q.PadQuantInfoStart, q.PadQuantInfoEnd) + self.ints.append((q.PadQuantInfoAddInputZp, input_zp)) + +class TosaSerializerTensor: + def __init__(self, name, shape, dtype, usage, dformat, filename = None, placeholderFilename = None): + self.name = name + + if isinstance(shape, np.ndarray): + shape = shape.astype(int).tolist() + shape = list(map(int, shape)) + + self.shape = shape + self.dtype = dtype + self.usage = TosaSerializer.toList(usage) + self.dformat = TosaSerializer.toList(dformat) + + # Filename for const tensors. This gets written to the .tosa serialization + self.filename = filename + + # Filename for placeholder tensors. These get generated by the test generation + # process and are written to disk, but are considered input tensors by the network + # so they do not appear in the TOSA serialiazation. However, if we want to form a unit + # test around these input tensors, we can get the filename from here. + self.placeholderFilename = placeholderFilename + + def __str__(self): + str = 'TosaSerializerTensor name: {} shape: {} dtype: {} Usage: {} format {} filename: {}'.format( + self.name, self.shape, DTypeNames[self.dtype], self.usage, self.dformat, self.filename) + return str + + def addUsage(self, usage): + self.usage.append(usage) + + def addFormat(self, format): + self.dformat.append(format) + + def setDtype(self, dtype): + self.dtype = dtype + + def merge(self, name, shape, dtype, usage, dformat, filename = None): + # Merge in additional usage/formats to the list + found = 0 + for i in self.usage: + if i == usage: + found = 1 + break + if not found: + self.usage.append(usage) + + found = 0 + for i in self.dformat: + if i == dformat: + found = 1 + break + if not found: + self.dformat.append(dformat) + + def serialize(self, builder): + fb_name = builder.CreateString(self.name) + if self.filename: + fb_filename = builder.CreateString(self.filename) + fb_shapes = TosaSerializer.serializeInt32Vec(builder, self.shape) + fb_usage = TosaSerializer.serializeInt32Vec(builder, self.usage) + fb_dformat = TosaSerializer.serializeInt32Vec(builder, self.dformat) + + TosaTensor.TosaTensorStart(builder) + TosaTensor.TosaTensorAddName(builder, fb_name) + TosaTensor.TosaTensorAddShape(builder, fb_shapes) + TosaTensor.TosaTensorAddType(builder, self.dtype) + TosaTensor.TosaTensorAddUsage(builder, fb_usage) + TosaTensor.TosaTensorAddFormat(builder, fb_dformat) + if self.filename: + TosaTensor.TosaTensorAddNpyFilename(builder, fb_filename) + + return TosaTensor.TosaTensorEnd(builder) + +class TosaSerializerOperator: + def __init__(self, op, inputs, outputs, attributes = None, quantInfo = None): + self.op = op + self.attributes = attributes + self.inputs = TosaSerializer.toList(inputs) + self.outputs = TosaSerializer.toList(outputs) + self.quantInfo = quantInfo + + def __str__(self): + str = 'Op {}\n----\n'.format(self.op) + + for i in self.inputs: + str = str + ' Input: {}\n'.format(i) + for o in self.outputs: + str = str + ' Output: {}\n'.format(o) + + return str + + def serialize(self, builder): + fb_inputs = TosaSerializer.serializeStrVec(builder, self.inputs, TosaOperator.TosaOperatorStartInputsVector) + fb_outputs = TosaSerializer.serializeStrVec(builder, self.outputs, TosaOperator.TosaOperatorStartOutputsVector) + # Need to serialize quant_info and attributes enums still + if self.attributes is not None: + fb_attributes = self.attributes.serialize(builder) + + if self.quantInfo is not None: + fb_qinfo = self.quantInfo.serialize(builder) + + TosaOperator.TosaOperatorStart(builder) + TosaOperator.TosaOperatorAddOp(builder, self.op) + TosaOperator.TosaOperatorAddInputs(builder, fb_inputs) + TosaOperator.TosaOperatorAddOutputs(builder, fb_outputs) + if self.attributes is not None: + TosaOperator.TosaOperatorAddAttributeType(builder, self.attributes.utype) + TosaOperator.TosaOperatorAddAttribute(builder, fb_attributes) + if self.quantInfo is not None: + TosaOperator.TosaOperatorAddQuantInfoType(builder, self.quantInfo.utype) + TosaOperator.TosaOperatorAddQuantInfo(builder, fb_qinfo) + + return TosaOperator.TosaOperatorEnd(builder) + +class TosaSerializerBasicBlock: + def __init__(self, name): + self.name = name + self.operators = [] + + # Dict assures uniqueness, but allows us to look up by name + self.tensors = dict() + + self.inputs = [] + self.outputs = [] + + def addTensor(self, name, shape, dtype, usage, dformat, filename = None, placeholderFilename = None): + try: + # Someone already added this tensor. + # We may have to add more usages and formats + tens = self.tensors[name] + filename = tens.merge(name, shape, dtype, usage, dformat, filename) + except KeyError: + self.tensors[name] = TosaSerializerTensor(name, shape, dtype, usage, dformat, filename, placeholderFilename) + + return self.tensors[name] + + def addInput(self, name): + self.inputs.append(name) + + def addOutput(self, name): + self.outputs.append(name) + + def addOperator(self, op, inputs, outputs, attributes = None, quant_info = None): + self.operators.append(TosaSerializerOperator(op, inputs, outputs, attributes, quant_info)) + + def serialize(self, builder): + fb_name = builder.CreateString(self.name) + fbv_inputs = TosaSerializer.serializeStrVec(builder, list(self.inputs), TosaBasicBlock.TosaBasicBlockStartInputsVector) + fbv_outputs = TosaSerializer.serializeStrVec(builder, list(self.outputs), TosaBasicBlock.TosaBasicBlockStartOutputsVector) + fbv_tensors = TosaSerializer.serializeObjVec(builder, list(self.tensors.values()), TosaBasicBlock.TosaBasicBlockStartTensorsVector) + fbv_operators = TosaSerializer.serializeObjVec(builder, self.operators, TosaBasicBlock.TosaBasicBlockStartOperatorsVector) + + TosaBasicBlock.TosaBasicBlockStart(builder) + TosaBasicBlock.TosaBasicBlockAddName(builder, fb_name) + TosaBasicBlock.TosaBasicBlockAddInputs(builder, fbv_inputs) + TosaBasicBlock.TosaBasicBlockAddOutputs(builder, fbv_outputs) + TosaBasicBlock.TosaBasicBlockAddTensors(builder, fbv_tensors) + TosaBasicBlock.TosaBasicBlockAddOperators(builder, fbv_operators) + return TosaBasicBlock.TosaBasicBlockEnd(builder) + +@unique +class TensorDir(IntEnum): + PLACEHOLDER = 0 + CONST = 1 + INTERMEDIATE = 2 + RESULT = 3 + +class TosaSerializer: + def __init__(self, pathPrefix): + + # Get the global TOSA version if not already defined + try: + TOSA_VERSION + except NameError: + TosaSerializer.setTosaVersion() + + self.builder = flatbuffers.Builder(0) + + self.basicBlocks = [] + self.startBasicBlock('main') + self.pathPrefix = pathPrefix + + # Indicies used for adding/naming tensors + self.currInputIdx = 0 + self.currConstIdx = 0 + self.currLayerIdx = 1 + self.currResultIdx = 0 + + # Is this an illegal test that is expected to fail? + self.expectedFailure = False + self.expectedFailureDesc = '' + + def __str__(self): + str = '' + for bb in self.basicBlocks: + str = str + bb.__str__() + return str + + def addPlaceholder(self, shape, dtype, usage, dformat, vals): + if not self.currBasicBlock: + raise Exception('addTensor called without valid basic block') + + name = 'input-{}'.format(self.currInputIdx) + filename = '{}.npy'.format(name) + self.currInputIdx = self.currInputIdx + 1 + + tens = self.currBasicBlock.addTensor(name, shape, dtype, usage, dformat, None, filename) + # This is always an input to the block + self.currBasicBlock.addInput(name) + # Add the operator now + self.currBasicBlock.addOperator(tosa.Op.Op().PLACEHOLDER, [], name) + + if vals is not None: + np.save(os.path.join(self.pathPrefix, filename), vals, False) + + return tens + + def addConst(self, shape, dtype, usage, dformat, vals): + if not self.currBasicBlock: + raise Exception('addTensor called without valid basic block') + + name = 'const-{}'.format(self.currInputIdx) + filename = '{}.npy'.format(name) + self.currInputIdx = self.currInputIdx + 1 + + tens = self.currBasicBlock.addTensor(name, shape, dtype, usage, dformat, filename) + # Add the operator now + self.currBasicBlock.addOperator(tosa.Op.Op().CONST, [], name) + + if vals is not None: + np.save(os.path.join(self.pathPrefix, filename), vals, False) + return tens + + def addIntermediate(self, shape, dtype, usage, dformat): + + if not self.currBasicBlock: + raise Exception('addTensor called without valid basic block') + + name = 'layer-{}'.format(self.currLayerIdx) + filename = None # No file, so no filename + self.currLayerIdx = self.currLayerIdx + 1 + + tens = self.currBasicBlock.addTensor(name, shape, dtype, usage, dformat, filename) + + return tens + + def addInputTensor(self, tensor): + self.currBasicBlock.addOperator(tosa.Op.Op().PLACEHOLDER, [], tensor.name) + self.currBasicBlock.addTensor(tensor.name, tensor.shape, tensor.dtype, tensor.usage, tensor.dformat) + self.currBasicBlock.addInput(tensor.name) + + def addOutputTensor(self, tensor): + self.currBasicBlock.addOutput(tensor.name) + + def addOutput(self, shape, dtype, usage, dformat): + if not self.currBasicBlock: + raise Exception('addTensor called without valid basic block') + + name = 'result-{}'.format(self.currResultIdx) + self.currResultIdx = self.currResultIdx + 1 + + tens = self.currBasicBlock.addTensor(name, shape, dtype, usage, dformat, None) + self.currBasicBlock.addOutput(name) + return tens + + def addOperator(self, op, inputs, outputs, attributes = None, quant_info = None): + + if op == tosa.Op.Op().PLACEHOLDER or \ + op == tosa.Op.Op().CONST: + raise Exception('Use addPlaceholderTensor() or addConstTensor() to add PLACEHOLDER and CONST ops') + + return self.currBasicBlock.addOperator(op, inputs, outputs, attributes, quant_info) + + def setExpectedFailure(self, desc='', val=True): + self.expectedFailure = val + self.expectedFailureDesc = desc + + def setExpectedFailure(self, desc='', val=True): + self.expectedFailure = val + self.expectedFailureDesc = desc + + def serialize(self): + + builder = self.builder + + Version.VersionStart(builder) + Version.VersionAdd_major(builder, TOSA_VERSION[0]) + Version.VersionAdd_minor(builder, TOSA_VERSION[1]) + Version.VersionAdd_patch(builder, TOSA_VERSION[2]) + Version.VersionAdd_experimental(builder, TOSA_VERSION[3]) + version = Version.VersionEnd(builder) + + fbv_bb = TosaSerializer.serializeObjVec(builder, self.basicBlocks, TosaGraph.TosaGraphStartBlocksVector) + + TosaGraph.TosaGraphStart(builder) + TosaGraph.TosaGraphAddVersion(builder, version) + TosaGraph.TosaGraphAddBlocks(builder, fbv_bb) + graph = TosaGraph.TosaGraphEnd(builder) + + self.builder.Finish(graph) + return self.builder.Output() + + def writeJson(self, tosa_filename): + '''Write a json test file so that it is fairly easy to pick up the test + and generate commands for third party tool''' + test_desc = dict() + + test_desc['tosa_file'] = tosa_filename + ifm_name = [] + ifm_shape = [] + ifm_file = [] + ofm_name = [] + ofm_file = [] + ofm_shape = [] + + for b in self.basicBlocks: + if b.name == 'main': + for i in b.inputs: + ifm_name.append(i) + ifm_shape.append(b.tensors[i].shape) + ifm_file.append(b.tensors[i].placeholderFilename) + for o in b.outputs: + ofm_name.append(o) + ofm_shape.append(b.tensors[o].shape) + # Make up an OFM filename here. One isn't generated until the reference tool is + # run, so any name is a good name + ofm_file.append('ref-{}.npy'.format(o)) + + test_desc['ifm_placeholder'] = ifm_name + test_desc['ifm_file'] = ifm_file + test_desc['ifm_shape'] = ifm_shape + test_desc['ofm_name'] = ofm_name + test_desc['ofm_shape'] = ofm_shape + test_desc['ofm_file'] = ofm_file + test_desc['expected_failure'] = self.expectedFailure + if self.expectedFailureDesc: + test_desc['expected_failure_desc'] = self.expectedFailureDesc + + return json.dumps(test_desc, indent=' ') + + def startBasicBlock(self, name): + self.currBasicBlock = TosaSerializerBasicBlock(name) + self.basicBlocks.append(self.currBasicBlock) + + @staticmethod + def serializeStrVec(builder, vec, start_fcn): + fb_strs = [builder.CreateString(i) for i in vec] + start_fcn(builder, len(fb_strs)) + for s in fb_strs[::-1]: + builder.PrependUOffsetTRelative(s) + return builder.EndVector(len(fb_strs)) + + @staticmethod + def serializeInt32Vec(builder, vec): + builder.StartVector(4, len(vec), 4) + for v in vec[::-1]: + builder.PrependInt32(v) + return builder.EndVector(len(vec)) + + @staticmethod + def serializeObjVec(builder, vec, start_fcn): + serialized_vec = [] + for v in vec[::-1]: + serialized_vec.append(v.serialize(builder)) + + start_fcn(builder, len(vec)) + for v in serialized_vec: + builder.PrependUOffsetTRelative(v) + return builder.EndVector(len(vec)) + + @staticmethod + def toList(val): + if isinstance(val, list): + return val + else: + return [val] + + @staticmethod + def setTosaVersion(): + # Create a dummy flatbuffers file with the default version information + # There does not appear to be a better way to get a constant from a + # flatbuffer schema file + builder = flatbuffers.Builder(0) + Version.VersionStart(builder) + ver = Version.VersionEnd(builder) + TosaGraph.TosaGraphStart(builder) + TosaGraph.TosaGraphAddVersion(builder, ver) + gr = TosaGraph.TosaGraphEnd(builder) + builder.Finish(gr) + + out = builder.Output() + + gr = TosaGraph.TosaGraph() + root = gr.GetRootAsTosaGraph(out, 0) + + # Store the version as a global variable so that it only needs to be + # generated once per process. + global TOSA_VERSION + TOSA_VERSION = [root.Version()._major(), + root.Version()._minor(), + root.Version()._patch(), + root.Version()._experimental() ] diff --git a/verif/tosa_test_gen.py b/verif/tosa_test_gen.py new file mode 100644 index 0000000..dc2d803 --- /dev/null +++ b/verif/tosa_test_gen.py @@ -0,0 +1,2301 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import numpy as np +import argparse +import sys +import re +import os +import subprocess +import shlex +import json +import glob +import math +import queue +import threading +import traceback +import math + +from enum import IntEnum, Enum, unique + +import tosa_serializer as ts +from tosa_serializer import * +import tosa + +# Convenience variables to the flatc-generated types that should be enums, but aren't +DType = tosa.DType.DType() +Usage = tosa.Usage.Usage() +Format = tosa.Format.Format() +Op = tosa.Op.Op() +ResizeMode = tosa.ResizeMode.ResizeMode() + +class TosaQuantGen: + '''QuantizedInfo random generator helper functions. Specify with 'qgen': in the operator defintion''' + def __init__(self): + pass + + @staticmethod + def needsQinfo(op, dtype): + if dtype == DType.AINT8 or dtype == DType.INT8: + return True + return False + + @staticmethod + def qgUnary(testGen, op, dtype): + qinfo = ts.TosaSerializerQuantInfo() + if TosaQuantGen.needsQinfo(op, dtype): + qinfo.UnaryQuantInfo(testGen.randInt(), testGen.randInt()) + else: + qinfo.UnaryQuantInfo(0, 0) + return qinfo + + @staticmethod + def qgConv(testGen, op, dtype): + qinfo = ts.TosaSerializerQuantInfo() + if TosaQuantGen.needsQinfo(op, dtype): + qinfo.ConvQuantInfo(testGen.randInt(), testGen.randInt()) + else: + qinfo.ConvQuantInfo(0, 0) + return qinfo + + @staticmethod + def qgMatmul(testGen, op, dtype): + qinfo = ts.TosaSerializerQuantInfo() + if TosaQuantGen.needsQinfo(op, dtype): + qinfo.MatMulQuantInfo(testGen.randInt(), testGen.randInt()) + else: + qinfo.MatMulQuantInfo(0, 0) + return qinfo + + @staticmethod + def qgPad(testGen, op, dtype): + qinfo = ts.TosaSerializerQuantInfo() + if TosaQuantGen.needsQinfo(op, dtype): + qinfo.PadQuantInfo(testGen.randInt()) + else: + qinfo.PadQuantInfo(0) + return qinfo + + @staticmethod + def computeMultiplierAndShift(scaleFp, scale32): + # Derived from computeMultiplierAndShiftTosaScale32 + # Provide a floating-point scaling factor and the scale32 parameter + # to compute the multiplier and shift + + if scale32: + scaleBits = 31 + else: + scaleBits = 15 + + m, shift = math.frexp(scaleFp) + + if scaleFp < 0.0: + m = -m + + multiplier = round(m * (1 << scaleBits)) + assert(multiplier <= (1 << scaleBits)) + + if multiplier == (1 << scaleBits): + multiplier = multiplier // 2 + shift = shift + 1 + + shift = (-shift) + scaleBits + #print('scalefp {} scaleBits {} m {} mult {} shift {}'.format(scaleFp, scaleBits, m, multiplier, shift)) + + assert(multiplier <= (1 << scaleBits)) + assert(shift >= 0 and shift <= 63) + + return multiplier, shift + + +class TosaTensorGen(): + ''' Tensor generators create a shape list for the placeholder and const tensor + data operands for the operator. The actual random data is generated separately for each test.''' + def __init__(self): + pass + + @staticmethod + def tgBasic(testGen, opName, rank): + pl, const = opName['operands'] + shape = testGen.makeShape(rank) + + shape_list = [] + for i in range(pl + const): + shape_list.append(shape.copy()) + + return shape_list + + @staticmethod + def tgNHWC(testGen, opName, rank): + pl, const = opName['operands'] + + assert(rank == 4) + + shape = testGen.makeShape(rank) + + # Constrict the batch size? + if testGen.args.max_batch_size: + shape[0] = (shape[0] % testGen.args.max_batch_size) + 1 + + shape_list = [] + for i in range(pl + const): + shape_list.append(shape.copy()) + + return shape_list + + @staticmethod + def tgBroadcastFuzz(testGen, op, rank): + shape = testGen.makeShape(rank) + + pl, const = op['operands'] + + shape_list = [] + + # Choose one of the inputs to broadcast + bcast_idx = testGen.randInt(0, pl + const) + for i in range(pl + const): + shape_bcast = shape.copy() + + # If the chosen input, pick a random index to broadcast + if i == bcast_idx: + fuzz_idx = testGen.randInt(0, rank) + shape_bcast[fuzz_idx] = 1 + + shape_list.append(shape_bcast) + + return shape_list + + @staticmethod + def tgConv2D(testGen, op, rank): + pl, const = op['operands'] + + assert(rank == 4) + + # IFM dimensions are NHWC + ifm_shape = testGen.makeShape(rank) + + # Constrict the batch size? + if testGen.args.max_batch_size: + ifm_shape[0] = (ifm_shape[0] % testGen.args.max_batch_size) + 1 + + # Get the filter height/width from the operator parameters + filter_hw = op['filter'] + + # Generate a random OFM depth + ofm_depth = testGen.makeShape(1)[0] + + # The filter dimensions are OHWI + filter_shape = np.asarray([ofm_depth, filter_hw[0], filter_hw[1], ifm_shape[3]]) + + # The bias is OC + bias_shape = np.asarray([ofm_depth]) + + return [ifm_shape, filter_shape, bias_shape] + + @staticmethod + def tgTransposeConv2D(testGen, op, rank): + pl, const = op['operands'] + + assert(rank == 4) + + # IFM dimensions are NHWC + ifm_shape = testGen.makeShape(rank) + + # Constrict the batch size? + if testGen.args.max_batch_size: + ifm_shape[0] = (ifm_shape[0] % testGen.args.max_batch_size) + 1 + + # Get the filter height/width from the operator parameters + filter_hw = op['filter'] + + # Generate a random OFM depth + ofm_depth = testGen.makeShape(1)[0] + + # The filter dimensions are OHWI + filter_shape = np.asarray([ofm_depth, filter_hw[0], filter_hw[1], ifm_shape[3]]) + + return [ifm_shape, filter_shape] + + @staticmethod + def tgDepthwiseConv2D(testGen, op, rank): + pl, const = op['operands'] + + assert(rank == 4) + assert(pl == 1 and const == 2) + + # IFM dimensions are NHWC + ifm_shape = testGen.makeShape(rank) + + # Constrict the batch size? + if testGen.args.max_batch_size: + ifm_shape[0] = (ifm_shape[0] % testGen.args.max_batch_size) + 1 + + # Get the filter height/width from the operator parameters + # Filter is KH, HW, C, M + filter_hw = op['filter'] + + # Generate a random OFM depth, but don't let it get too big because + # the output depth is M * C + filter_m = (testGen.makeShape(1)[0] % (testGen.args.tensor_shape_range[1] // 4)) + 1 + + # The filter dimensions are HWCM + filter_shape = np.asarray([filter_hw[0], filter_hw[1], ifm_shape[3], filter_m]) + + # The bias is M * C + bias_shape = np.asarray([ifm_shape[3] * filter_m]) + + return [ifm_shape, filter_shape, bias_shape] + + @staticmethod + def tgFullyConnected(testGen, op, rank): + pl, const = op['operands'] + + assert(rank == 2) + assert(pl == 2 and const == 0) + + input_shape = testGen.makeShape(rank) + filter_oc = testGen.makeShape(1)[0] + filter_shape = np.asarray([filter_oc, input_shape[1]]) + + bias_shape = np.asarray([filter_oc]) + + return [input_shape, filter_shape, bias_shape] + + @staticmethod + def tgMatmul(testGen, op, rank): + pl, const = op['operands'] + + assert(rank == 2) + assert(pl == 2 and const == 0) + + a_shape = testGen.makeShape(rank) + b_oc = testGen.makeShape(1)[0] + b_shape = np.asarray([a_shape[1], b_oc]) + + return [a_shape, b_shape] + +class TosaArgGen: + '''Argument generators create exhaustive or random lists of attributes for operators that take + attributes or other parameters. The return value is a list of (descriptive_name, [arglist]) + tuples where the descriptive_name is appended to the test name and the arglist is expanded + as arguments to the operator build function.''' + def __init__(self): + pass + + @staticmethod + def agNone(testGen, opName, shapeList, dtype): + '''A trivial argument generator for operators that don't take any + non-tensor arguments''' + return [('', [])] + + @staticmethod + def agAxis(testGen, opName, shapeList, dtype): + '''Build the axis argument for operators that take a single axis''' + axes = [] + + shape = shapeList[0] + + for a in range(0, len(shape)): + axes.append(('axis_{}'.format(a), [a])) + return axes + + @staticmethod + def agConv2D(testGen, opName, shapeList, dtype): + arg_list = [] + + ifm_shape = shapeList[0] + filter_shape = shapeList[1] + + # Must be rank 4 + assert(len(ifm_shape) == 4) + assert(len(filter_shape) == 4) + + maxStride = testGen.args.max_conv_stride + maxPadding = testGen.args.max_conv_padding + 1 + maxDilation = testGen.args.max_conv_dilation + + # Strides, padding, dilations + for stride in range(0, maxStride ** 2): + for padding in range(0, (maxPadding) ** 4): + for dilation in range(0, maxDilation ** 2): + + s = [stride // maxStride + 1, + stride % maxStride + 1] + p = [(padding // (maxPadding * 4)) % maxPadding, + (padding // (maxPadding * 2)) % maxPadding, + (padding // (maxPadding * 1)) % maxPadding, + padding % maxPadding] + d = [ dilation // maxDilation + 1, + dilation % maxDilation + 1] + + # 4 padding parameters for regular conv2d + arg_list.append(('st{}{}_pad{}{}{}{}_dilat{}{}'.format(s[0], s[1], + p[0], p[1], p[2], p[3], + d[0], d[1]), + [ s, p, d ])) + return arg_list + + @staticmethod + def agTransposeConv2D(testGen, opName, shapeList, dtype): + arg_list = [] + + ifm_shape = shapeList[0] + filter_shape = shapeList[1] + + # Must be rank 4 + assert(len(ifm_shape) == 4) + assert(len(filter_shape) == 4) + + maxStride = testGen.args.max_conv_stride + maxPadding = testGen.args.max_conv_padding + 1 + maxDilation = testGen.args.max_conv_dilation + + # Strides, padding, dilations + for stride in range(0, maxStride ** 2): + for out_padding in range(0, (maxPadding) ** 2): + for dilation in range(0, maxDilation ** 2): + + s = [stride // maxStride + 1, + stride % maxStride + 1] + p = [(out_padding // (maxPadding * 1)) % maxPadding, + out_padding % maxPadding] + d = [ dilation // maxDilation + 1, + dilation % maxDilation + 1] + + oh = (ifm_shape[1] - filter_shape[1] - (filter_shape[1] - 1) * (d[0] - 1) + \ + 2 * p[0]) // s[0] + 1 + + ow = (ifm_shape[2] - filter_shape[2] - (filter_shape[2] - 1) * (d[1] - 1) + \ + 2 * p[1]) // s[1] + 1 + + # Output shape + os = [ ifm_shape[0], oh, ow, filter_shape[0] ] + + arg_list.append(('st{}{}_outpad{}{}_dilat{}{}_os{}x{}x{}x{}'.format(s[0], s[1], + p[0], p[1], + d[0], d[1], + os[0], os[1], os[2], os[3]), + [ s, p, d, os ])) + + return arg_list + + @staticmethod + def agPad(testGen, opName, shapeList, dtype): + arg_list = [] + rank = len(shapeList[0]) + + # Exhaustively test combinations of 0/1 padding on each side of each dimension + # This process might need some revision for >1 padding, but use rank**2 as a bitmask + # for now + for v in range(rank ** 2): + + # Create a flat arraypadding4D + paddings = np.zeros((rank * 2), dtype=np.int32) + + # Fill in the 1's + for r in (range(rank * 2)): + if (v >> r) & 1: + paddings[r] = 1 + + # Reshape back to a 2D array + paddings = paddings.reshape((rank, 2)) + + arg_list.append(('pad{0:b}'.format(v), [ paddings ])) + + return arg_list + + @staticmethod + def agPooling(testGen, opName, shapeList, dtype): + arg_list = [] + + shape = shapeList[0] + assert(len(shape) == 4) + + maxStride = testGen.args.max_pooling_stride + maxKernel = testGen.args.max_pooling_kernel + maxPadding = testGen.args.max_pooling_padding + 1 + + for kernel in range(0, maxKernel ** 2): + for stride in range(0, maxStride ** 2): + for padding in range(0, maxPadding ** 4): + s = [stride // maxStride + 1, + stride % maxStride + 1] + k = [(kernel // maxKernel) + 2, + (kernel % maxKernel) + 2] + p = [(padding // (maxPadding * 4)) % maxPadding, + (padding // (maxPadding * 2)) % maxPadding, + (padding // (maxPadding * 1)) % maxPadding, + padding % maxPadding] + + arg_list.append(('st{}{}_kern{}{}_pad{}{}{}{}'.format(s[0], s[1], + k[0], k[1], + p[0], p[1], p[2], p[3]), + [k, s, p])) + return arg_list + + @staticmethod + def agCast(testGen, opName, shapeList, inDtype): + arg_list = [] + + # Enumerate the output types here + if inDtype == DType.INT8: + dtypeList = [ DType.BOOL, DType.INT16, DType.INT32, DType.FLOAT ] + elif inDtype == DType.INT16: + dtypeList = [ DType.BOOL, DType.INT8, DType.INT32, DType.FLOAT ] + elif inDtype == DType.INT32: + dtypeList = [ DType.BOOL, DType.INT8, DType.INT16, DType.FLOAT ] + elif inDtype == DType.BOOL: + dtypeList = [ DType.INT8, DType.INT16, DType.INT32 ] + elif inDtype == DType.FLOAT: + dtypeList = [ DType.INT8, DType.INT16, DType.INT32 ] + else: + raise Exception('Unexpected input dtype: {}'.format(inDtype)) + + for dtype in dtypeList: + arg_list.append(('out{}'.format(DTypeNames[dtype]), [dtype])) + + return arg_list + + @staticmethod + def agRescale(testGen, opName, shapeList, inDtype): + arg_list = [] + + # Enumerate the output types here + for dtype in [ DType.AINT8, DType.INT16, DType.INT32 ]: + for scale32 in [ False, True ]: + for double_round in [ False, True ]: + for per_channel in [ False, True ]: + + if inDtype == DType.INT48 and scale32: + # Illegal condition. Must be scale32=False + continue + + arg_list.append(('out{}_sc{}_dr{}_pc{}'.format(DTypeNames[dtype], int(scale32), int(double_round), int(per_channel)), + [dtype, scale32, double_round, per_channel])) + + return arg_list + + # Helper function for reshape. Gets some factors of a larger number. + @staticmethod + def getFactors(val, start=1): + factors = [] + + for i in range(start, int(np.sqrt(val))): + if (val % i) == 0: + factors.append(i) + + return factors + + @staticmethod + def agReshape(testGen, opName, shapeList, dtype): + arg_list = [] + + origShape = shapeList[0] + + totalElements = 1 + for s in origShape: + totalElements *= s + + # This code is NOT fast. Fortunately, the numbers are fairly small. + factors = TosaArgGen.getFactors(totalElements) + + for p in range(testGen.args.num_rand_permutations): + newRank = testGen.randInt(1, 6) + newShape = [] + if (len(factors) < newRank): + continue + + remainingElements = totalElements + shuffledFactors = testGen.rng.permutation(factors) + for i in range(newRank): + # pick rank-1 factors + newShape.append(shuffledFactors[0]) + remainingElements = remainingElements // shuffledFactors[0] + shuffledFactors = testGen.rng.permutation(TosaArgGen.getFactors(remainingElements)) + newShape.append(remainingElements) + + # Toss in a -1 sometimes + minusOne = testGen.randInt(0, newRank * 4) + if minusOne < newRank: + newShape[minusOne] = -1 + + arg_list.append(('perm{}_rank{}'.format(p, newRank), [newShape])) + + return arg_list + + + @staticmethod + def agTranspose(testGen, opName, shapeList, dtype): + arg_list = [] + + ifm_shape = shapeList[0] + + perms = range(len(ifm_shape)) + for p in range(testGen.args.num_rand_permutations): + perms = np.int32(testGen.rng.permutation(perms)).tolist() + + # Avoid duplicates + found = False + for name, other_perm in arg_list: + if other_perm[0] == perms: + found = True + break + + if not found: + arg_list.append(('perm{}'.format(p), [perms])) + + return arg_list + + @staticmethod + def agSlice(testGen, opName, shapeList, dtype): + arg_list = [] + + ifm_shape = shapeList[0] + rank = len(ifm_shape) + + for p in range(testGen.args.num_rand_permutations): + begin = [] + size = [] + + valid=True + + for i in range(rank): + if ifm_shape[i] > 1: + begin.append(testGen.randInt(0, ifm_shape[i])) + size.append(testGen.randInt(0, ifm_shape[i] - begin[i])) + + # Invalid slice size? + if size[i] == 0: + valid = False + else: + begin.append(0) + size.append(1) + + if valid: + arg_list.append(('perm{}'.format(p), [begin, size])) + return arg_list + + @staticmethod + def agTile(testGen, opName, shapeList, dtype): + arg_list = [] + + ifm_shape = shapeList[0] + rank = len(ifm_shape) + + for p in range(testGen.args.num_rand_permutations): + + # Pick a few random, but small multiple values + # because otherwise this has a tendency to generate + # enormous tensors + multiples = [] + for i in range(rank): + multiples.append(testGen.randInt(1, 4)) + + arg_list.append(('perm{}'.format(p), [multiples])) + + return arg_list + + @staticmethod + def agResize(testGen, opName, shapeList, dtype): + arg_list = [] + + ifm_shape = shapeList[0] + + for m in [ResizeMode.NEAREST, ResizeMode.BILINEAR]: + + # Exclude illegal {mode, type} configurations. Pick legal output types + if m == ResizeMode.NEAREST and dtype == DType.INT8: + outputDTypeList = [ DType.INT32 ] + elif m == ResizeMode.NEAREST and dtype == DType.INT16: + outputDTypeList = [ DType.INT16 ] + elif m == ResizeMode.BILINEAR and dtype == DType.INT8: + outputDTypeList = [ DType.INT8 ] + elif m == ResizeMode.BILINEAR and dtype == DType.INT16: + outputDTypeList = [ DType.INT48 ] + else: + continue + + for outputDType in outputDTypeList: + for perm in range(testGen.args.num_rand_permutations): + + # Randomly generate legal output dimensions and shift + # and then compute the stride and offset based on them + output_dims = [ testGen.randInt(), testGen.randInt() ] + + shift = testGen.randInt(1, 11) + + stride = [ (ifm_shape[1] << shift) // output_dims[0], + (ifm_shape[2] << shift) // output_dims[1] ] + + offset = [ testGen.randInt(-stride[0], (ifm_shape[1] << shift) - (output_dims[0] - 1) * stride[0]), + testGen.randInt(-stride[1], (ifm_shape[2] << shift) - (output_dims[1] - 1) * stride[1]) ] + + arg_list.append(('mode{}_shift{}_odim{}x{}_out{}_st{}x{}_off{}x{}'.format(m, shift, output_dims[0], output_dims[1], + testGen.typeStr(outputDType), stride[0], stride[1], + offset[0], offset[1]), + [m, stride, offset, shift, output_dims, outputDType])) + + return arg_list + + def agCondIf(testGen, opName, shapeList, dtype): + # CondIf generates the condition values here. + # Convert to tensors in the build function, along with the + # then and else blocks + arg_list = [] + + for c in [False, True]: + arg_list.append(('cond{}'.format(int(c)), [ c ])) + + return arg_list + + def agWhileLoop(testGen, opName, shapeList, dtype): + # While loop: 0 iterations, 1, more than 1 + arg_list = [] + + for iter in [0, 1, 4]: + arg_list.append(('iter{}'.format(iter), [ iter ])) + + return arg_list + +class TosaTestGen: + def __init__(self, args): + self.args = args + self.basePath = args.output_dir + self.random_seed = args.random_seed + self.ser = None + self.rng = np.random.default_rng(self.random_seed) + self.createDynamicOpLists() + self.initOpListDefaults() + self.quantGen = TosaQuantGen() + # Force makeShape to do a specific starting shape + self.targetted_shape = None + + def createSerializer(self, opName, testPath): + self.testPath = os.path.join(opName, testPath) + + fullPath = os.path.join(self.basePath, self.testPath) + os.makedirs(fullPath, exist_ok=True) + self.ser = ts.TosaSerializer(fullPath) + + def getSerializer(self): + return self.ser + + def serialize(self, testName): + with open(os.path.join(self.basePath, self.testPath, '{}.tosa'.format(testName)), 'wb') as fd: + fd.write(self.ser.serialize()) + + with open(os.path.join(self.basePath, self.testPath, 'desc.json'), 'w') as fd: + fd.write(self.ser.writeJson('{}.tosa'.format(testName))) + + def getRandTensor(self, shape, dtype): + RAND_SHIFT_FACTOR = 0.5 + RAND_SCALE_FACTOR = 4.0 + + if dtype == DType.BOOL: + np_dt = np.bool + return np.bool_(self.rng.choice(a=[False, True], size=shape)) + elif dtype == DType.AINT8: + return np.int32(self.rng.integers(low=0, high=256, size=shape)) + elif dtype == DType.INT4: + return np.int32(self.rng.integers(low=-7, high=8, size=shape)) + elif dtype == DType.INT8: + return np.int32(self.rng.integers(low=-127, high=128, size=shape)) + elif dtype == DType.INT16: + return np.int32(self.rng.integers(low=-32768, high=32768, size=shape)) + elif dtype == DType.INT32: + return np.int32(self.rng.integers(low=-(1 << 31), high=(1 << 31), size=shape)) + elif dtype == DType.INT48: + return np.int64(self.rng.integers(low=-(1 << 47), high=(1 << 47), size=shape)) + elif dtype == DType.FLOAT: + return np.float32(self.rng.random(size=shape) - RAND_SHIFT_FACTOR * RAND_SCALE_FACTOR) + else: + raise Exception('Unrecognized Dtype: {}'.format(dtype)) + + def buildPlaceholderTensors(self, shape_list, dtype): + placeholders = [] + + for shape in shape_list: + arr = self.getRandTensor(shape, dtype) + placeholders.append(self.ser.addPlaceholder(shape, dtype, Usage.ACTIVATION, [], arr)) + + return placeholders + + def buildConstTensors(self, shape_list, dtype): + consts = [] + + for shape in shape_list: + arr = self.getRandTensor(shape, dtype) + consts.append(self.ser.addConst(shape, dtype, Usage.ACTIVATION, [], arr)) + + return consts + + def makeShape(self, rank): + if self.targetted_shape: + return np.int32(self.targetted_shape) + return np.int32(self.rng.integers(low=self.args.tensor_shape_range[0], + high=self.args.tensor_shape_range[1], + size=rank)) + + def setTargetShape(self, shape): + self.targetted_shape = shape + + def randInt(self, low=0, high=256): + return np.int32(self.rng.integers(low=low, high=high, size=1))[0] + + def getRandNumberDType(self, dtype): + if dtype == DType.FLOAT: + return self.rng.random() + elif dtype == DType.BOOL: + return self.rng.choice([False, True]) + elif dtype == DType.INT4: + low, high = (-7, 8) + elif dtype == DType.AINT8: + low, high = (0, 256) + elif dtype == DType.INT8: + low, high = (-127, 128) + elif dtype == DType.INT16: + low, high = (-32768, 32768) + elif dtype == DType.INT32: + low, high = (-(1<<31), (1<<31)) + elif dtype == DType.INT48: + low, high = (-(1<<47), (1<<47)) + # Special size + return np.int64(self.rng.integers(low, high, size=1))[0] + else: + raise Exception('Unknown dtype: {}'.format(dtype)) + + return np.int32(self.rng.integers(low, high, size=1))[0] + + def shapeStr(self, shape): + + sStr = [] + # Convert to strings + for i in shape: + sStr.append(str(i)) + + return 'x'.join(sStr) + + def typeStr(self, t): + if t == DType.BOOL: + return 'b' + elif t == DType.AINT8: + return 'a8' + elif t == DType.INT4: + return 'i4' + elif t == DType.INT8: + return 'i8' + elif t == DType.INT16: + return 'i16' + elif t == DType.INT32: + return 'i32' + elif t == DType.INT48: + return 'i48' + elif t == DType.FLOAT: + return 'float' + else: + raise Exception('Unknown dtype, cannot convert to string: {}'.format(t)) + + def typeWidth(self, t): + ''' Get the datatype width for integer types''' + if t == DType.AINT8: + return 8 + elif t == DType.UINT8: + return 8 + elif t == DType.INT4: + return 4 + elif t == DType.INT8: + return 8 + elif t == DType.INT16: + return 16 + elif t == DType.INT32: + return 32 + elif t == DType.INT48: + return 48 + else: + raise Exception('Unknown dtype, cannot convert to string: {}'.format(t)) + + # Argument generators + # Returns a list of tuples (stringDescriptor, [build_fcn_arg_list]) + # Where the string descriptor is used to generate the test name and + # The build_fcn_arg_list is expanded and passed to the operator test + # build function + + + def build_unary(self, op, a, qinfo = None): + result_tens = OutputShaper.unaryOp(self.ser, a) + self.ser.addOperator(op, [a.name], [result_tens.name], None, qinfo) + return result_tens + + def build_binary_broadcast(self, op, a, b): + result_tens = OutputShaper.binaryBroadcastOp(self.ser, a, b) + self.ser.addOperator(op, [a.name, b.name], [result_tens.name]) + return result_tens + + def build_binary_nonbroadcast(self, op, a, b): + result_tens = OutputShaper.binaryNonBroadcastOp(self.ser, a, b) + self.ser.addOperator(op, [a.name, b.name], [result_tens.name]) + return result_tens + + def build_mul(self, op, a, b): + result_tens = OutputShaper.binaryBroadcastOp(self.ser, a, b) + + # Special for multiply: + # Force the result to INT32 for INT types + if a.dtype != DType.FLOAT: + result_tens.setDtype(DType.INT32) + + self.ser.addOperator(op, [a.name, b.name], [result_tens.name]) + return result_tens + + def build_table(self, op, a): + # Constant size, random values + table_arr = self.getRandTensor([513], DType.INT16) + table_tens = self.ser.addConst(table_arr.shape, DType.INT16, Usage.INDEX, [], table_arr) + + result_tens = OutputShaper.tableOp(self.ser, a, table_tens) + self.ser.addOperator(op, [a.name, table_tens.name], [result_tens.name], None) + + return result_tens + + def build_select(self, op, cond, a, b): + + # Replace the cond tensor with a boolean tensor since it probably + # has the wrong dtype + t = self.buildPlaceholderTensors([cond.shape], DType.BOOL) + cond = t[0] + + result_tens = OutputShaper.selectOp(self.ser, cond, a, b) + self.ser.addOperator(op, [cond.name, a.name, b.name], [result_tens.name]) + + return result_tens + + def build_comparison(self, op, a, b): + result_tens = OutputShaper.binaryComparisonOp(self.ser, a, b) + self.ser.addOperator(op, [a.name, b.name], [result_tens.name]) + return result_tens + + def build_argmax(self, op, a, axis): + result_tens = OutputShaper.argmaxOp(self.ser, a, axis) + + attr = ts.TosaSerializerAttribute() + attr.AxisAttribute(axis) + + self.ser.addOperator(op, [a.name], [result_tens.name], attr) + return result_tens + + def build_pool2d(self, op, input, kernel, stride, pad, qinfo = None): + result_tens = OutputShaper.pool2dOp(self.ser, input, kernel, stride, pad) + + attr = ts.TosaSerializerAttribute() + attr.Pool2dAttribute(kernel, stride, pad) + input.addFormat(Format.NHWC) + + self.ser.addOperator(op, [input.name], [result_tens.name], attr, qinfo) + return result_tens + + def build_conv2d(self, op, ifm, filter, bias, strides, padding, dilations, qinfo): + assert(len(padding) == 4) + result_tens = OutputShaper.conv2dOp(self.ser, ifm, filter, strides, padding, dilations) + + attr = ts.TosaSerializerAttribute() + attr.Conv2dAttribute(padding, strides, dilations) + + ifm.addFormat(Format.NHWC) + # Update the filter ordering + filter.addUsage(Usage.WEIGHT) + filter.addFormat(Format.OHWI) + + self.ser.addOperator(op, [ifm.name, filter.name, bias.name], [result_tens.name], attr, qinfo) + return result_tens + + def build_transpose_conv2d(self, op, ifm, filter, stride, outpad, dilation, output_shape, qinfo): + assert(len(outpad) == 2) + result_tens = OutputShaper.transposeConv2DOp(self.ser, ifm, output_shape) + + attr = ts.TosaSerializerAttribute() + attr.TransposeConv2DAttribute(outpad, stride, dilation, output_shape) + + ifm.addFormat(Format.NHWC) + # Update the filter ordering + filter.addUsage(Usage.WEIGHT) + filter.addFormat(Format.OHWI) + + # Create bias here since the acc_t depends on (but isn't the same as) the input dtype + # The bias is OC + if ifm.dtype == DType.AINT8 or ifm.dtype == DType.INT8: + bias_type = DType.INT32 + elif ifm.dtype == DType.INT16: + bias_type = DType.INT48 + elif ifm.dtype == DType.FLOAT: + bias_type = DType.FLOAT + else: + raise Exception('Unsupported dtype for transpose_conv2d: {}'.format(ifm.dtype)) + + bias_arr = self.getRandTensor([filter.shape[0]], bias_type) + bias_tens = self.ser.addConst([filter.shape[0]], bias_type, [], [], bias_arr) + + self.ser.addOperator(op, [ifm.name, filter.name, bias_tens.name], [result_tens.name], attr, qinfo) + return result_tens + + def build_depthwise_conv2d(self, op, ifm, filter, bias, strides, padding, dilations, qinfo): + result_tens = OutputShaper.depthwiseConv2dOp(self.ser, ifm, filter, strides, padding, dilations) + + attr = ts.TosaSerializerAttribute() + attr.Conv2dAttribute(padding, strides, dilations) + + ifm.addFormat(Format.NHWC) + filter.addUsage(Usage.WEIGHT) + filter.addFormat(Format.HWIM) + + self.ser.addOperator(op, [ifm.name, filter.name, bias.name], [result_tens.name], attr, qinfo) + return result_tens + + def build_fully_connected(self, op, ifm, filter, bias, qinfo): + result_tens = OutputShaper.fullyConnectedOp(self.ser, ifm, filter) + + filter.addUsage(Usage.WEIGHT) + self.ser.addOperator(op, [ifm.name, filter.name, bias.name], [result_tens.name], None, qinfo) + return result_tens + + def build_matmul(self, op, a, b, qinfo): + result_tens = OutputShaper.matmulOp(self.ser, a, b) + self.ser.addOperator(op, [a.name, b.name], [result_tens.name], None, qinfo) + return result_tens + + def build_reduce(self, op, a, axis): + result_tens = OutputShaper.reduceOp(self.ser, a, axis) + + attr = ts.TosaSerializerAttribute() + attr.AxisAttribute(axis) + + self.ser.addOperator(op, [a.name], result_tens.name, attr) + return result_tens + + def build_clamp(self, op, a): + result_tens = OutputShaper.unaryOp(self.ser, a) + + attr = ts.TosaSerializerAttribute() + + # Get two random ints + v = [self.randInt(), self.randInt()] + + if a.dtype == DType.FLOAT: + attr.ClampAttribute(0, 0, min(v), max(v)) + else: + attr.ClampAttribute(min(v), max(v), 0, 0) + + self.ser.addOperator(op, [a.name], [result_tens.name], attr) + return result_tens + + def build_leaky_relu(self, op, a): + result_tens = OutputShaper.unaryOp(self.ser, a) + attr = ts.TosaSerializerAttribute() + + attr.LeakyReluAttribute(self.getRandNumberDType(DType.FLOAT)) + + self.ser.addOperator(op, [a.name], [result_tens.name], attr) + return result_tens + + # Needs an additional type/input + def build_prelu(self, op, a): + result_tens = OutputShaper.unaryOp(self.ser, a) + + self.ser.addOperator(op, [a.name], [result_tens.name]) + return result_tens + + def build_relun(self, op, a): + result_tens = OutputShaper.unaryOp(self.ser, a) + + attr = ts.TosaSerializerAttribute() + + if a.dtype == DType.FLOAT: + attr.ReluNAttribute(0, self.getRandNumberDType(a.dtype)) + else: + attr.ReluNAttribute(self.getRandNumberDType(a.dtype), 0) + + self.ser.addOperator(op, [a.name], [result_tens.name], attr) + return result_tens + + def build_sigmoid(self, op, a): + result_tens = OutputShaper.unaryOp(self.ser, a) + self.ser.addOperator(op, [a.name], [result_tens.name]) + return result_tens + + def build_tanh(self, op, a): + result_tens = OutputShaper.unaryOp(self.ser, a) + self.ser.addOperator(op, [a.name], [result_tens.name]) + return result_tens + + def build_concat(self, op, a, b, axis): + result_tens = OutputShaper.concatOp(self.ser, a, b, axis) + + attr = ts.TosaSerializerAttribute() + attr.AxisAttribute(axis) + + self.ser.addOperator(op, [a.name, b.name], [result_tens.name], attr) + + def build_pad(self, op, a, padding, qinfo): + result_tens = OutputShaper.padOp(self.ser, a, padding) + + # Need to turn the padding array into a TOSA tensor here. + # This is one of the few tensor operands that does not get + # randomly generated + padding_tens = self.ser.addConst(padding.shape, DType.INT32, [], [], padding) + + self.ser.addOperator(op, [a.name, padding_tens.name], [result_tens.name], None, qinfo) + + def build_reshape(self, op, a, newShape): + result_tens = OutputShaper.reshapeOp(self.ser, a, newShape) + + attr = ts.TosaSerializerAttribute() + attr.ReshapeAttribute(newShape) + + self.ser.addOperator(op, [a.name], [result_tens.name], attr) + return result_tens + + def build_reverse(self, op, a, axis): + result_tens = OutputShaper.unaryOp(self.ser, a) + + attr = ts.TosaSerializerAttribute() + attr.AxisAttribute(axis) + + self.ser.addOperator(op, [a.name], [result_tens.name], attr) + return result_tens + + def build_transpose(self, op, a, perms): + result_tens = OutputShaper.transposeOp(self.ser, a, perms) + + perms_tens = self.ser.addConst([len(perms)], DType.INT32, Usage.ACTIVATION, [], np.int32(perms)) + + self.ser.addOperator(op, [a.name, perms_tens.name], [result_tens.name]) + return result_tens + + def build_slice(self, op, a, begin, size): + result_tens = OutputShaper.sliceOp(self.ser, a, begin, size) + + attr = ts.TosaSerializerAttribute() + attr.SliceAttribute(begin, size) + + self.ser.addOperator(op, [a.name], [result_tens.name], attr) + return result_tens + + def build_tile(self, op, a, multiples): + result_tens = OutputShaper.tileOp(self.ser, a, multiples) + + attr = ts.TosaSerializerAttribute() + attr.TileAttribute(multiples) + + self.ser.addOperator(op, [a.name], [result_tens.name], attr) + return result_tens + + + def build_gather(self, op, values, axis): + + # Create a new indicies tensor + # here with data that doesn't exceed the dimensions of the values tensor + + max_val = values.shape[axis] + indicies_arr = np.int32(self.rng.integers(low=0, high=max_val, size=[self.randInt(1, max_val + 1)])) + indicies = self.ser.addConst(indicies_arr.shape, DType.INT32, Usage.INDEX, [], indicies_arr) + + result_tens = OutputShaper.gatherOp(self.ser, values, indicies, axis) + + attr = ts.TosaSerializerAttribute() + attr.AxisAttribute(axis) + + self.ser.addOperator(op, [values.name, indicies.name], [result_tens.name], attr) + + return result_tens + + def build_resize(self, op, input, mode, stride, offset, shift, output_dims, output_dtype): + result_tens = OutputShaper.resizeOp(self.ser, input, mode, stride, offset, shift, output_dims, output_dtype) + + attr = ts.TosaSerializerAttribute() + attr.ResizeAttribute(output_dims, stride, offset, shift, mode) + + self.ser.addOperator(op, [input.name], [result_tens.name], attr) + return result_tens + + def build_identityn(self, op, val, val2): + + result_tens = OutputShaper.unaryOp(self.ser, val) + result_tens2 = OutputShaper.unaryOp(self.ser, val2) + self.ser.addOperator(op, [val.name, val2.name], [result_tens.name, result_tens2.name]) + return result_tens + + def build_placeholder(self, op, val): + # Add an identity op to avoid warning in the reference model + return self.build_unary(Op.IDENTITY, val) + + # Type Conversion + def build_cast(self, op, val, out_dtype): + result_tens = OutputShaper.typeConversionOp(self.ser, val, out_dtype) + self.ser.addOperator(op, [val.name], [result_tens.name]) + return result_tens + + def build_rescale(self, op, val, out_dtype, scale32, double_round, per_channel): + result_tens = OutputShaper.typeConversionOp(self.ser, val, out_dtype) + + if per_channel: + nc = val.shape[-1] + else: + nc = 1 + + in_type_width = self.typeWidth(val.dtype) + out_type_width = self.typeWidth(out_dtype) + + if val.dtype == DType.AINT8: + input_zp = self.randInt() + in_type_width = in_type_width + 1 + else: + input_zp = 0 + + if out_dtype == DType.AINT8: + output_zp = self.randInt() + out_type_width = out_type_width + 1 + else: + output_zp = 0 + + # Calculate scale based on: + # scale = a *(2^output_width)/(2^input_width)) + + a = np.float32(self.rng.random(size=[nc])) + scale_arr = a * np.float32((1 << out_type_width) / (1 << in_type_width)) + + if scale32: + pass + # Cap the scaling at 2^15 - 1 for scale16 + scale_arr = np.clip(scale_arr, 1.0 / (1 << 31), (1 << 31) - 1) + else: + # Cap the scaling at 2^15 - 1 for scale16 + scale_arr = np.clip(scale_arr, 1.0 / (1 << 31), 32767.0) + + #print('{} {} -> {}'.format(out_type_width, in_type_width, scale_arr)) + + multiplier_arr = np.int32(np.zeros(shape=[nc])) + shift_arr = np.int32(np.zeros(shape=[nc])) + + for i in range(nc): + multiplier_arr[i], shift_arr[i] = TosaQuantGen.computeMultiplierAndShift(scale_arr[i], scale32) + + #print('multiplier {} shift {} inzp {} outzp {}'.format(multiplier_arr, shift_arr, input_zp, output_zp)) + + attr = ts.TosaSerializerAttribute() + attr.RescaleAttribute(input_zp, + output_zp, + multiplier_arr, + shift_arr, + scale32, + double_round, + + per_channel) + + self.ser.addOperator(op, [val.name], [result_tens.name], attr) + return result_tens + + def build_cond_if_const(self, op, then_tens, else_tens, cond): + # For cond_if with constants, we're supplied with then/else tensors that we ignore + # (except for the generated shap) and the condition. Build Then/Else blocks + # and fill them with const nodes for the body. + + # Condition tensor + cond_tens = self.ser.addConst([], DType.BOOL, Usage.ACTIVATION, [], [cond]) + + # Make then/else tensors + out_shape = then_tens.shape + then_arr = np.int32(self.rng.integers(0, 255, size=out_shape)) + else_arr = np.int32(self.rng.integers(0, 255, size=out_shape)) + + # And the result tensor based on any of the outputs + result_tens = self.ser.addOutput(out_shape, DType.INT32, Usage.ACTIVATION, []) + + # Create the attribute with the names of the then/else blocks + then_block = 'THEN_BLOCK' + else_block = 'ELSE_BLOCK' + attr = ts.TosaSerializerAttribute() + attr.CondIfAttribute(then_block, else_block) + + # Finally, build the op and the two blocks + self.ser.addOperator(op, [cond_tens.name], [result_tens.name], attr) + + self.ser.startBasicBlock(then_block) + # Build the actual then/else tensors inside their blocks + then_tens = self.ser.addConst(out_shape, DType.INT32, Usage.ACTIVATION, [], then_arr) + self.ser.addOutputTensor(then_tens) + + self.ser.startBasicBlock(else_block) + else_tens = self.ser.addConst(out_shape, DType.INT32, Usage.ACTIVATION, [], else_arr) + self.ser.addOutputTensor(else_tens) + + return result_tens + + def build_cond_if_binary(self, op, a, b, cond): + # For cond_if with a binary op in the then/else blocks, take a and b and + # alternately add or subtract them based on the condition + + # Condition tensor + cond_tens = self.ser.addConst([], DType.BOOL, Usage.ACTIVATION, [], [cond]) + + result_tens = self.ser.addOutput(a.shape, a.dtype, Usage.ACTIVATION, []) + self.ser.currBasicBlock.addOutput(result_tens.name) + + # Create the attribute with the names of the then/else blocks + then_block = 'THEN_BLOCK' + else_block = 'ELSE_BLOCK' + attr = ts.TosaSerializerAttribute() + attr.CondIfAttribute(then_block, else_block) + + # Finally, build the op and the two blocks + self.ser.addOperator(op, [cond_tens.name, a.name, b.name], [result_tens.name], attr) + + self.ser.startBasicBlock(then_block) + self.ser.addInputTensor(a) + self.ser.addInputTensor(b) + then_tens = self.ser.addOutput(a.shape, a.dtype, a.usage, a.dformat) + self.ser.addOperator(Op.ADD, [a.name, b.name], [then_tens.name]) + + self.ser.startBasicBlock(else_block) + self.ser.addInputTensor(a) + self.ser.addInputTensor(b) + else_tens = self.ser.addOutput(a.shape, a.dtype, a.usage, a.dformat) + self.ser.addOperator(Op.SUB, [a.name, b.name], [else_tens.name]) + + return result_tens + + def build_while_loop(self, op, a, iter_val): + iter = self.ser.addPlaceholder([], DType.INT32, Usage.ACTIVATION, [], [np.int32(iter_val)]) + + cond_block = 'COND_BLOCK' + body_block = 'BODY_BLOCK' + + attr = ts.TosaSerializerAttribute() + attr.WhileLoopAttribute(cond_block, body_block) + + # Accumulator tensor + #acc = self.ser.addOutput(a.shape, a.dtype, a.usage, a.dformat) + acc_init_val = np.int32(np.zeros(a.shape)) + acc = self.ser.addPlaceholder(a.shape, a.dtype, a.usage, a.dformat, acc_init_val) + + # Intermediate/output tensors for everything going through the loop + iter_out = self.ser.addIntermediate(iter.shape, iter.dtype, iter.usage, iter.dformat) + a_out = self.ser.addIntermediate(a.shape, a.dtype, a.usage, a.dformat) + acc_out = self.ser.addIntermediate(acc.shape, acc.dtype, acc.usage, acc.dformat) + + # While_loop operator + self.ser.addOperator(op, + [iter.name, a.name, acc.name], + [iter_out.name, a_out.name, acc_out.name], attr) + + # COND block (input: iter, output: cond_tens ) + self.ser.startBasicBlock(cond_block) + self.ser.addInputTensor(iter) + self.ser.addInputTensor(a) + self.ser.addInputTensor(acc) + zero_tens = self.ser.addConst([], DType.INT32, [], [], [np.int32(0)]) + cond_tens = self.ser.addOutput([], DType.BOOL, [], []) + self.ser.addOperator(Op.GREATER, [iter.name, zero_tens.name], + [cond_tens.name]) + + # BODY block (input: a, acc, iter, output: a, acc, iter) + # Note that local intermediate tensors need to be declared here for the outputs + self.ser.startBasicBlock(body_block) + self.ser.addInputTensor(iter) + self.ser.addInputTensor(a) + self.ser.addInputTensor(acc) + one_tens = self.ser.addConst([], DType.INT32, [], [], [np.int32(1)]) + iter_body_out = self.ser.addIntermediate(iter.shape, iter.dtype, iter.usage, iter.dformat) + acc_body_out = self.ser.addIntermediate(acc.shape, acc.dtype, acc.usage, acc.dformat) + self.ser.addOperator(Op.ADD, [a.name, acc.name], [acc_body_out.name]) + self.ser.addOperator(Op.SUB, [iter.name, one_tens.name], [iter_body_out.name]) + self.ser.addOutputTensor(iter_body_out) + self.ser.addOutputTensor(a) + self.ser.addOutputTensor(acc_body_out) + + return acc_out + + + def genOpTestList(self, opName, shapeFilter=[None], rankFilter=None, dtypeFilter=None): + + try: + op = self.TOSA_OP_LIST[opName] + except KeyError as e: + raise Exception('Cannot find op with name {}'.format(opName)) + + # Initialize a new random number generator + self.rng = np.random.default_rng(self.random_seed) + + build_fcn, tgen_fcn, agen_fcn = op['build_fcn'] + + # Generate the lists of arguments + rmin, rmax = op['rank'] + + # Test list consists of a tuple of: + # (opName, testNameStr, dtype, shapeList, argumentsList) + testList = [] + + if not shapeFilter: + shapeFilter = [None] + + for r in range(rmin, rmax + 1): + + # Filter out the rank? + if rankFilter is not None and r not in rankFilter: + continue + + for t in op['types']: + + # Filter tests based on dtype? + if dtypeFilter is not None: + if t not in dtypeFilter: + continue + + # Create the placeholder and const tensors + for shape in shapeFilter: + # A None shape chooses a random shape of a given rank + + # Filter out by rank + if shape is not None and len(shape) != r: + continue + + self.setTargetShape(shape) + shapeList = tgen_fcn(self, op, r) + + shapeStr = self.shapeStr(shapeList[0]) + typeStr = self.typeStr(t) + + # Argument lists consists of tuples of the (str, []) string representation and the build function argument list + argList = [] + if agen_fcn: + argList = agen_fcn(self, opName, shapeList, t) + else: + argList = [('', [])] + + for argStr, args in argList: + if argStr: + testStr = '{}_{}_{}_{}'.format(opName, shapeStr, typeStr, argStr) + else: + testStr = '{}_{}_{}'.format(opName, shapeStr, typeStr) + + testList.append((opName, testStr, t, shapeList, args)) + + return testList + + def serializeTest(self, opName, testStr, dtype, shapeList, testArgs): + try: + op = self.TOSA_OP_LIST[opName] + except KeyError as e: + raise Exception('Cannot find op with name {}'.format(opName)) + + # Create a serializer + self.createSerializer(opName, testStr) + + build_fcn, tgen_fcn, agen_fcn = op['build_fcn'] + pCount, cCount = op['operands'] + + try: + qgen = op['qgen'] + except KeyError: + qgen = None + + # Build the random tensor operands and the test + tens = [] + tens.extend(self.buildPlaceholderTensors(shapeList[0:pCount], dtype)) + tens.extend(self.buildConstTensors(shapeList[pCount:], dtype)) + + if qgen is not None: + qinfo = qgen(self, op, dtype) + else: + qinfo = None + + try: + if qinfo is not None: + resultName = build_fcn(self, op['op'], *tens, *testArgs, qinfo) + else: + resultName = build_fcn(self, op['op'], *tens, *testArgs) + except TypeError as e: + print('build_fcn: {}\nTensors: {}\nArgs: {}\n'.format(build_fcn, tens, testArgs)) + raise e + + # Save the serialized test + self.serialize('test') + + def createDynamicOpLists(self): + + # Dynamically create op lists for convolutions with a list of kernel sizes + KERNELS = [ [1, 1], [2, 2], [3, 3], [5, 5], [3, 1], [1, 3] ] + + for k in KERNELS: + testName = 'conv2d_{}x{}'.format(k[0], k[1]) + self.TOSA_OP_LIST[testName] = self.TOSA_OP_LIST['conv2d_TEMPLATE'].copy() + self.TOSA_OP_LIST[testName]['filter'] = k + self.TOSA_OP_LIST[testName]['template'] = False + + testName = 'depthwise_conv2d_{}x{}'.format(k[0], k[1]) + self.TOSA_OP_LIST[testName] = self.TOSA_OP_LIST['depthwise_conv2d_TEMPLATE'].copy() + self.TOSA_OP_LIST[testName]['filter'] = k + self.TOSA_OP_LIST[testName]['template'] = False + + testName = 'transpose_conv2d_{}x{}'.format(k[0], k[1]) + self.TOSA_OP_LIST[testName] = self.TOSA_OP_LIST['transpose_conv2d_TEMPLATE'].copy() + self.TOSA_OP_LIST[testName]['filter'] = k + self.TOSA_OP_LIST[testName]['template'] = False + + # Delete any templates after having created any dynamic ops + # This is a two-pass operation because it's bad practice to delete + # keys from dictionaries while iterating + keyList = [] + for k in self.TOSA_OP_LIST: + try: + if self.TOSA_OP_LIST[k]['template'] == True: + keyList.append(k) + continue + except KeyError: + pass + + for k in keyList: + del self.TOSA_OP_LIST[k] + + def initOpListDefaults(self): + '''Fill in default fields for ops if they aren't already specified. + Look for missing required fields (datastructure linting).''' + for op in self.TOSA_OP_LIST: + + # Required fields + try: + pl, c = self.TOSA_OP_LIST[op]['operands'] + except (KeyError, ValueError, TypeError): + raise Exception('Op {} is missing a valid operand tuple in TOSA_OP_LIST'.format(op)) + + try: + fcn, tgen, arggen = self.TOSA_OP_LIST[op]['build_fcn'] + except (KeyError, ValueError, TypeError): + raise Exception('Op {} is missing a valid build_fcn tuple in TOSA_OP_LIST'.format(op)) + + try: + types = self.TOSA_OP_LIST[op]['types'] + except KeyError as e: + raise Exception('Op {} is missing a valid type list in TOSA_OP_LIST'.format(op)) + + try: + opcode = self.TOSA_OP_LIST[op]['op'] + except KeyError as e: + raise Exception('Op {} is missing the Op field in TOSA_OP_LIST'.format(op)) + + # Put in default rank range, if missing + try: + rank = self.TOSA_OP_LIST[op]['rank'] + except KeyError: + self.TOSA_OP_LIST[op]['rank'] = self.DEFAULT_RANK_RANGE + + # Tensor operator list + # 'op': op name + # 'operands': tuple of (placeholder, const) operands + # 'rank': optional, restricts rank to tuple inclusive of (min, max), if not specified, defaults to (1, 4) + # 'build_fcn': tuple of the function to (build_operator(), TensorGen function, ArgGen enum) + # 'types': array of datatypes to be tested + TYPE_FP = [ DType.FLOAT ] + + # Type with an aint8 + TYPE_INT = [ DType.AINT8, DType.INT16, DType.INT32 ] # Most operators support AINT8 instead of INT8, excludes INT4 + TYPE_INT_FP = [ DType.AINT8, DType.INT16, DType.INT32, DType.FLOAT ] # Most operators support AINT8 instead of INT8, excludes INT4 + + # Types with an int8 + TYPE_PURE_INT = [ DType.INT8, DType.INT16, DType.INT32 ] # Note: excludes INT4 + TYPE_PURE_INT_FP = [ DType.INT8, DType.INT16, DType.INT32, DType.FLOAT ] # Note: excludes INT4 + TYPE_BOOL = [ DType.BOOL ] + TYPE_FI32 = [ DType.FLOAT, DType.INT32 ] + TYPE_FIB = [ DType.FLOAT, DType.AINT8, DType.INT8, DType.INT16, DType.INT32, DType.BOOL ] + TYPE_FI16 = [ DType.FLOAT, DType.INT16 ] + + TYPE_NARROW_INT_FP = [ DType.AINT8, DType.INT16, DType.FLOAT ] + + DEFAULT_RANK_RANGE = (1, 4) + + TOSA_OP_LIST = { + # Binary ops + 'add': + { 'op': Op.ADD, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_FI32 }, + + 'arithmetic_right_shift': + { 'op': Op.ARITHMETIC_RIGHT_SHIFT, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_PURE_INT }, + + 'bitwise_and': + { 'op': Op.BITWISE_AND, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_INT }, + + 'bitwise_or': + { 'op': Op.BITWISE_OR, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_INT }, + + 'bitwise_xor': + { 'op': Op.BITWISE_XOR, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_INT }, + + 'logical_and': + { 'op': Op.LOGICAL_AND, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_BOOL }, + + 'logical_left_shift': + { 'op': Op.LOGICAL_LEFT_SHIFT, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_PURE_INT }, + + 'logical_right_shift': + { 'op': Op.LOGICAL_RIGHT_SHIFT, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_PURE_INT }, + + 'logical_or': + { 'op': Op.LOGICAL_OR, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_BOOL }, + + 'logical_xor': + { 'op': Op.LOGICAL_XOR, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_BOOL }, + + 'max': + { 'op': Op.MAXIMUM, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_FI32 }, + + 'min': + { 'op': Op.MINIMUM, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_FI32 }, + + 'mul': + { 'op': Op.MUL, + 'operands': (2, 0), + 'build_fcn': (build_mul, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_PURE_INT_FP }, + + 'pow': + { 'op': Op.POW, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + 'sub': + { 'op': Op.SUB, + 'operands': (2, 0), + 'build_fcn': (build_binary_broadcast, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_FI32 }, + + 'table': + { 'op': Op.TABLE, + # Use the automatic generation functions to create the input array + # but create the table tensor in the build function, as it may be + # a different type from the input + 'operands': (1, 0), + 'build_fcn': (build_table, TosaTensorGen.tgBasic, None), + 'types': [ DType.INT16 ] }, + + 'argmax': + { 'op': Op.ARGMAX, + 'operands': (1, 0), + 'build_fcn': (build_argmax, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_FP }, + + # Templated operator. Filled in by createDynamicOpLists + 'conv2d_TEMPLATE': + { 'op': Op.CONV2D, + 'operands': (1, 2), + 'rank': (4, 4), + 'build_fcn': (build_conv2d, TosaTensorGen.tgConv2D, TosaArgGen.agConv2D), + 'qgen': TosaQuantGen.qgConv, + 'types': TYPE_FP, + 'template': True }, + + # Templated operator. Filled in by createDynamicOpLists + 'depthwise_conv2d_TEMPLATE': + { 'op': Op.DEPTHWISE_CONV2D, + 'operands': (1, 2), + 'filter': [1, 1], + 'rank': (4, 4), + 'build_fcn': (build_depthwise_conv2d, TosaTensorGen.tgDepthwiseConv2D, TosaArgGen.agConv2D), + 'qgen': TosaQuantGen.qgConv, + 'types': TYPE_FP, + 'template': True }, + + # Templated operator. Filled in by createDynamicOpLists + 'transpose_conv2d_TEMPLATE': + { 'op': Op.TRANSPOSE_CONV2D, + 'operands': (1, 1), + 'rank': (4, 4), + 'build_fcn': (build_transpose_conv2d, TosaTensorGen.tgTransposeConv2D, TosaArgGen.agTransposeConv2D), + 'qgen': TosaQuantGen.qgConv, + 'types': TYPE_FP, + 'template': True }, + + 'fully_connected': + { 'op': Op.FULLY_CONNECTED, + 'operands': (2, 0), + 'rank': (2, 2), + 'build_fcn': (build_fully_connected, TosaTensorGen.tgFullyConnected, None), + 'qgen': TosaQuantGen.qgConv, + 'types': TYPE_FP }, + + 'matmul': + { 'op': Op.MATMUL, + 'operands': (2, 0), + 'rank': (2, 2), + 'build_fcn': (build_matmul, TosaTensorGen.tgMatmul, None), + 'qgen': TosaQuantGen.qgMatmul, + 'types': TYPE_NARROW_INT_FP }, + + # Unary operators + 'abs': + { 'op': Op.ABS, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_FI32 }, + + 'bitwise_not': + { 'op': Op.BITWISE_NOT, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_INT }, + + 'ceil': + { 'op': Op.CEIL, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + 'clz': + { 'op': Op.CLZ, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': [ DType.INT32 ] }, + + 'exp': + { 'op': Op.EXP, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + 'floor': + { 'op': Op.FLOOR, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + 'log': + { 'op': Op.LOG, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + 'floor': + { 'op': Op.FLOOR, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + 'logical_not': + { 'op': Op.LOGICAL_NOT, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_BOOL }, + + 'negate': + { 'op': Op.NEGATE, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'qgen': TosaQuantGen.qgUnary, + 'types': TYPE_INT_FP }, + + 'reciprocal': + { 'op': Op.RECIPROCAL, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + 'rsqrt': + { 'op': Op.RSQRT, + 'operands': (1, 0), + 'build_fcn': (build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + # Ternary operators + 'select': + { 'op': Op.SELECT, + 'operands': (3, 0), + 'build_fcn': (build_select, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_FIB }, + + # Comparison operators + 'equal': + { 'op': Op.EQUAL, + 'operands': (2, 0), + 'build_fcn': (build_comparison, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_FI32 }, + + 'greater_equal': + { 'op': Op.GREATER_EQUAL, + 'operands': (2, 0), + 'build_fcn': (build_comparison, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_FI32 }, + + 'greater': + { 'op': Op.GREATER, + 'operands': (2, 0), + 'build_fcn': (build_comparison, TosaTensorGen.tgBroadcastFuzz, None), + 'types': TYPE_FI32 }, + + # Pooling operators + 'avg_pool2d': + { 'op': Op.AVG_POOL2D, + 'operands': (1, 0), + 'rank': (4, 4), + 'build_fcn': (build_pool2d, TosaTensorGen.tgNHWC, TosaArgGen.agPooling), + 'qgen': TosaQuantGen.qgUnary, + 'types': TYPE_NARROW_INT_FP }, + + + 'max_pool2d': + { 'op': Op.MAX_POOL2D, + 'operands': (1, 0), + 'rank': (4, 4), + 'build_fcn': (build_pool2d, TosaTensorGen.tgNHWC, TosaArgGen.agPooling), + 'types': TYPE_NARROW_INT_FP }, + + # Reduce operators + 'reduce_any': + { 'op': Op.REDUCE_ANY, + 'operands': (1, 0), + 'build_fcn': (build_reduce, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_BOOL }, + + 'reduce_all': + { 'op': Op.REDUCE_ALL, + 'operands': (1, 0), + 'build_fcn': (build_reduce, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_BOOL }, + + 'reduce_max': + { 'op': Op.REDUCE_MAX, + 'operands': (1, 0), + 'build_fcn': (build_reduce, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_INT_FP }, + + 'reduce_min': + { 'op': Op.REDUCE_MAX, + 'operands': (1, 0), + 'build_fcn': (build_reduce, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_INT_FP }, + + 'reduce_product': + { 'op': Op.REDUCE_PRODUCT, + 'operands': (1, 0), + 'build_fcn': (build_reduce, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_FP }, + + 'reduce_sum': + { 'op': Op.REDUCE_SUM, + 'operands': (1, 0), + 'build_fcn': (build_reduce, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_FI32 }, + + # Activation functions + 'clamp': + { 'op': Op.CLAMP, + 'operands': (1, 0), + 'build_fcn': (build_clamp, TosaTensorGen.tgBasic, None), + 'types': TYPE_NARROW_INT_FP }, + + 'relun': + { 'op': Op.RELUN, + 'operands': (1, 0), + 'build_fcn': (build_relun, TosaTensorGen.tgBasic, None), + 'types': TYPE_FI32 }, + + 'sigmoid': + { 'op': Op.SIGMOID, + 'operands': (1, 0), + 'build_fcn': (build_sigmoid, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + 'tanh': + { 'op': Op.TANH, + 'operands': (1, 0), + 'build_fcn': (build_tanh, TosaTensorGen.tgBasic, None), + 'types': TYPE_FP }, + + # Data layout operators + 'concat': + { 'op': Op.CONCAT, + 'operands': (2, 0), + 'build_fcn': (build_concat, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_FIB }, + + 'pad': + { 'op': Op.PAD, + 'operands': (1, 0), + 'build_fcn': (build_pad, TosaTensorGen.tgBasic, TosaArgGen.agPad), + 'qgen': TosaQuantGen.qgPad, + 'types': TYPE_FIB }, + + 'reshape': + { 'op': Op.RESHAPE, + 'operands': (1, 0), + 'build_fcn': (build_reshape, TosaTensorGen.tgBasic, TosaArgGen.agReshape), + 'types': TYPE_FIB }, + + 'reverse': + { 'op': Op.REVERSE, + 'operands': (1, 0), + 'build_fcn': (build_reverse, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_FIB }, + + 'slice': + { 'op': Op.SLICE, + 'operands': (1, 0), + 'build_fcn': (build_slice, TosaTensorGen.tgBasic, TosaArgGen.agSlice), + 'types': TYPE_FIB }, + + 'tile': + { 'op': Op.TILE, + 'operands': (1, 0), + 'build_fcn': (build_tile, TosaTensorGen.tgBasic, TosaArgGen.agTile), + 'types': TYPE_FIB }, + + 'transpose': + { 'op': Op.TRANSPOSE, + 'operands': (1, 0), + 'rank': (2, 4), # Do not allow tranpose on rank=1 + 'build_fcn': (build_transpose, TosaTensorGen.tgBasic, TosaArgGen.agTranspose), + 'types': TYPE_FIB }, + + # Scatter/Gather + 'gather': + { 'op': Op.GATHER, + 'operands': (1, 0), + 'build_fcn': (build_gather, TosaTensorGen.tgBasic, TosaArgGen.agAxis), + 'types': TYPE_INT }, + + + # Image operations + 'resize': + { 'op': Op.RESIZE, + 'operands': (1, 0), + 'rank': (4, 4), + 'build_fcn': ( build_resize, TosaTensorGen.tgNHWC, TosaArgGen.agResize), + 'types': [ DType.INT8, DType.INT16 ] }, + + + # Data nodes + 'placeholder': + { 'op': Op.PLACEHOLDER, + 'operands': (1, 0), + 'build_fcn': ( build_placeholder, TosaTensorGen.tgBasic, None), + 'types': TYPE_FIB }, + + 'const': + { 'op': Op.CONST, + 'operands': (1, 0), + 'build_fcn': ( build_placeholder, TosaTensorGen.tgBasic, None), + 'types': TYPE_FIB }, + + + 'identity': + { 'op': Op.IDENTITY, + 'operands': (1, 0), + 'build_fcn': ( build_unary, TosaTensorGen.tgBasic, None), + 'types': TYPE_FIB }, + + + 'identityn': + { 'op': Op.IDENTITYN, + 'operands': (2, 0), + 'build_fcn': ( build_identityn, TosaTensorGen.tgBasic, None), + 'types': TYPE_FIB }, + + # Type conversion + 'cast': + { 'op': Op.CAST, + 'operands': (1, 0), + 'build_fcn': ( build_cast, TosaTensorGen.tgBasic, TosaArgGen.agCast ), + 'types': [ DType.FLOAT, DType.INT8, DType.INT16, DType.INT32, DType.BOOL ] }, + + 'rescale': + { 'op': Op.RESCALE, + 'operands': (1, 0), + 'build_fcn': ( build_rescale, TosaTensorGen.tgBasic, TosaArgGen.agRescale ), + 'types': [ DType.AINT8, DType.INT16, DType.INT32, DType.INT48 ] }, + + # Custom + # Not implemented. + + # Control flow + + # Two varients of cond_if, one that generates one of two constant tensors (no + # inputs to the basic blocks, one output) and another that either adds or subtracts two tensors + # (two inputs to the basic blocks, one output) + 'cond_if_const': + { 'op': Op.COND_IF, + 'operands': (0, 2), + 'build_fcn': ( build_cond_if_const, TosaTensorGen.tgBasic, TosaArgGen.agCondIf ), + 'types': [ DType.BOOL ] }, + + 'cond_if_binary': + { 'op': Op.COND_IF, + 'operands': (2, 0), + 'build_fcn': ( build_cond_if_binary, TosaTensorGen.tgBasic, TosaArgGen.agCondIf ), + 'types': TYPE_FI32 }, + + # while_loop + 'while_loop': + { 'op': Op.WHILE_LOOP, + 'operands': (0, 1), + 'build_fcn': ( build_while_loop, TosaTensorGen.tgBasic, TosaArgGen.agWhileLoop ), + 'types': [DType.INT32] }, + + + } + +class OutputShaper: + # Methods in this class compute the expected output shape and datatype + # for common classes of operations + def __init__(self): + pass + + # These methods return arguments that can be used for + # creating a new output tensor + @staticmethod + def binaryBroadcastOp(ser, a, b): + assert(len(a.shape) == len(b.shape)) + assert(a.dtype == b.dtype) + + shape = [] + for i in range(len(a.shape)): + if a.shape[i] == 1: + shape.append(b.shape[i]) + else: + shape.append(a.shape[i]) + + return ser.addOutput(shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def binaryNonBroadcastOp(ser, a, b): + assert(len(a.shape) == len(b.shape)) + assert(a.dtype == b.dtype) + + shape = [] + for i in range(len(a.shape)): + assert(a.shape[i] == b.shape[i]) + shape.append(a.shape[i]) + + return ser.addOutput(shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def unaryOp(ser, a): + return ser.addOutput(a.shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def selectOp(ser, cond, a, b): + assert(len(a.shape) == len(b.shape) and len(a.shape) == len(cond.shape)) + assert(a.dtype == b.dtype) + + shape = [] + for i in range(len(a.shape)): + shape.append(max(cond.shape[i], a.shape[i], b.shape[i])) + + return ser.addOutput(shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def binaryComparisonOp(ser, a, b): + assert(len(a.shape) == len(b.shape)) + assert(a.dtype == b.dtype) + + # Do broadcast + shape = [] + for i in range(len(a.shape)): + if a.shape[i] == 1: + shape.append(b.shape[i]) + else: + shape.append(a.shape[i]) + + # Force the output type to bool + return ser.addOutput(shape, DType.BOOL, a.usage, a.dformat) + + @staticmethod + def reduceOp(ser, a, axis): + + shape = a.shape.copy() + + shape[axis] = 1 + + return ser.addOutput(shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def argmaxOp(ser, a, axis): + shape = a.shape.copy() + del shape[axis] + return ser.addOutput(shape, DType.INT32, a.usage, a.dformat) + + @staticmethod + def conv2dOp(ser, ifm, filter, strides, padding, dilations): + + # IFM: NHWC + # Filter: OHWI + # OFM: NHWC + + if len(padding) == 2: + # Expand padding to 4 parameters in the case of transpose_conv2d + # From H,W to T,B,L,R + padding = [padding[0], padding[0], padding[1], padding[1]] + + h = (ifm.shape[1] - filter.shape[1] - (filter.shape[1] - 1) * (dilations[0] - 1) + \ + padding[0] + padding[1]) // strides[0] + 1 + + w = (ifm.shape[2] - filter.shape[2] - (filter.shape[2] - 1) * (dilations[1] - 1) + \ + padding[2] + padding[3]) // strides[1] + 1 + + if h <= 0 or w <= 0: + # Invalid test parameters? + h = 0 + w = 0 + ser.setExpectedFailure(True, 'Invalid combination of conv2d parameters') + + ofm_shape = [ifm.shape[0], h, w, filter.shape[0]] + + if ifm.dtype == DType.AINT8 or ifm.dtype == DType.INT8: + out_dtype = DType.INT32 + elif ifm.dtype == DType.INT16: + out_dtype = DType.INT48 + elif ifm.dtype == DType.FLOAT: + out_dtype = DType.FLOAT + else: + raise Exception('Unsupported input dtype: {}'.format(ifm.dtype)) + + return ser.addOutput(ofm_shape, out_dtype, ifm.usage, ifm.dformat) + + @staticmethod + def depthwiseConv2dOp(ser, ifm, filter, strides, padding, dilations): + # IFM: NHWC + # Filter: HWCM + # OFM: NHW C*M + h = (ifm.shape[1] - filter.shape[0] - (filter.shape[0] - 1) * (dilations[0] - 1) + \ + padding[0] + padding[1]) // strides[0] + 1 + + w = (ifm.shape[2] - filter.shape[1] - (filter.shape[1] - 1) * (dilations[1] - 1) + \ + padding[2] + padding[3]) // strides[1] + 1 + + if h <= 0 or w <= 0: + # Invalid test parameters? + h = 0 + w = 0 + ser.setExpectedFailure(True, 'Invalid combination of conv2d parameters') + + ofm_shape = [ifm.shape[0], h, w, filter.shape[2] * filter.shape[3]] + + if ifm.dtype == DType.AINT8 or ifm.dtype == DType.INT8: + out_dtype = DType.INT32 + elif ifm.dtype == DType.INT16: + out_dtype = DType.INT48 + elif ifm.dtype == DType.FLOAT: + out_dtype = DType.FLOAT + else: + raise Exception('Unsupported input dtype: {}'.format(ifm.dtype)) + + return ser.addOutput(ofm_shape, out_dtype, ifm.usage, ifm.dformat) + + + @staticmethod + def pool2dOp(ser, ifm, kernel, stride, pad): + # input: NHWC + h = (ifm.shape[1] + pad[0] + pad[1] + stride[0] - kernel[0]) // stride[0] + w = (ifm.shape[2] + pad[2] + pad[3] + stride[1] - kernel[1]) // stride[1] + + if h <= 0 or w <= 0: + # Invalid test parameters? + h = 0 + w = 0 + ser.setExpectedFailure(True, 'Invalid combination of pooling parameters') + + ofm_shape = [ifm.shape[0], h, w, ifm.shape[3]] + return ser.addOutput(ofm_shape, ifm.dtype, ifm.usage, ifm.dformat) + + @staticmethod + def fullyConnectedOp(ser, input, filter): + # input: N, IC + # filter: OC, IC + # output: N, OC + + output_shape = [input.shape[0], filter.shape[0]] + + if input.dtype == DType.AINT8 or input.dtype == DType.INT8: + out_dtype = DType.INT32 + elif input.dtype == DType.INT16: + out_dtype = DType.INT48 + elif input.dtype == DType.FLOAT: + out_dtype = DType.FLOAT + else: + raise Exception('Unsupported input dtype: {}'.format(input.dtype)) + + return ser.addOutput(output_shape, out_dtype, input.usage, input.dformat) + + @staticmethod + def matmulOp(ser, a, b): + # a: M, K + # b: K, N + # out: M, N + + output_shape = [a.shape[0], b.shape[1]] + + + if a.dtype == DType.AINT8: + out_dtype = DType.INT32 + elif a.dtype == DType.INT16: + out_dtype = DType.INT48 + elif a.dtype == DType.FLOAT: + out_dtype = DType.FLOAT + else: + raise Exception('UNsupported input dtype for matmul: {}'.format(a.dtype)) + + return ser.addOutput(output_shape, out_dtype, a.usage, a.dformat) + + @staticmethod + def concatOp(ser, a, b, axis): + + output_shape = a.shape.copy() + output_shape[axis] = a.shape[axis] + b.shape[axis] + + return ser.addOutput(output_shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def padOp(ser, a, padding): + + output_shape = a.shape.copy() + + for i in range(len(output_shape)): + output_shape[i] = padding[i][0] + padding[i][1] + output_shape[i] + + return ser.addOutput(output_shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def reshapeOp(ser, a, shape): + output_shape = shape.copy() + + totalElements = 1 + for i in a.shape: + totalElements *= i + + # If there are any -1 elements, figure out what that dimension must be + totalOutputElements = 1 + for i in output_shape: + if i != -1: + totalOutputElements *= i + + # And fill it in + for i in range(len(output_shape)): + if output_shape[i] == -1: + output_shape[i] = totalElements // totalOutputElements + + return ser.addOutput(output_shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def sliceOp(ser, a, begin, size): + + output_shape = size.copy() + return ser.addOutput(output_shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def tileOp(ser, a, multiples): + + output_shape = a.shape.copy() + assert(len(multiples) == len(output_shape)) + + for i in range(len(output_shape)): + output_shape[i] = a.shape[i] * multiples[i] + + return ser.addOutput(output_shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def transposeOp(ser, a, perms): + output_shape = a.shape.copy() + assert(len(perms) == len(output_shape)) + + for i in range(len(output_shape)): + output_shape[i] = a.shape[perms[i]] + + return ser.addOutput(output_shape, a.dtype, a.usage, a.dformat) + + @staticmethod + def gatherOp(ser, values, indicies, axis): + # indicies minus the axis + values - the indexes used to look up values. + output_shape = [*values.shape[0:axis], indicies.shape[0], *values.shape[axis+1:]] + + return ser.addOutput(output_shape, values.dtype, indicies.usage, indicies.dformat) + + @staticmethod + def tableOp(ser, input, table): + # Same shape as the input, but with the type of the table. + return ser.addOutput(input.shape, DType.INT32, input.usage, input.dformat) + + @staticmethod + def resizeOp(ser, input, mode, stride, offset, shift, output_dims, output_dtype): + + output_dims = [input.shape[0], output_dims[0], output_dims[1], input.shape[3]] + + if stride[0] <= 0 or stride[1] <= 0: + ser.setExpectedFailure(True, 'Negative or zero stride') + + return ser.addOutput(output_dims, output_dtype, input.usage, input.dformat) + + @staticmethod + def typeConversionOp(ser, val, out_dtype): + return ser.addOutput(val.shape, out_dtype, val.usage, val.dformat) + + @staticmethod + def transposeConv2DOp(ser, ifm, output_shape): + if ifm.dtype == DType.AINT8 or ifm.dtype == DType.INT8: + out_dtype = DType.INT32 + elif ifm.dtype == DType.INT16: + out_dtype = DType.INT48 + elif ifm.dtype == DType.FLOAT: + out_dtype = DType.FLOAT + else: + raise Exception('Unsupported input dtype: {}'.format(ifm.dtype)) + + if output_shape[1] <= 0 or output_shape[2] <= 0: + ser.setExpectedFailure(True, 'Negative output shape') + + return ser.addOutput(output_shape, out_dtype, ifm.usage, ifm.dformat) diff --git a/verif/tosa_test_runner.py b/verif/tosa_test_runner.py new file mode 100644 index 0000000..6549192 --- /dev/null +++ b/verif/tosa_test_runner.py @@ -0,0 +1,63 @@ +import os + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import json +import shlex +import subprocess +from enum import IntEnum, unique + +def run_sh_command(args, full_cmd, capture_output=False): + '''Utility function to run an external command. Optionally return captured stdout/stderr''' + + # Quote the command line for printing + full_cmd_esc = [ shlex.quote(x) for x in full_cmd ] + + if args.verbose: + print('### Running {}'.format(' '.join(full_cmd_esc))) + + if capture_output: + rc = subprocess.run(full_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) + if rc.returncode != 0: + print(rc.stdout.decode('utf-8')) + print(rc.stderr.decode('utf-8')) + raise Exception('Error running command: {}.\n{}'.format(' '.join(full_cmd_esc), rc.stderr.decode('utf-8'))) + return (rc.stdout, rc.stderr) + else: + rc = subprocess.run(full_cmd) + if rc.returncode != 0: + raise Exception('Error running command: {}'.format(' '.join(full_cmd_esc))) + +class TosaTestRunner: + + def __init__(self, args, runnerArgs, testDir): + + self.args = args + self.runnerArgs = runnerArgs + self.testDir = testDir + + # Load the json test file + with open(os.path.join(testDir, 'desc.json'), 'r') as fd: + self.testDesc = json.load(fd) + + def runModel(self): + pass + + class Result(IntEnum): + EXPECTED_PASS = 0 + EXPECTED_FAILURE = 1 + UNEXPECTED_PASS = 2 + UNEXPECTED_FAILURE = 3 + INTERNAL_ERROR = 4 diff --git a/verif/tosa_verif_build_tests.py b/verif/tosa_verif_build_tests.py new file mode 100755 index 0000000..19eb2f4 --- /dev/null +++ b/verif/tosa_verif_build_tests.py @@ -0,0 +1,136 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import argparse +import sys +import re +import os +import subprocess +import shlex +import json +import glob +import math +import queue +import threading +import traceback + + +from enum import IntEnum, Enum, unique +from datetime import datetime + +# Include the ../shared directory in PYTHONPATH +parent_dir = os.path.dirname(os.path.realpath(__file__)) +sys.path.append(os.path.join(parent_dir, '..', 'scripts')) +sys.path.append(os.path.join(parent_dir, '..', 'scripts', 'xunit')) +import xunit +from tosa_serializer import * +from tosa_test_gen import TosaTestGen +import tosa + +# Used for parsing a comma-separated list of integers in a string +# to an actual list of integers +def str_to_list(in_s): + '''Converts a comma-separated list of string integers to a python list of ints''' + lst = in_s.split(',') + out_list = [] + for i in lst: + out_list.append(int(i)) + return out_list + +def auto_int(x): + '''Converts hex/dec argument values to an int''' + return int(x, 0) + +def parseArgs(): + + parser = argparse.ArgumentParser() + parser.add_argument('-o', dest='output_dir', type=str, default='vtest', + help='Test output directory') + + parser.add_argument('--seed', dest='random_seed', default=42, type=int, + help='Random seed for test generation') + + parser.add_argument('--filter', dest='filter', default='', type=str, + help='Filter operator test names by this expression') + + parser.add_argument('-v', '--verbose', dest='verbose', action='count', + help='Verbose operation') + + # Constraints on tests + parser.add_argument('--tensor-dim-range', dest='tensor_shape_range', default='1,64', + type=lambda x: str_to_list(x), + help='Min,Max range of tensor shapes') + + parser.add_argument('--max-batch-size', dest='max_batch_size', default=1, type=int, + help='Maximum batch size for NHWC tests') + + parser.add_argument('--max-conv-padding', dest='max_conv_padding', default=1, type=int, + help='Maximum padding for Conv tests') + + parser.add_argument('--max-conv-dilation', dest='max_conv_dilation', default=2, type=int, + help='Maximum dilation for Conv tests') + + parser.add_argument('--max-conv-stride', dest='max_conv_stride', default=2, type=int, + help='Maximum stride for Conv tests') + + parser.add_argument('--max-pooling-padding', dest='max_pooling_padding', default=1, type=int, + help='Maximum padding for pooling tests') + + parser.add_argument('--max-pooling-stride', dest='max_pooling_stride', default=2, type=int, + help='Maximum stride for pooling tests') + + parser.add_argument('--max-pooling-kernel', dest='max_pooling_kernel', default=2, type=int, + help='Maximum padding for pooling tests') + + parser.add_argument('--num-rand-permutations', dest='num_rand_permutations', default=6, type=int, + help='Number of random permutations for a given shape/rank for randomly-sampled parameter spaces') + + # Targetting a specific shape/rank/dtype + parser.add_argument('--target-shape', dest='target_shapes', action='append', default=[], type=lambda x: str_to_list(x), + help='Create tests with a particular input tensor shape, e.g., 1,4,4,8 (may be repeated for tests that require multiple input shapes)') + + parser.add_argument('--target-rank', dest='target_ranks', action='append', default=None, type=lambda x: auto_int(x), + help='Create tests with a particular input tensor rank') + + parser.add_argument('--target-dtype', dest='target_dtypes', action='append', default=None, type=lambda x: dtype_str_to_val(x), + help='Create test with a particular DType (may be repeated)') + + args = parser.parse_args() + + return args + +def main(): + + + args = parseArgs() + + ttg = TosaTestGen(args) + + testList = [] + for op in ttg.TOSA_OP_LIST: + if re.match(args.filter + '.*', op): + testList.extend(ttg.genOpTestList(op, shapeFilter=args.target_shapes, rankFilter=args.target_ranks, dtypeFilter=args.target_dtypes)) + + print('{} matching tests'.format(len(testList))) + for opName, testStr, dtype, shapeList, testArgs in testList: + print(testStr) + ttg.serializeTest(opName, testStr, dtype, shapeList, testArgs) + print('Done creating {} tests'.format(len(testList))) + + +if __name__ == '__main__': + exit(main()) diff --git a/verif/tosa_verif_run_ref.py b/verif/tosa_verif_run_ref.py new file mode 100755 index 0000000..2284e35 --- /dev/null +++ b/verif/tosa_verif_run_ref.py @@ -0,0 +1,198 @@ +#!/usr/bin/env python3 + +# Copyright (c) 2020, ARM Limited. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +import argparse +import sys +import re +import os +import subprocess +import shlex +import json +import glob +import math +import queue +import threading +import traceback +import importlib + + +from enum import IntEnum, Enum, unique +from datetime import datetime + +# Include the ../shared directory in PYTHONPATH +parent_dir = os.path.dirname(os.path.realpath(__file__)) +sys.path.append(os.path.join(parent_dir, '..', 'scripts')) +sys.path.append(os.path.join(parent_dir, '..', 'scripts', 'xunit')) +import xunit +import tosa +from tosa_test_gen import TosaTestGen +from tosa_test_runner import TosaTestRunner + +no_color_printing = False +#from run_tf_unit_test import LogColors, print_color, run_sh_command + +def parseArgs(): + + parser = argparse.ArgumentParser() + parser.add_argument('-t', '--test', dest='test', type=str, nargs='+', + help='Test(s) to run') + parser.add_argument('--seed', dest='random_seed', default=42, type=int, + help='Random seed for test generation') + parser.add_argument('--ref-model-path', dest='ref_model_path', + default='build/reference_model/tosa_reference_model', type=str, + help='Path to reference model executable') + parser.add_argument('--ref-debug', dest='ref_debug', default='', type=str, + help='Reference debug flag (low, med, high)') + parser.add_argument('--ref-intermediates', dest='ref_intermediates', default=0, type=int, + help='Reference model dumps intermediate tensors') + parser.add_argument('-v', '--verbose', dest='verbose', action='count', + help='Verbose operation') + parser.add_argument('-j', '--jobs', dest='jobs', type=int, default=1, + help='Number of parallel jobs') + parser.add_argument('--sut-module', '-s', dest='sut_module', type=str, nargs='+', default=['tosa_ref_run'], + help='System under test module to load (derives from TosaTestRunner). May be repeated') + parser.add_argument('--sut-module-args', dest='sut_module_args', type=str, nargs='+', default=[], + help='System under test module arguments. Use sutmodulename:argvalue to pass an argument. May be repeated.') + parser.add_argument('--xunit-file', dest='xunit_file', type=str, default='result.xml', + help='XUnit output file') + + args = parser.parse_args() + + # Autodetect CPU count + if args.jobs <= 0: + args.jobs = os.cpu_count() + + return args + +def workerThread(task_queue, runnerList, args, result_queue): + while True: + try: + test = task_queue.get(block=False) + except queue.Empty: + break + + if test is None: + break + + msg = '' + start_time = datetime.now() + try: + + for runnerModule, runnerArgs in runnerList: + if args.verbose: + print('Running runner {} with test {}'.format(runnerModule.__name__, test)) + runner = runnerModule.TosaRefRunner(args, runnerArgs, test) + try: + rc = runner.runModel() + except Exception as e: + rc = TosaTestRunner.Result.INTERNAL_ERROR + except Exception as e: + print('Internal regression error: {}'.format(e)) + print(''.join(traceback.format_exception(etype=type(e), value=e, tb=e.__traceback__))) + rc = TosaTestRunner.Result.INTERNAL_ERROR + + end_time = datetime.now() + + result_queue.put((test, rc, msg, end_time - start_time)) + task_queue.task_done() + + return True + +def loadRefModules(args): + # Returns a tuple of (runner_module, [argument list]) + runnerList = [] + for r in args.sut_module: + if args.verbose: + print('Loading module {}'.format(r)) + + runner = importlib.import_module(r) + + # Look for arguments associated with this runner + runnerArgPrefix = '{}:'.format(r) + runnerArgList = [] + for a in args.sut_module_args: + if a.startswith(runnerArgPrefix): + runnerArgList.append(a[len(runnerArgPrefix):]) + runnerList.append((runner, runnerArgList)) + + return runnerList + +def main(): + args = parseArgs() + + runnerList = loadRefModules(args) + + threads = [] + taskQueue = queue.Queue() + resultQueue = queue.Queue() + + for t in args.test: + taskQueue.put((t)) + + print('Running {} tests '.format(taskQueue.qsize())) + + for i in range(args.jobs): + t = threading.Thread(target=workerThread, args=(taskQueue, runnerList, args, resultQueue)) + t.setDaemon(True) + t.start() + threads.append(t) + + taskQueue.join() + + resultList = [] + results = [0] * len(TosaTestRunner.Result) + + while True: + try: + test, rc, msg, time_delta = resultQueue.get(block=False) + except queue.Empty: + break + + resultList.append((test, rc, msg, time_delta)) + results[rc] = results[rc] + 1 + + xunit_result = xunit.xunit_results('Regressions') + xunit_suite = xunit_result.create_suite('Unit tests') + + # Sort by test name + for test, rc, msg, time_delta in sorted(resultList, key=lambda tup: tup[0]): + test_name = test + xt = xunit.xunit_test(test_name, 'reference') + + xt.time = str(float(time_delta.seconds) + (float(time_delta.microseconds) * 1e-6)) + + if rc == TosaTestRunner.Result.EXPECTED_PASS or rc == TosaTestRunner.Result.EXPECTED_FAILURE: + if args.verbose: + print('{} {}'.format(rc.name, test_name)) + else: + xt.failed(msg) + print('{} {}'.format(rc.name, test_name)) + + xunit_suite.tests.append(xt) + resultQueue.task_done() + + xunit_result.write_results(args.xunit_file) + + print('Totals: ', end='') + for result in TosaTestRunner.Result: + print('{} {}, '.format(results[result], result.name.lower()), end ='') + print() + + return 0 + +if __name__ == '__main__': + exit(main()) |