Add Vela codebase
- Added modules ethosu.vela and ethosu.mlw_codec.
- Added README and various configuration files.
Change-Id: I3690f8c8f5966306ecddaeb2793c30ca9c6e2eee
diff --git a/Pipfile b/Pipfile
new file mode 100644
index 0000000..300bef6
--- /dev/null
+++ b/Pipfile
@@ -0,0 +1,9 @@
+[[source]]
+name = "pypi"
+url = "https://pypi.org/simple"
+verify_ssl = true
+
+[dev-packages]
+
+[packages]
+ethos-u-vela = {editable = true,path = "."}
diff --git a/Pipfile.lock b/Pipfile.lock
new file mode 100644
index 0000000..6fa0154
--- /dev/null
+++ b/Pipfile.lock
@@ -0,0 +1,56 @@
+{
+ "_meta": {
+ "hash": {
+ "sha256": "2d930644f3f81f11dae3317cae890fe083479342c80da44161b46ac83d6972d5"
+ },
+ "pipfile-spec": 6,
+ "requires": {},
+ "sources": [
+ {
+ "name": "pypi",
+ "url": "https://pypi.org/simple",
+ "verify_ssl": true
+ }
+ ]
+ },
+ "default": {
+ "ethos-u-vela": {
+ "editable": true,
+ "path": "."
+ },
+ "flatbuffers": {
+ "hashes": [
+ "sha256:776a959c5f70b41819fa75de44ed14fd984fa1a79b378f27e6f4fff338cbdca2",
+ "sha256:f24185db54193540e3d684dc98aa7c2d89882341641548ceb36fd2589fef6c4e"
+ ],
+ "version": "==1.11.0"
+ },
+ "numpy": {
+ "hashes": [
+ "sha256:1598a6de323508cfeed6b7cd6c4efb43324f4692e20d1f76e1feec7f59013448",
+ "sha256:1b0ece94018ae21163d1f651b527156e1f03943b986188dd81bc7e066eae9d1c",
+ "sha256:2e40be731ad618cb4974d5ba60d373cdf4f1b8dcbf1dcf4d9dff5e212baf69c5",
+ "sha256:4ba59db1fcc27ea31368af524dcf874d9277f21fd2e1f7f1e2e0c75ee61419ed",
+ "sha256:59ca9c6592da581a03d42cc4e270732552243dc45e87248aa8d636d53812f6a5",
+ "sha256:5e0feb76849ca3e83dd396254e47c7dba65b3fa9ed3df67c2556293ae3e16de3",
+ "sha256:6d205249a0293e62bbb3898c4c2e1ff8a22f98375a34775a259a0523111a8f6c",
+ "sha256:6fcc5a3990e269f86d388f165a089259893851437b904f422d301cdce4ff25c8",
+ "sha256:82847f2765835c8e5308f136bc34018d09b49037ec23ecc42b246424c767056b",
+ "sha256:87902e5c03355335fc5992a74ba0247a70d937f326d852fc613b7f53516c0963",
+ "sha256:9ab21d1cb156a620d3999dd92f7d1c86824c622873841d6b080ca5495fa10fef",
+ "sha256:a1baa1dc8ecd88fb2d2a651671a84b9938461e8a8eed13e2f0a812a94084d1fa",
+ "sha256:a244f7af80dacf21054386539699ce29bcc64796ed9850c99a34b41305630286",
+ "sha256:a35af656a7ba1d3decdd4fae5322b87277de8ac98b7d9da657d9e212ece76a61",
+ "sha256:b1fe1a6f3a6f355f6c29789b5927f8bd4f134a4bd9a781099a7c4f66af8850f5",
+ "sha256:b5ad0adb51b2dee7d0ee75a69e9871e2ddfb061c73ea8bc439376298141f77f5",
+ "sha256:ba3c7a2814ec8a176bb71f91478293d633c08582119e713a0c5351c0f77698da",
+ "sha256:cd77d58fb2acf57c1d1ee2835567cd70e6f1835e32090538f17f8a3a99e5e34b",
+ "sha256:cdb3a70285e8220875e4d2bc394e49b4988bdb1298ffa4e0bd81b2f613be397c",
+ "sha256:deb529c40c3f1e38d53d5ae6cd077c21f1d49e13afc7936f7f868455e16b64a0",
+ "sha256:e7894793e6e8540dbeac77c87b489e331947813511108ae097f1715c018b8f3d"
+ ],
+ "version": "==1.18.2"
+ }
+ },
+ "develop": {}
+}
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..03ad7fe
--- /dev/null
+++ b/README.md
@@ -0,0 +1,112 @@
+# Vela
+This tool is used to compile a [TensorFlow Lite for Microcontrollers](https://www.tensorflow.org/lite/microcontrollers) neural network model into an optimised version that can run on an embedded system containing an [Ethos-U55 NPU](https://www.arm.com/products/silicon-ip-cpu/ethos/ethos-u55).
+
+The optimised model will contain TensorFlow Lite Custom operators for those parts of the model that can be accelerated by the Ethos-U55. Parts of the model that cannot be accelerated are left unchanged and will instead run on the Cortex-M series CPU using an appropriate kernel (such as the [Arm](https://www.arm.com) optimised [CMSIS-NN](https://github.com/ARM-software/CMSIS_5/tree/develop/CMSIS/NN) kernels).
+
+After compilation the optimised model can only be run on an Ethos-U55 NPU embedded system.
+
+The tool will also generate performance estimates (EXPERIMENTAL) for the compiled model.
+
+## Environment
+Vela runs on the Linux operating system.
+
+## Prerequisites
+The following should be installed prior to the installation of Vela:
+ - Python >= 3.6
+ - GNU toolchain (GCC, Binutils and libraries) or alternative C compiler/linker toolchain
+
+## Installation
+Before running, the Vela package must be installed along with all its dependencies. To do this, first change to the directory that contains this README.md file. Then use the command:
+```
+pip3 install -U setuptools>=40.1.0
+pip3 install .
+```
+
+Or, if you use the `pipenv` virtual environment tool:
+```
+pipenv install .
+```
+
+## Running
+Vela is run with an input `.tflite` file passed on the command line. This file contains the neural network to be compiled. The tool then outputs an optimised version with a `_vela.tflite` file prefix, along with the performance estimate (EXPERIMENTAL) CSV files, all to the output directory.
+
+If you use the `pipenv` virtual environment tool then first start by spawning a shell in the virtual environment.:
+```
+pipenv shell
+```
+After which running Vela is the same regardless of whether you are in a virtual environment or not.
+
+Example usage:
+1) Compile the network `my_model.tflite`. The optimised version will be output to `./output/my_network_vela.tflite`.
+```
+vela my_model.tflite
+```
+2) Compile the network `/path/to/my_model.tflite` and specify the output to go in the directory `./results_dir/`.
+```
+vela --output-dir ./results_dir /path/to/my_model.tflite
+```
+3) To get a list of all available options:
+```
+vela --help
+```
+4) To specifiy information about the embedded system's configuration use Vela's system configuration file. The following command selects the `MySysConfig` settings that are described in the `sys_cfg_vela.ini` system configuration file. More details can be found in the next section.
+```
+vela --config sys_cfg_vela.ini --system-config MySysConfig my_model.tflite
+```
+
+### Vela's System Configuration file
+This is used to describe various properties of the embedded system that the network will run in.
+
+Example of a Vela system configuration file.
+```
+; File: sys_cfg_vela.ini
+; The file contains two parts; a system config part and a CPU operator
+; performance part.
+
+; System config
+; Specifies properties such as the core clock speed, the size and speed of the
+; four potential memory areas, and for various types of data which memory area
+; is used to store them. The cpu property is used to link with the CPU operator
+; performance.
+; The four potential memory areas are: Sram, Dram, OnChipFlash, OffChipFlash.
+
+[SysConfig.MySysConfig]
+npu_freq=500e6
+cpu=MyCpu
+Sram_clock_scale=1
+Sram_port_width=64
+Dram_clock_scale=1
+Dram_port_width=64
+OnChipFlash_clock_scale=1
+OnChipFlash_port_width=64
+OffChipFlash_clock_scale=0.25
+OffChipFlash_port_width=32
+permanent_storage_mem_area=OffChipFlash
+feature_map_storage_mem_area=Sram
+fast_storage_mem_area=Sram
+
+; CPU operator performance
+; Specifies properties that are used by a linear model to estimate the
+; performance for any operations that will be run on the CPU (such as those not
+; supported by the NPU). Setting the intercept and slope to 0 will result in
+; the operator being excluded from the performance estimation. This is the same
+; as not specifying the operator. If an explicit cpu is specified rather than
+; using the default then the cpu name must match the cpu specified in the
+; SysConfig.<system config name> section.
+
+[CpuPerformance.MyCpuOperator]
+default.intercept=0.0
+default.slope=1.0
+
+MyCpu.intercept=0.0
+MyCpu.slope=1.0
+```
+
+## Contribution Guidlines and Pull Requests
+Contributions are accepted under [Apache License 2.0](LICENSE.txt). Only submit contributions where you have authored all of the code.
+
+## Resources
+* [Ethos-U55](https://www.arm.com/products/silicon-ip-cpu/ethos/ethos-u55)
+
+## License
+Vela is licensed under [Apache License 2.0](LICENSE.txt)
diff --git a/ethosu/mlw_codec/makefile b/ethosu/mlw_codec/makefile
new file mode 100644
index 0000000..6eb418d
--- /dev/null
+++ b/ethosu/mlw_codec/makefile
@@ -0,0 +1,49 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Makefile to build mlw_codec
+
+UNAME=$(shell uname -o)
+
+CFLAGS=-Wall -Wno-unused-function -Wno-unused-variable
+
+ifeq ($(DEBUG),1)
+ CFLAGS+=-g -O0 -DDEBUG
+else
+ CFLAGS+=-O3
+endif
+
+LIBSRCS=mlw_encode.c mlw_decode.c
+LIBHDRS=mlw_encode.h mlw_decode.h mlw_common.h
+
+ifeq ($(UNAME),Cygwin)
+ MLWEXE=mlw_codec.exe
+else
+ MLWEXE=mlw_codec
+endif
+
+all: mlwexe
+
+.PHONY: mlwexe
+mlwexe: $(MLWEXE)
+
+clean:
+ rm -f $(MLWEXE)
+
+$(MLWEXE): mlw_main.c $(LIBSRCS) $(LIBHDRS) makefile
+ gcc $(CFLAGS) mlw_main.c $(LIBSRCS) -o $(MLWEXE) -lm
diff --git a/ethosu/mlw_codec/mlw_codecmodule.c b/ethosu/mlw_codec/mlw_codecmodule.c
new file mode 100644
index 0000000..de945ab
--- /dev/null
+++ b/ethosu/mlw_codec/mlw_codecmodule.c
@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2020 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * 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.
+ */
+
+#define PY_SSIZE_T_CLEAN
+#include <Python.h>
+
+#include "mlw_decode.h"
+#include "mlw_encode.h"
+
+/* C extension wrapper for mlw_encode
+ *
+ * This method is exposed directly in python with the arguments with a
+ * prototype of the form:
+ *
+ * output = mlw_codec.encode(input, verbose=0)
+ *
+ * input: [int]
+ * verbose: int
+ * output: bytearray
+ */
+
+static PyObject *
+method_encode (PyObject *self, PyObject *args)
+{
+ /* Object to hold the input integer list. */
+ PyObject *input_list_object;
+
+ /* Object to hold the input verbosity integer, the verbose argument
+ * is optional so defaulted to 0.
+ */
+ int verbose = 0;
+
+ /* Arguments to the method are delivered as a tuple, unpack the
+ * tuple to get the individual arguments, note the second is
+ * optional.
+ */
+ if (!PyArg_ParseTuple(args, "O|i", &input_list_object, &verbose))
+ return NULL;
+
+ /* Unpack the length of the input integer list. */
+ int input_length = PyObject_Length (input_list_object);
+ if (input_length < 0)
+ input_length = 0;
+
+ /* We need to marshall the integer list into an input buffer
+ * suitable for mlw_encode, use a temporary heap allocated buffer
+ * for that purpose.
+ */
+ int16_t *input_buffer = (int16_t *) malloc(sizeof(int16_t *) * input_length);
+ if (input_buffer == NULL)
+ return PyErr_NoMemory();
+
+ /* Unpack the input integer list into the temporary buffer.
+ */
+ for (int i = 0; i < input_length; i++)
+ {
+ PyObject *item;
+ item = PyList_GetItem(input_list_object, i);
+ if (!PyLong_Check(item))
+ input_buffer[i] = 0;
+ input_buffer[i] = PyLong_AsLong(item);
+ }
+
+ /* We don't know the output length required, we guess worst case,
+ * the mlw_encode call will do a resize (downwards) anyway.
+ */
+ uint8_t *output_buffer = malloc(input_length);
+ if (output_buffer == NULL)
+ return PyErr_NoMemory();
+
+ int output_length = mlw_encode(input_buffer, input_length, &output_buffer, verbose);
+
+ PyObject *output_byte_array = PyByteArray_FromStringAndSize ((char *) output_buffer, output_length);
+
+ /* Discard the temporary input and output buffers. */
+ free (input_buffer);
+ free (output_buffer);
+
+ return output_byte_array;
+}
+
+/* C extension wrapper for mlw_decode
+ *
+ * This method is exposed directly in python with the arguments with a
+ * prototype of the form:
+ *
+ * output = mlw_codec.decode(input, verbose=0)
+ *
+ * input: bytearray
+ * verbose: int
+ * output: [int]
+ */
+
+static PyObject *
+method_decode(PyObject *self, PyObject *args)
+{
+ /* Object to hold the input bytearray. */
+ PyObject *input_bytearray_object;
+
+ /* Object to hold the input verbosity integer, the verbose argument
+ * is optional so defaulted to 0.
+ */
+ int verbose = 0;
+
+ /* Arguments to the method are delivered as a tuple, unpack the
+ * tuple to get the individual arguments, note the second is
+ * optional.
+ */
+ if (!PyArg_ParseTuple(args, "Y|i", &input_bytearray_object, &verbose))
+ return NULL;
+
+ /* Unpack the input buffer and length from the bytearray object. */
+ uint8_t *input_buffer = (uint8_t *) PyByteArray_AsString(input_bytearray_object);
+ int input_length = PyByteArray_Size(input_bytearray_object);
+
+ /* We don't know the output length required, we guess, but the guess
+ * will be too small, the mlw_decode call will do a resize (upwards)
+ * anyway.
+ */
+ int16_t *output_buffer = malloc (input_length);
+ if (output_buffer == NULL)
+ return PyErr_NoMemory();
+
+ int output_length = mlw_decode (input_buffer, input_length, &output_buffer, verbose);
+
+ /* Construct a new integer list and marshall the output buffer
+ * contents into the list. */
+ PyObject *output_list = PyList_New(output_length);
+ for (int i = 0; i <output_length; i++)
+ PyList_SetItem (output_list, i, PyLong_FromLong (output_buffer[i]));
+
+ free (output_buffer);
+
+ return output_list;
+}
+
+/* mlw_codec method descriptors.
+ */
+
+static PyMethodDef mlw_methods[] = {
+ {"decode", method_decode, METH_VARARGS, "Python interface for decode"},
+ {"encode", method_encode, METH_VARARGS, "Python interface for encode"},
+ {NULL, NULL, 0, NULL}
+};
+
+/* mlw_codec module descriptor.
+ */
+
+static struct PyModuleDef mlw_codecmodule = {
+ PyModuleDef_HEAD_INIT,
+ "mlw_codec",
+ "Python interface for the mlw encoder",
+ -1,
+ mlw_methods
+};
+
+PyMODINIT_FUNC PyInit_mlw_codec(void) {
+ return PyModule_Create(&mlw_codecmodule);
+}
diff --git a/ethosu/mlw_codec/mlw_common.h b/ethosu/mlw_codec/mlw_common.h
new file mode 100644
index 0000000..008473a
--- /dev/null
+++ b/ethosu/mlw_codec/mlw_common.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2020 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * 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 <stdint.h>
+
+#ifndef __MLW_COMMON_H__
+#define __MLW_COMMON_H__
+
+#define ZDIV_DISABLE 6 // not alternating mode
+#define ZDIV_EOS 7 // indicates end of stream
+
+#define WDIV_UNCOMPRESSED 7 // indicates uncompressed weights
+
+#endif
diff --git a/ethosu/mlw_codec/mlw_decode.c b/ethosu/mlw_codec/mlw_decode.c
new file mode 100644
index 0000000..92aaea6
--- /dev/null
+++ b/ethosu/mlw_codec/mlw_decode.c
@@ -0,0 +1,300 @@
+/*
+ * Copyright (c) 2020 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * 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 <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+#include <stdarg.h>
+#include <math.h>
+#include "mlw_common.h"
+#include "mlw_decode.h"
+
+
+/////////////////////////////// Read from bitstream
+
+typedef struct bitbuf {
+ uint8_t *buf;
+ int buf_size; // in bytes
+ int pos; // bit pos of next bit
+ int log_symbols;
+} bitbuf_t;
+
+
+// size in byte
+static void bitbuf_init( bitbuf_t *bb, uint8_t *buf, int size, int log_symbols) {
+ bb->buf = buf;
+ bb->pos = 0;
+ bb->buf_size = size;
+ bb->log_symbols = log_symbols;
+}
+
+static int bitbuf_getbit( bitbuf_t *bb) {
+ int byte_pos = bb->pos>>3;
+ int bit_pos = bb->pos&7;
+ if ( byte_pos < 0 || byte_pos >= bb->buf_size ) {
+ printf("bitbuf_getbit: underrun, bit_pos %3d byte_pos %3d buf_size %3d\n", bit_pos, byte_pos, bb->buf_size);
+ exit(1);
+ }
+ int bit = bb->buf[ byte_pos ] & (1<<bit_pos) ? 1 : 0;
+ bb->pos++;
+ return bit;
+}
+
+static int bitbuf_get( bitbuf_t *bb, const char *name, int len) {
+ int i, data=0, save_pos=bb->pos;
+ if (len>0) {
+ for(i=0; i<len; i++) {
+ data |= bitbuf_getbit(bb)<<i;
+ }
+ if (bb->log_symbols)
+ printf("bitbuf: pos %3d %7s len %d data %x\n", save_pos, name, len, data);
+ }
+ return data;
+}
+
+// Decode the given weight stream
+// inbuf compressed bitstream
+// inbuf_size size of compressed bitstream in bytes
+// outbuf uncompressed 9bit signed weights, buffer malloced
+// verbose if non-zero, printf log
+// Return value is the number of uncompressed weights
+int mlw_decode( uint8_t *inbuf, int inbuf_size, int16_t **outbuf, int verbose) {
+ int nvalues;
+ int w_grc_div;
+ int w_grc_trunc;
+ int w_uncompressed;
+ int z_grc_div, z_prev_grc_div=0;
+ int new_palette;
+ int palsize=0, palbits=0;
+ int direct_offset=0;
+ int16_t palette[512];
+ int first=1;
+ int use_zero_run, i, j;
+ int outbuf_size=0;
+ int nchunks=0;
+
+ *outbuf=0;
+
+ bitbuf_t bitbuf_s, *bb=&bitbuf_s;
+ bitbuf_init( bb, inbuf, inbuf_size, (verbose&2)?1:0 );
+
+ // Loop over all slices
+ while(1) {
+ // Decode slice header
+ z_grc_div = bitbuf_get( bb, "ZDIV", 3 );
+ while(z_grc_div==ZDIV_EOS) { // TODO: change to ZDIV_PAD
+ // End of stream
+ // Byte align
+ bitbuf_get( bb, "BYTEALIGN", (8-(bb->pos&7))&7 );
+ first=1;
+ if ( (bb->pos/8) == inbuf_size) {
+ // Quit if we actually reached end of input stream
+ break;
+ }
+ z_grc_div = bitbuf_get( bb, "ZDIV", 3 );
+ }
+ if ( (bb->pos/8) == inbuf_size) {
+ break; // reached end of input stream
+ }
+ assert(z_grc_div<4 || z_grc_div==ZDIV_DISABLE);
+ use_zero_run = z_grc_div!=ZDIV_DISABLE; // alternating grc
+ nvalues = bitbuf_get( bb, "SLICELEN", 15 )+1;
+ w_grc_div = bitbuf_get( bb, "WDIV", 3 );
+ w_grc_trunc = bitbuf_get( bb, "WTRUNC", 1 );
+ new_palette = bitbuf_get( bb, "NEWPAL", 1 );
+ if (first) {
+ // the first slice must have a palette/direct mode setup
+ assert(new_palette);
+ first=0;
+ }
+ if (!new_palette) {
+ // At the moment it is not supported to change between alternating
+ // and non-alternating without redefining the palette (this is because
+ // the zero is not included in the palette in case of alternating)
+ int prev_use_zero_run = z_prev_grc_div!=ZDIV_DISABLE;
+ (void)(prev_use_zero_run);
+ assert( use_zero_run == prev_use_zero_run);
+ }
+ z_prev_grc_div = z_grc_div;
+ if (new_palette) {
+ direct_offset = bitbuf_get( bb, "DIROFS", 5 );
+ palsize = bitbuf_get( bb, "PALSIZE", 5 );
+ if (palsize>0)
+ palsize++;
+ palbits = bitbuf_get( bb, "PALBITS", 3 )+2;
+ for(i=0; i<palsize; i++) {
+ palette[i] = bitbuf_get( bb, "PALETTE", palbits );
+ }
+ }
+
+ if (w_grc_div==WDIV_UNCOMPRESSED) {
+ // Uncompressed mode
+ w_uncompressed = 1;
+ int uncompressed_bits;
+ if (palsize>0) {
+ // Uncompressed bits is given by palette size.
+ uncompressed_bits=0;
+ while( (1<<uncompressed_bits) < palsize )
+ uncompressed_bits++;
+ } else {
+ // No palette. PALBITS is used to specify uncompressed bits.
+ uncompressed_bits=palbits;
+ }
+ // In uncompressed mode there's only a remainder part (no unary)
+ // This is achieved by setting w_grc_div to index bit width
+ w_grc_div = uncompressed_bits;
+ } else {
+ w_uncompressed = 0;
+ assert(w_grc_div<6);
+ }
+
+ // Decode the slice
+ int z_nvalues = nvalues + (new_palette?1:0);
+ int *w_value = malloc( nvalues*sizeof(int) );
+ int *z_value = malloc( z_nvalues*sizeof(int) );
+ int w_pos=0, z_pos=0;
+ int w_prev_pos=0, z_prev_pos=0;
+ int w_unary0=0, w_unary1=0, w_unary1_len=0, w_q[12]={0}, w_carry=0;
+ int z_unary=0, z_q[12]={0}, z_carry=0;
+ int w_nsymbols=0;
+ int w_prev_enable=0, w_prev_nsymbols=0, w_prev_q[12]={0};
+ int z_nsymbols=0;
+ int z_prev_enable=0, z_prev_nsymbols=0, z_prev_q[12]={0};
+ int total_zcnt=0;
+ int z_unary_len = z_grc_div<3 ? 12 : 8;
+
+ // Loop over all chunks in the slice
+ do {
+ // Flow control to possibly throttle either the weights or zero-runs
+ int balance = use_zero_run ? w_pos - z_pos : 0;
+ int w_enable = (balance<8 || !use_zero_run) && w_pos<nvalues;
+ int z_enable = balance>=0 && use_zero_run && z_pos<z_nvalues;
+ if (w_enable) {
+ if (!w_uncompressed)
+ w_unary0 = bitbuf_get( bb, "WUNARY0", 12 );
+ else
+ w_unary0 = 0;
+ }
+ if (z_enable) {
+ z_unary = bitbuf_get( bb, "ZUNARY", z_unary_len );
+ z_nsymbols=0;
+ int cnt = z_carry;
+ for(i=0; i<z_unary_len; i++) {
+ if (z_unary & (1<<i)) {
+ cnt++;
+ } else {
+ z_q[z_nsymbols++] = cnt;
+ cnt=0;
+ }
+ }
+ z_carry = cnt;
+ z_pos += z_nsymbols;
+ }
+ if (w_enable) {
+ w_unary1_len=0;
+ int max_symbols = w_uncompressed && w_grc_div>5 ? 8 : 12;
+ for(i=0; i<max_symbols; i++) {
+ if (w_unary0&(1<<i))
+ w_unary1_len++;
+ }
+ w_unary1 = bitbuf_get( bb, "WUNARY1", w_unary1_len );
+ w_nsymbols=0;
+ int cnt = w_carry;
+ for(i=0; i<max_symbols; i++) {
+ int code=0;
+ if (w_unary0 & (1<<i)) {
+ code++;
+ if (w_unary1&1) {
+ code++;
+ }
+ w_unary1 = w_unary1>>1;
+ }
+ cnt += code;
+ if (code<2 || w_grc_trunc) {
+ w_q[w_nsymbols++] = cnt;
+ cnt=0;
+ }
+ }
+ w_carry = cnt;
+ w_pos += w_nsymbols;
+ }
+ if (w_prev_enable) {
+ for(i=0; i<w_prev_nsymbols && w_prev_pos<nvalues; i++, w_prev_pos++) {
+ int remain = bitbuf_get( bb, "WREMAIN", w_grc_div );
+ w_value[w_prev_pos] = (w_prev_q[i]<<w_grc_div) + remain;
+ }
+ }
+ if (z_prev_enable) {
+ for(i=0; i<z_prev_nsymbols && z_prev_pos<z_nvalues; i++, z_prev_pos++) {
+ int remain = bitbuf_get( bb, "ZREMAIN", z_grc_div );
+ z_value[z_prev_pos] = (z_prev_q[i]<<z_grc_div) + remain;
+ total_zcnt += z_value[z_prev_pos];
+ }
+ }
+ w_prev_enable = w_enable;
+ w_prev_nsymbols = w_nsymbols;
+ memcpy( w_prev_q, w_q, sizeof(w_prev_q));
+ z_prev_enable = z_enable;
+ z_prev_nsymbols = z_nsymbols;
+ memcpy( z_prev_q, z_q, sizeof(z_prev_q));
+ nchunks++;
+ } while( w_prev_enable || z_prev_enable );
+
+ // Interleave non-zero and zeros into the outbut buffer
+ // Increase the outbuffer to fit the new slice
+ *outbuf = realloc( *outbuf, (outbuf_size + nvalues + total_zcnt)*sizeof(int16_t));
+
+ int k=outbuf_size;
+
+ // Insert initial zeros
+ // (slices redefining the palette may start with zeros)
+ if (new_palette && use_zero_run) {
+ for(j=0; j<z_value[0]; j++) {
+ (*outbuf)[k++] = 0;
+ }
+ }
+
+ // Loop over all weights and insert zeros in-between
+ for(i=0; i<nvalues; i++) {
+ int val;
+ assert(w_value[i]<512); // HW supports 9bit
+ if (w_value[i]<palsize) {
+ val = palette[w_value[i]];
+ } else {
+ val = w_value[i]-palsize+direct_offset;
+ }
+ int sign = val&1;
+ int mag = val>>1;
+ (*outbuf)[k++] = sign ? -mag : mag;
+ if (use_zero_run) {
+ for(j=0; j<z_value[i+(new_palette?1:0)]; j++) {
+ (*outbuf)[k++] = 0;
+ }
+ }
+ }
+
+ outbuf_size = k;
+ free(w_value);
+ free(z_value);
+ }
+ return outbuf_size;
+}
diff --git a/ethosu/mlw_codec/mlw_decode.h b/ethosu/mlw_codec/mlw_decode.h
new file mode 100644
index 0000000..a15261a
--- /dev/null
+++ b/ethosu/mlw_codec/mlw_decode.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * 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 <stdint.h>
+
+#ifndef __MLW_DECODE_H__
+#define __MLW_DECODE_H__
+
+#ifdef _MSC_VER
+ #define EXPORTED __declspec(dllexport)
+#else
+ #define EXPORTED __attribute__((visibility("default")))
+#endif
+
+#if __cplusplus
+extern "C"
+{
+#endif
+
+EXPORTED
+int mlw_decode(uint8_t *inbuf, int inbuf_size, int16_t **outbuf, int verbose);
+
+#if __cplusplus
+}
+#endif
+
+#endif
diff --git a/ethosu/mlw_codec/mlw_encode.c b/ethosu/mlw_codec/mlw_encode.c
new file mode 100644
index 0000000..ac25fc5
--- /dev/null
+++ b/ethosu/mlw_codec/mlw_encode.c
@@ -0,0 +1,874 @@
+/*
+ * Copyright (c) 2020 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * 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 <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+#include <stdarg.h>
+#include <math.h>
+#include "mlw_common.h"
+#include "mlw_encode.h"
+
+#define DPRINTF(...)
+//#define DPRINTF(...) printf(__VA_ARGS__)
+
+#define ZERO_RUN_THRES 4
+
+#define min(a,b) ((a)<(b)?(a):(b))
+#define max(a,b) ((a)>(b)?(a):(b))
+
+typedef struct palette {
+ int16_t lut[32];
+ int16_t inv_lut[512];
+ int palsize; // number of palette entries
+ int palbits; // bit width of palette entries
+ int use_zero_runs; // zeros are coded separately
+ int only_palette; // no values outside the palette
+ int direct_offset; // added to the decoded weight index before direct conversion to sign/mag
+ int only_zeros; // special case that the section is all zeros
+} palette_t;
+
+static int is_power_of_two( int x ) {
+ return ((x-1) & x)==0;
+}
+
+static int get_palette_index_bits( int size ) {
+ int i;
+ for(i=7; i>=0; i--)
+ if (size > (1<<i) )
+ return i+1;
+ return 0;
+}
+
+// Search the stream for suitable palette restart positions
+// Return the number of restarts
+static int search_palette_sections( int16_t *buf, int size, int **palette_restart_positions ) {
+ int i,j,got_palette,restart_i,palette_size=0, last_restart_idx, zero_cnt;
+ int prev_idx[512]; // For each value, keep track of the index of the previous occurence
+ int *restart_pos;
+ int max_palettes = size/64;
+
+ // Preliminary allocation of sufficient size
+ restart_pos = (int*)malloc( max_palettes*sizeof(int) );
+ last_restart_idx=0;
+ got_palette=0;
+ restart_i=1;
+ restart_pos[0] = 0;
+ zero_cnt=0;
+ memset( prev_idx, -1, sizeof(prev_idx));
+ for(i=0; i<size; i++) {
+ // Guess if zeros should be excluded from the palette
+ int exclude_zero = zero_cnt > (i-last_restart_idx)/4;
+
+ if (got_palette) {
+ // Check if the next value is not covered by the current palette
+ if ( prev_idx[ buf[i]+256 ] < last_restart_idx ) {
+ // New value: increase the palette size
+ palette_size++;
+ DPRINTF("Note: at pos %d extend palette to size %d\n", i, palette_size);
+ if ( is_power_of_two(palette_size-1-exclude_zero) ) {
+ if ( (i - last_restart_idx - zero_cnt) > 512 || (palette_size-exclude_zero)>32 ) {
+ // create a new palette because we extend a long lasting palette to require one more index bit
+ DPRINTF("Note: at pos %d create new palette because previous has to increase one more index bit. last_restart_idx %d n %d zero_cnt %d\n", i, last_restart_idx, i - last_restart_idx, zero_cnt );
+ assert( restart_i < max_palettes );
+ DPRINTF("restart %d pos %d\n", restart_i, i);
+ restart_pos[restart_i++] = i;
+ last_restart_idx = i;
+ got_palette=0;
+ zero_cnt=0;
+ }
+ }
+ }
+ }
+
+ prev_idx[ buf[i]+256 ] = i;
+ if (buf[i]==0)
+ zero_cnt++;
+
+ static const int window_sizes[5][2] = {{32,1}, {64,1}, {128,1}, {256,1}, {512,1}};
+ int k;
+ // loop over window sizes
+ for(k=0; k<5; k++) {
+ // Every Nth non-zero value, count what would be the size of a palette covering the last N NZ.
+ int N = window_sizes[k][0] * (got_palette?2:1);
+ if ( (i - last_restart_idx - zero_cnt) > 0 && ((i - last_restart_idx - zero_cnt) % N)==0 ) {
+ // Search backward to the position N nonzero values earlier
+ int nzcnt=0;
+ for( j=i; j>last_restart_idx; j--) {
+ if ( buf[j]!=0 ) {
+ if (nzcnt==N+1)
+ break;
+ nzcnt++;
+ }
+ }
+ int restart_idx = j;
+
+ // Calculate the size of a new palette (starting at restart_idx)
+ int new_palette_size=0;
+ for(j=0; j<512; j++) {
+ if ( prev_idx[j] >= restart_idx ) {
+ new_palette_size++;
+ }
+ }
+
+ int create_new_palette=0;
+ if (got_palette) {
+ int new_size_bits = get_palette_index_bits( new_palette_size - exclude_zero );
+ int old_size_bits = get_palette_index_bits( palette_size - exclude_zero );
+ int savings = N*(old_size_bits*15-new_size_bits*15)/16 - new_palette_size*8 - 20;
+ if ( savings>0 ) {
+ // Create new palette because it can be smaller than the existing palette
+ create_new_palette=1;
+ DPRINTF("Note: at pos %d restart smaller palette\n", restart_idx);
+ }
+ } else {
+ if ( (new_palette_size-exclude_zero) <= 32) {
+ int new_size_bits = get_palette_index_bits( new_palette_size - exclude_zero );
+ // estimate if we will make savings by using palette mode
+ int savings = N*(90-new_size_bits*15)/16 - new_palette_size*8 - 20;
+ create_new_palette = savings>0;
+ }
+ }
+ if (create_new_palette) {
+ palette_size=new_palette_size;
+ got_palette=1;
+ last_restart_idx = restart_idx;
+ DPRINTF("Note: at pos %d create palette of size %d\n", last_restart_idx, new_palette_size);
+ if ( restart_pos[restart_i-1] != last_restart_idx) {
+ assert( restart_i < max_palettes );
+ restart_pos[restart_i++] = last_restart_idx;
+ }
+ zero_cnt=0;
+ for( j=last_restart_idx; j<=i; j++)
+ if (buf[j]==0)
+ zero_cnt++;
+ }
+ }
+ }
+ }
+ // Reallocate to actual size
+ *palette_restart_positions = (int*)realloc( restart_pos, restart_i*sizeof(int) );
+ return restart_i;
+}
+
+// Calculate frequency table
+static void calc_freq( const int16_t *buf, int size, int freq[512] ) {
+ int i;
+ memset(freq, 0, 512*sizeof(int));
+ for(i=0; i<size; i++) {
+ freq[buf[i]+256]++;
+ }
+}
+
+static int cmp_uint64(const void * a, const void * b) {
+ uint64_t aa = *(uint64_t*)a;
+ uint64_t bb = *(uint64_t*)b;
+ return aa>bb ? -1 : aa<bb ? 1 : 0;
+}
+
+// Create palette from the given frequencies
+// Freq index 0-511 correspond to weights -256..255
+static void create_palette( int freq[512],
+ int use_zero_runs,
+ palette_t *p ) {
+ uint64_t freq64[512];
+ int i,all_cnt,all_max_val;
+
+ // Pair the frequency with the value so that
+ // the array can be sorted on frequency while keeping
+ // track of the corresponding palette value
+ memset(freq64, 0, sizeof(freq64));
+ all_cnt=0;
+ all_max_val=0;
+ for(i=-255; i<256; i++) {
+ if (i==0 && use_zero_runs)
+ continue;
+ int sign = i<0;
+ int mag = abs(i);
+ int palval = (mag<<1) | sign;
+
+ // Store palette value in 16 LSB bits, which will not affect the sorting
+ freq64[palval] = (((uint64_t)freq[i+256])<<16) | palval;
+ all_cnt+=freq[i+256];
+
+ if (freq[i+256]>0) {
+ all_max_val = max(all_max_val, palval);
+ }
+ }
+
+ // Count number of non-used weight values around zero (0, -1, +1, -2, +2 etc)
+ for(i=0; i<31; i++) {
+ if ((freq64[i]>>16)!=0)
+ break;
+ }
+ p->direct_offset = i;
+
+ // Sort in descending frequency order
+ qsort(freq64, 512, sizeof(uint64_t), cmp_uint64);
+
+ // Identify special case that there are no weights to code
+ // in the weight index stream (i.e. all weights are zeros)
+ p->only_zeros = (freq64[0]>>16)==0;
+ if (p->only_zeros) {
+ p->direct_offset=0;
+ }
+
+ // Check if all weights fit into the palette (and the palette is not empty)
+ p->only_palette = (freq64[0]>>16)>0 && (freq64[32]>>16)==0;
+
+ int max_palette_size;
+ if (p->only_palette) {
+ max_palette_size = 32;
+ } else {
+ // For direct-lut we must make sure that the encoded weight
+ // index is not > 511. We do that by limiting the palette size
+ // such that the greatest value can be reached after subtracting
+ // the palette size.
+ max_palette_size = min(32, 511-all_max_val);
+ if (max_palette_size==1) {
+ max_palette_size=0; // because palette of size 1 is not supported
+ }
+ }
+
+ // Setup the 32 entry palette
+ int palette_max_val = 0, val, cnt, pal_cnt=0;
+ for(i=0; i<max_palette_size; i++) {
+ cnt = freq64[i]>>16;
+ val = freq64[i]&0xffff;
+ if ( cnt==0 )
+ break;
+ p->lut[i] = val;
+ palette_max_val = max(palette_max_val, val);
+ pal_cnt+=cnt;
+ }
+ if (i==1)
+ i++; // palette size of 1 is not supported, make it 2
+
+ // Heuristic for when to use the palette. If more than half of the
+ // weights are in the palette then we use it. This ensures we don't
+ // use palette for e.g. rectangular distributions.
+ int palbits_val;
+ if (pal_cnt > all_cnt/2) {
+ p->palsize = i;
+ palbits_val = palette_max_val;
+ } else {
+ // No palette
+ p->palsize = 0;
+ // If no palette, then palbits is used to specify the
+ // number of bits required for uncompressed mode, i.e.
+ // the number of bits for the greatest weight value
+ palbits_val = all_max_val;
+ }
+
+ // the palette entry bit width
+ // minimum 2bits (because PALBITS is in range 2..9)
+ int palbits=2;
+ while( (1<<palbits) <= palbits_val )
+ palbits++;
+ assert(palbits<=9);
+ p->palbits = palbits;
+ p->use_zero_runs = use_zero_runs;
+}
+
+// Return 1 if zero runs should be used
+// If palette_size is 512, then palette is not used (in that case the palette is setup
+// with the standard alternating unsigned to signed mapping)
+static int find_palette( const int16_t *inbuf, int inbuf_size, palette_t *p) {
+ int freq[512], i;
+
+ // Calculate frequencies of the given weight stream
+ calc_freq( inbuf, inbuf_size, freq);
+
+ // Find two most common values
+ int most_common_freq[2]={0}, most_common_val[2]={0};
+ for(i=0; i<512; i++) {
+ if ( freq[i] > most_common_freq[0] ) {
+ most_common_freq[1] = most_common_freq[0];
+ most_common_val[1] = most_common_val[0];
+ most_common_freq[0] = freq[i];
+ most_common_val[0] = i-256;
+ } else if ( freq[i] > most_common_freq[1] ) {
+ most_common_freq[1] = freq[i];
+ most_common_val[1] = i-256;
+ }
+ }
+
+ // Decide if zero-runs (alternating mode) should be used:
+ // * zero should be the most common symbol
+ // * zero should be sufficiently more common than the second most common symbol
+ int use_zero_runs = most_common_val[0]==0 && most_common_freq[0] > ZERO_RUN_THRES*most_common_freq[1];
+
+ // Create the palette
+ create_palette( freq, use_zero_runs, p);
+
+ return use_zero_runs;
+}
+
+static void create_inverse_palette( palette_t *p) {
+ int i;
+ memset( p->inv_lut, 0, sizeof(p->inv_lut));
+ for(i=0; i<512; i++) {
+ int val = i;
+ int sign = val&1;
+ int mag = val>>1;
+ int weight = sign ? -mag : mag;
+ if (weight+256 < 512)
+ p->inv_lut[ weight+256 ] = i + p->palsize - p->direct_offset;
+ }
+ for(i=0; i<p->palsize; i++) {
+ int val = p->lut[i];
+ int sign = val&1;
+ int mag = val>>1;
+ int weight = sign ? -mag : mag;
+ if (weight+256 < 512)
+ p->inv_lut[ weight+256 ] = i;
+ }
+}
+
+#define NWCFG 13
+#define NZCFG 4 // restrict search to ZDIV=0..3
+#define MAX_ZWCFG (max(NWCFG,NZCFG))
+
+// search state
+typedef struct search_state {
+ int bitcnt; // number of bits to reach this state
+ uint8_t prev_cfg; // previous grc parameter config
+} search_state_t;
+
+// (trunc<<4) | div, 0x20 means uncompressed
+static const char w_grc_params[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x20 };
+static const char z_grc_params[] = { 0x00, 0x01, 0x02, 0x03, 0x04 };
+
+
+
+// An algorithm similar to the Viterbi algorithm is used to search for a
+// good GRC parameter sequence for the given input value sequence.
+// The inval buffer can contain weights, weight indices or runs.
+// The return value is the resulting number of bitstream sections.
+static int search_grc_params( const int *inval_buf,
+ int n_inval,
+ int zrun_mode,
+ int uncompressed_bits,
+ uint8_t *grc_param_cfg,
+ int *grc_param_pos,
+ int max_grc_param_cfg,
+ int *existing_grc_param_pos,
+ int n_existing_grc_param_pos,
+ int *bitcnt )
+{
+ int n_cfg = zrun_mode ? NZCFG : NWCFG;
+ const char *grc_params = zrun_mode ? z_grc_params : w_grc_params;
+ int i,j;
+
+ search_state_t *state[MAX_ZWCFG];
+ for(i=0; i<n_cfg; i++) {
+ state[i] = malloc( sizeof(search_state_t) * (n_inval+1) );
+ state[i][0].bitcnt=0;
+ state[i][0].prev_cfg=i;
+ }
+
+ // Loop over inval_buf
+ int existing_idx=0;
+ for(i=0; i<n_inval; i++) {
+ int value = inval_buf[i];
+
+ // Best GRC parameter so far
+ int best_bitcnt=0x7fffffff, best_cfg=0;
+ for(j=0; j<n_cfg; j++) {
+ if (state[j][i].bitcnt < best_bitcnt) {
+ best_bitcnt = state[j][i].bitcnt;
+ best_cfg = j;
+ }
+ }
+
+ int cmd_cost = 40;
+ if (existing_idx < n_existing_grc_param_pos && existing_grc_param_pos[existing_idx] == (i+1)) {
+ // free transition, because the weight stream already inserted a command at this position
+ cmd_cost = 0;
+ existing_idx++;
+ }
+
+ // Loop over GRC parameters, calculate bits to code value, and then update the search state
+ for(j=0; j<n_cfg; j++) {
+ int div = grc_params[j]&15;
+ int trunc = grc_params[j]>>4;
+ int q = value>>div;
+ int bits = trunc ? min(q+1,2) + div : q+1+div;
+ if (!zrun_mode && ((trunc && q>2) || q>31))
+ bits=10000; // it's not possible to code the current value; give it a high cost
+ if (trunc==2)
+ bits=uncompressed_bits;
+
+ if ( best_bitcnt + cmd_cost < state[j][i].bitcnt ) {
+ // Change GRC parameters
+ state[j][i+1].prev_cfg = best_cfg;
+ state[j][i+1].bitcnt = best_bitcnt + cmd_cost + bits;
+ } else {
+ // Keep same GRC parameters
+ state[j][i+1].prev_cfg = j;
+ state[j][i+1].bitcnt = state[j][i].bitcnt + bits;
+ }
+ }
+ }
+
+
+ // Best GRC parameter
+ int best_bitcnt=0x7fffffff, best_cfg=0;
+ for(j=0; j<n_cfg; j++) {
+ if (state[j][n_inval].bitcnt < best_bitcnt) {
+ best_bitcnt = state[j][n_inval].bitcnt;
+ best_cfg = j;
+ }
+ }
+
+ int cfg = best_cfg;
+ int n_cmds=0;
+ for(i=n_inval; i>=0; i--) {
+ if (state[cfg][i].prev_cfg != cfg || i==0) {
+ n_cmds++;
+ cfg = state[cfg][i].prev_cfg;
+ }
+ }
+
+ (void)(max_grc_param_cfg);
+ assert(n_cmds<=max_grc_param_cfg);
+
+ cfg = best_cfg;
+ j=n_cmds-1;
+ int endpos=n_inval;
+ for(i=n_inval; i>=0; i--) {
+ if (state[cfg][i].prev_cfg != cfg || i==0) {
+ grc_param_cfg[j] = cfg;
+ grc_param_pos[j] = endpos;
+ j--;
+ cfg = state[cfg][i].prev_cfg;
+ endpos = i-1;
+ }
+ }
+ assert(j==-1);
+
+ for(i=0; i<n_cfg; i++) {
+ free(state[i]);
+ }
+
+ *bitcnt = best_bitcnt;
+
+ return n_cmds;
+}
+
+
+/////////////////////////////// Write to bitstream
+
+typedef struct bitbuf {
+ uint8_t *buf;
+ int buf_size; // in bytes
+ int pos; // bit pos of next bit
+ int log_symbols;
+} bitbuf_t;
+
+// size in byte
+static void bitbuf_init( bitbuf_t *bb, uint8_t *buf, int size, int log_symbols ) {
+ bb->buf = buf;
+ bb->pos = 0;
+ bb->buf_size = size;
+ bb->log_symbols = log_symbols;
+}
+
+static void bitbuf_putbit( bitbuf_t *bb, int bit) {
+ int byte_pos = bb->pos>>3;
+ int bit_pos = bb->pos&7;
+ assert( byte_pos >= 0 );
+ assert( byte_pos < bb->buf_size );
+ bb->buf[ byte_pos ] = (bb->buf[ byte_pos ] & ~(1<<bit_pos)) | (bit<<bit_pos);
+ bb->pos += 1;
+}
+
+static void bitbuf_put( bitbuf_t *bb, const char *name, int len, int data) {
+ int i;
+ if (len>0) {
+ if (bb->log_symbols)
+ printf("bitbuf: pos %3d %7s len %d data %x\n", bb->pos, name, len, data);
+ for(i=0; i<len; i++) {
+ bitbuf_putbit(bb, (data>>i)&1);
+ }
+ }
+}
+
+// Return new bitpos
+static int encode_slice( const int *w_value,
+ const int *z_value,
+ int nvalues,
+ palette_t *p,
+ int new_palette,
+ int uncompressed_bits,
+ int w_cfg,
+ int z_cfg,
+ uint8_t *bitbuf,
+ int bitbuf_size,
+ int bitpos,
+ int verbose )
+{
+ int i,j;
+ bitbuf_t bitbuf_s, *bb=&bitbuf_s;
+ bitbuf_init( bb, bitbuf, bitbuf_size, verbose&2?1:0 );
+ bb->pos = bitpos;
+
+ assert(nvalues<32768);
+ // GRC parameters for this slice
+ int w_grc_div = w_grc_params[w_cfg] & 15;
+ int w_grc_trunc = (w_grc_params[w_cfg] >> 4)==1;
+ int w_uncompressed = (w_grc_params[w_cfg] >> 4)==2;
+ int z_grc_div = z_grc_params[z_cfg] & 15;
+
+ if (w_uncompressed) {
+ w_grc_div = uncompressed_bits;
+ }
+
+ int zdiv = p->use_zero_runs ? z_grc_div : ZDIV_DISABLE;
+ int wdiv = !w_uncompressed ? w_grc_div : WDIV_UNCOMPRESSED;
+
+ if (verbose&1) {
+ printf("slice: bitoffset %7d slicelen %5d zdiv %d wdiv %d wtrunc %d newpal %d palbits %d palsize %2d\n",
+ bb->pos, nvalues, zdiv, wdiv, w_grc_trunc, new_palette, p->palbits, p->palsize);
+ }
+
+ // Write slice header
+ bitbuf_put( bb, "ZDIV", 3, zdiv);
+ bitbuf_put( bb, "SLICELEN", 15, nvalues-1 );
+ bitbuf_put( bb, "WDIV", 3, wdiv);
+ bitbuf_put( bb, "WTRUNC", 1, w_grc_trunc );
+ bitbuf_put( bb, "NEWPAL", 1, new_palette );
+ if (new_palette) {
+ bitbuf_put( bb, "DIROFS", 5, p->direct_offset );
+ bitbuf_put( bb, "PALSIZE", 5, max(0, p->palsize-1));
+ bitbuf_put( bb, "PALBITS", 3, p->palbits-2 );
+ for(i=0; i<p->palsize; i++) {
+ bitbuf_put( bb, "PALETTE", p->palbits, p->lut[i] );
+ }
+ }
+
+ int z_nvalues = nvalues + (new_palette?1:0);
+ int w_pos=0, z_pos=0;
+ int w_unary0=0, w_unary1=0, w_unary1_len=0, w_q=-1, w_r=0;
+ int z_unary=0, z_q=-1, z_r=0;
+ int w_nsymbols=0, w_remain[12]={0};
+ int w_prev_enable=0, w_prev_nsymbols=0, w_prev_remain[12]={0};
+ int z_nsymbols=0, z_remain[12]={0};
+ int z_prev_enable=0, z_prev_nsymbols=0, z_prev_remain[12]={0};
+ int z_unary_len = z_grc_div<3 ? 12 : 8;
+ do {
+ int balance = p->use_zero_runs ? w_pos - z_pos : 0;
+ int w_enable = balance<8 && w_pos<nvalues;
+ int z_enable = balance>=0 && p->use_zero_runs && z_pos<z_nvalues;
+ if (w_enable) {
+ // Encode chunk (weights)
+ j=0;
+ w_nsymbols=0;
+ w_unary0=0;
+ w_unary1=0;
+ w_unary1_len=0;
+ int max_symbols = w_uncompressed && w_grc_div>5 ? 8 : 12;
+ while(j<max_symbols) {
+ if (w_q<0) {
+ if (w_pos<nvalues) {
+ int value = w_value[w_pos];
+ assert(value<512);
+ w_q = value>>w_grc_div;
+ w_r = value&((1<<w_grc_div)-1);
+ assert( w_q<=31 && (!w_grc_trunc || w_q<=2));
+ } else {
+ w_q = 0;
+ w_r = -1; // don't send remainder
+ }
+ }
+ while( w_q>=0 && j<max_symbols) {
+ w_unary0 |= w_q>0 ? (1<<j) : 0;
+ if (w_q>0) {
+ w_unary1 |= w_q>1 ? (1<<w_unary1_len) : 0;
+ w_unary1_len++;
+ }
+ j++;
+ w_q-=2;
+ if (w_grc_trunc)
+ w_q--;
+ }
+ if (w_q<0 && w_r>=0) {
+ w_remain[w_nsymbols] = w_r;
+ w_nsymbols++;
+ w_pos++;
+ }
+ }
+ }
+
+ if (z_enable) {
+ // Encode chunk (zrun)
+ j=0;
+ z_nsymbols=0;
+ z_unary=0;
+ while(j<z_unary_len) {
+ if (z_q<0) {
+ if (z_pos<z_nvalues) {
+ int value = z_value[z_pos];
+ z_q = value>>z_grc_div;
+ z_r = value&((1<<z_grc_div)-1);
+ } else {
+ z_q = 0;
+ z_r = -1;
+ }
+ }
+ while( z_q>=0 && j<z_unary_len) {
+ z_unary |= z_q>0 ? (1<<j) : 0;
+ j++;
+ z_q--;
+ }
+ if (z_q<0 && z_r>=0) {
+ z_remain[z_nsymbols] = z_r;
+ z_nsymbols++;
+ z_pos++;
+ }
+ }
+ }
+
+ // Write chunk to bitstream
+ if (w_enable && !w_uncompressed) {
+ bitbuf_put( bb, "WUNARY0", 12, w_unary0);
+ }
+ if (z_enable) {
+ bitbuf_put( bb, "ZUNARY", z_unary_len, z_unary);
+ }
+ if (w_enable && !w_uncompressed) {
+ bitbuf_put( bb, "WUNARY1", w_unary1_len, w_unary1);
+ }
+ if (w_prev_enable) {
+ for(i=0; i<w_prev_nsymbols; i++) {
+ bitbuf_put( bb, "WREMAIN", w_grc_div, w_prev_remain[i]);
+ }
+ }
+ if (z_prev_enable) {
+ for(i=0; i<z_prev_nsymbols; i++) {
+ bitbuf_put( bb, "ZREMAIN", z_grc_div, z_prev_remain[i]);
+ }
+ }
+ w_prev_enable = w_enable;
+ w_prev_nsymbols = w_nsymbols;
+ memcpy( w_prev_remain, w_remain, sizeof(w_prev_remain));
+ z_prev_enable = z_enable;
+ z_prev_nsymbols = z_nsymbols;
+ memcpy( z_prev_remain, z_remain, sizeof(z_prev_remain));
+ } while( w_prev_enable || z_prev_enable );
+
+ return bb->pos;
+}
+
+
+// return new bitpos
+static int encode_section( const int16_t *inbuf,
+ int size,
+ palette_t *p,
+ uint8_t *bitbuf,
+ int bitbuf_size,
+ int bitpos,
+ int verbose )
+{
+ int uncompressed_bits;
+
+ // Uncompressed mode can only be used if either all weights
+ // are in the palette OR if the palette is not used.
+ if (p->only_palette) {
+ // Uncompressed bits derived from palette size
+ uncompressed_bits=0;
+ while( (1<<uncompressed_bits) < p->palsize )
+ uncompressed_bits++;
+ } else if (p->palsize==0) {
+ // Uncompressed bits is palbits (which is the bitdepth of the greatest weight)
+ uncompressed_bits = p->palbits;
+ } else {
+ // Don't use uncompressed
+ uncompressed_bits = 100;
+ }
+
+ int *weight_values = malloc( size*sizeof(int) );
+ int *zrun_values = malloc( size*sizeof(int) );
+
+ // Get weights (or weight indicies) AND zero-runs from the input weight stream.
+ int i=0, n_weights = 0, zcnt;
+ while(1) {
+ if (p->use_zero_runs) {
+ zcnt=0;
+ // Count zero run
+ // Special case: if all weights in the section are zero, we must
+ // still ensure we have one coded weight so the the slice length
+ // doesn't become 0. Therefore we skip the first zero run and code
+ // the zero explicitly as a weight value instead
+ if (!p->only_zeros || i>0) {
+ while( i<size && inbuf[i]==0) {
+ zcnt++;
+ i++;
+ }
+ }
+ zrun_values[n_weights] = zcnt;
+ }
+ if (i==size)
+ break;
+ int value = p->inv_lut[inbuf[i]+256];
+ weight_values[n_weights] = value;
+ n_weights++;
+ i++;
+ }
+
+ // Search for good GRC parameters for the weight stream
+ int n_w_slice, w_bitcnt;
+ uint8_t *w_slice_cfg;
+ int *w_slice_pos;
+ w_slice_cfg = malloc( size );
+ w_slice_pos = malloc( size*sizeof(int) );
+ n_w_slice = search_grc_params( weight_values, n_weights, 0, uncompressed_bits, w_slice_cfg, w_slice_pos, size, 0, 0, &w_bitcnt);
+ if (n_weights==0)
+ n_w_slice = 0;
+
+ // Search for good GRC parameters for the zrun stream
+ int n_z_slice=0, z_bitcnt=0;
+ uint8_t *z_slice_cfg=0;
+ int *z_slice_pos=0;
+ if (p->use_zero_runs) {
+ z_slice_cfg = malloc( size );
+ z_slice_pos = malloc( size*sizeof(int) );
+ n_z_slice = search_grc_params( zrun_values, n_weights+1, 1, 0, z_slice_cfg, z_slice_pos, size, w_slice_pos, n_w_slice, &z_bitcnt);
+ }
+
+ // Encode bitstream slice
+ int pos=0, i_w_slice=0, i_z_slice=0, new_palette=1;
+ while(pos<n_weights || new_palette) {
+ int endpos=pos+32767; // max slice length
+
+ if (i_w_slice<n_w_slice && w_slice_pos[i_w_slice]<endpos) {
+ endpos = w_slice_pos[i_w_slice];
+ }
+
+ if (i_z_slice<n_z_slice && z_slice_pos[i_z_slice]<endpos) {
+ endpos = z_slice_pos[i_z_slice];
+ }
+
+ if (n_weights < endpos) {
+ endpos = n_weights;
+ }
+
+ // The first slice (when new_palette is 1) encodes zero runs both at the
+ // beginning and end (i.e. number of zero runs are len+1).
+ // The following slices only encode zero runs at the end (there cannot be
+ // any zeros in the beginning since they are encoded by the previous slice)
+ int len = endpos - pos;
+ int *zrun_buf = p->use_zero_runs ? zrun_values+pos+(!new_palette) : 0;
+ bitpos = encode_slice( weight_values+pos, zrun_buf, len,
+ p, new_palette, uncompressed_bits,
+ w_slice_cfg[i_w_slice], p->use_zero_runs ? z_slice_cfg[i_z_slice] : 0,
+ bitbuf, bitbuf_size, bitpos, verbose );
+ new_palette = 0;
+
+ if (i_w_slice<n_w_slice && w_slice_pos[i_w_slice]==endpos) {
+ i_w_slice++;
+ }
+ if (i_z_slice<n_z_slice && z_slice_pos[i_z_slice]==endpos) {
+ i_z_slice++;
+ }
+ pos = endpos;
+ }
+
+ // Free temporary buffers
+ free(w_slice_cfg);
+ free(w_slice_pos);
+ if (p->use_zero_runs) {
+ free(z_slice_cfg);
+ free(z_slice_pos);
+ }
+ free(weight_values);
+ free(zrun_values);
+
+ return bitpos;
+}
+
+// Encode the given weight stream
+// inbuf uncompressed 9bit signed weights
+// inbuf_size number of weights
+// outbuf compressed bitstream, buffer is malloced
+// verbose if non-zero, printf log
+// Return value is the size in bytes of the compressed output
+// Return -1 if error
+int mlw_encode( int16_t *inbuf, int inbuf_size, uint8_t **outbuf, int verbose) {
+ int i;
+ // Range check
+ for(i=0; i<inbuf_size; i++) {
+ if (inbuf[i]<-255 || inbuf[i]>255) {
+ printf("ERROR: weight out of range at index %d, weight value is %d (valid range is -255..255)\n", i, inbuf[i]);
+ return -1;
+ }
+ }
+
+ int bitbuf_size = inbuf_size*2+1024;
+ *outbuf = malloc( bitbuf_size );
+
+ // Analyse input data to find palette re-programming points
+ int n_restarts;
+ int *palette_restart_pos;
+ n_restarts = search_palette_sections( inbuf, inbuf_size, &palette_restart_pos);
+
+ // Compress each section (using a single palette) separately
+ int bitpos=0;
+ for(i=0; i<n_restarts; i++) {
+ palette_t palette;
+ int pos, size;
+ pos = palette_restart_pos[i];
+ size = (i<n_restarts-1 ? palette_restart_pos[i+1] : inbuf_size) - pos;
+ find_palette( inbuf+pos, size, &palette);
+ create_inverse_palette( &palette);
+ bitpos = encode_section( inbuf+pos, size, &palette,
+ *outbuf, bitbuf_size, bitpos, verbose );
+ }
+
+
+ // Add end of stream marker and align to 128bit
+ {
+ bitbuf_t bitbuf_s, *bb=&bitbuf_s;
+ bitbuf_init( bb, *outbuf, bitbuf_size, verbose&2?1:0 );
+ bb->pos = bitpos;
+ bitbuf_put( bb, "ZDIV", 3, ZDIV_EOS);
+ bitbuf_put( bb, "BYTEALIGN", (8-(bb->pos&7))&7, 0xff );
+
+ // Pad with 0xff until 64bit aligned
+ while( bb->pos & 127 ) {
+ bitbuf_put( bb, "PAD", 8, 0xff );
+ }
+ bitpos = bb->pos;
+ }
+ assert((bitpos&127)==0);
+ int outbuf_size = bitpos/8;
+ *outbuf = realloc( *outbuf, outbuf_size);
+
+ free(palette_restart_pos);
+
+ return outbuf_size;
+}
+
+void mlw_free_outbuf( uint8_t *outbuf ) {
+ if (outbuf)
+ free(outbuf);
+}
diff --git a/ethosu/mlw_codec/mlw_encode.h b/ethosu/mlw_codec/mlw_encode.h
new file mode 100644
index 0000000..a995ac6
--- /dev/null
+++ b/ethosu/mlw_codec/mlw_encode.h
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2020 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * 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 <stdint.h>
+
+#ifndef __MLW_ENCODE_H__
+#define __MLW_ENCODE_H__
+
+#ifdef _MSC_VER
+ #define EXPORTED __declspec(dllexport)
+#else
+ #define EXPORTED __attribute__((visibility("default")))
+#endif
+
+#if __cplusplus
+extern "C"
+{
+#endif
+
+EXPORTED
+int mlw_encode(int16_t *inbuf, int inbuf_size, uint8_t **outbuf, int verbose);
+
+EXPORTED
+void mlw_free_outbuf(uint8_t *outbuf);
+
+#if __cplusplus
+}
+#endif
+
+#endif
diff --git a/ethosu/mlw_codec/mlw_main.c b/ethosu/mlw_codec/mlw_main.c
new file mode 100644
index 0000000..9f72049
--- /dev/null
+++ b/ethosu/mlw_codec/mlw_main.c
@@ -0,0 +1,177 @@
+/*
+ * Copyright (c) 2020 Arm Limited. All rights reserved.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * 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
+ *
+ * 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 <stdlib.h>
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+#include <assert.h>
+#include <math.h>
+#include <getopt.h>
+#include <stdarg.h>
+#include "mlw_encode.h"
+#include "mlw_decode.h"
+
+static void fatal_error(const char *format, ...) {
+ va_list ap;
+ va_start (ap, format);
+ vfprintf(stderr, format, ap);
+ va_end(ap);
+ exit(1);
+}
+
+static void print_usage(void) {
+ printf("Usage:\n");
+ printf(" Encode: ./mlw_codec [<options>] [-o <outfile.mlw>] infiles.bin\n");
+ printf(" Decode: ./mlw_codec [<options>] -d [-o <outfile.bin>] infiles.mlw\n");
+ printf("\n");
+ printf("Options:\n");
+ printf(" -w The uncompressed weight file is an int16_t (word) stream.\n");
+ printf(" This is to support 9bit signed weights. Little endian is assuemd.\n");
+ printf(" The default format is int8_t (byte) stream (if -w is not specified)\n");
+ printf("\n");
+}
+
+// Read file into allocated buffer. Return length in bytes.
+static int read_file( FILE *f, uint8_t **buf) {
+
+ fseek(f, 0, SEEK_END);
+ int size = ftell(f);
+ fseek(f, 0, SEEK_SET);
+ *buf = malloc(size);
+ assert(*buf);
+ int rsize = fread(*buf, 1, size, f);
+ assert(rsize==size);
+ fclose(f);
+ return size;
+}
+
+
+#define MAX_INFILES 1000
+
+int main(int argc, char *argv[])
+{
+ int c, decode=0, inbuf_size, outbuf_size;
+ char *infile_name[MAX_INFILES], *outfile_name=0;
+ uint8_t *inbuf=0, *outbuf=0;
+ FILE *infile, *outfile=0;
+ int verbose=0, infile_idx=0;
+ int int16_format=0;
+
+ if (argc==1) {
+ print_usage();
+ exit(1);
+ }
+
+ // Parse command line options
+ while( optind < argc) {
+ // Parse options
+ while ((c = getopt (argc, argv, "di:o:v:w?")) != -1) {
+ switch (c) {
+ case 'd':
+ decode=1;
+ break;
+ case 'i':
+ assert(infile_idx<MAX_INFILES);
+ infile_name[infile_idx++]=optarg;
+ break;
+ case 'o':
+ outfile_name=optarg;
+ break;
+ case 'v':
+ verbose=atoi(optarg);
+ break;
+ case 'w':
+ int16_format=1;
+ break;
+ case '?':
+ print_usage();
+ exit(0);
+ }
+ }
+
+ if (optind<argc) {
+ assert(infile_idx<MAX_INFILES);
+ infile_name[infile_idx++]=argv[optind];
+ optind++;
+
+ }
+ }
+
+ if (outfile_name) {
+ outfile=fopen(outfile_name, "wb");
+ if (!outfile)
+ fatal_error("ERROR: cannot open outfile %s\n", outfile_name);
+ }
+
+ // Loop over input files
+ int nbr_of_infiles=infile_idx;
+ for(infile_idx=0; infile_idx<nbr_of_infiles; infile_idx++) {
+ infile=fopen(infile_name[infile_idx], "rb");
+ if (!infile)
+ fatal_error("ERROR: cannot open infile %s\n", infile_name[infile_idx]);
+
+ // Read infile to buffer
+ inbuf_size = read_file(infile, &inbuf);
+
+ if (!decode) {
+ // Encode
+ int i, n = int16_format ? inbuf_size/sizeof(int16_t) : inbuf_size;
+ int16_t *weights = malloc( n * sizeof(int16_t) );
+ for(i=0; i<n; i++) {
+ weights[i] = int16_format ? ((int16_t*)inbuf)[i] : ((int8_t*)inbuf)[i];
+ }
+ outbuf_size = mlw_encode( weights, n, &outbuf, verbose);
+ free(weights);
+ printf("Input size %d output size %d bpw %4.2f\n", n, outbuf_size, outbuf_size*8.0/n);
+ } else {
+ // Decode
+ int i, n;
+ int16_t *weights;
+ n = mlw_decode( inbuf, inbuf_size, &weights, verbose);
+ outbuf_size = int16_format ? n*sizeof(int16_t) : n;
+ outbuf = malloc( outbuf_size );
+ assert(outbuf);
+ for(i=0; i<n; i++) {
+ if (int16_format)
+ ((int16_t*)outbuf)[i] = weights[i];
+ else
+ outbuf[i] = weights[i];
+ }
+ free(weights);
+ printf("Input size %d output size %d bpw %4.2f\n", inbuf_size, n, inbuf_size*8.0/n);
+
+ }
+
+ if (outfile) {
+ fwrite(outbuf, 1, outbuf_size, outfile);
+ }
+
+ if (inbuf)
+ free(inbuf);
+ if (outbuf)
+ free(outbuf);
+ }
+
+ if (outfile) {
+ fclose(outfile);
+ }
+
+ return 0;
+}
diff --git a/ethosu/mlw_codec/test_mlw_codec.py b/ethosu/mlw_codec/test_mlw_codec.py
new file mode 100644
index 0000000..b868721
--- /dev/null
+++ b/ethosu/mlw_codec/test_mlw_codec.py
@@ -0,0 +1,43 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Simple example of the usage of mlw_codec.
+
+import sys
+
+from ethosu import mlw_codec
+
+
+# Simple example
+if __name__ == "__main__":
+ weights = [0, 2, 3, 0, -1, -2, -3, 0, 0, 0, 1, -250, 240] * 3
+ print("Original weights :", weights)
+
+ compressed_weights = mlw_codec.encode(weights)
+ print("Compressed weights :", len(compressed_weights), compressed_weights)
+
+ uncompressed_weights = mlw_codec.decode(compressed_weights)
+ print("Uncompressed weights:", uncompressed_weights)
+
+ if weights != uncompressed_weights:
+ print("TEST FAILED")
+ sys.exit(1)
+ else:
+ print("TEST PASSED")
+ sys.exit(0)
diff --git a/ethosu/vela/__init__.py b/ethosu/vela/__init__.py
new file mode 100644
index 0000000..07d8d79
--- /dev/null
+++ b/ethosu/vela/__init__.py
@@ -0,0 +1,20 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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 ._version import __version__
+from .vela import main
+
+__all__ = [main, __version__]
diff --git a/ethosu/vela/__main__.py b/ethosu/vela/__main__.py
new file mode 100644
index 0000000..9bf74c7
--- /dev/null
+++ b/ethosu/vela/__main__.py
@@ -0,0 +1,22 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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 sys
+
+from .vela import main
+
+if __name__ == "__main__":
+ sys.exit(main())
diff --git a/ethosu/vela/_version.py b/ethosu/vela/_version.py
new file mode 100644
index 0000000..f3888c3
--- /dev/null
+++ b/ethosu/vela/_version.py
@@ -0,0 +1,19 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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 pkg_resources
+
+__version__ = pkg_resources.get_distribution("ethos-u-vela").version
\ No newline at end of file
diff --git a/ethosu/vela/architecture_features.py b/ethosu/vela/architecture_features.py
new file mode 100644
index 0000000..4a03d0e
--- /dev/null
+++ b/ethosu/vela/architecture_features.py
@@ -0,0 +1,618 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Holds a container for Ethos-U55/System architecture parameters.
+
+from .nn_graph import MemArea, TensorPurpose, NpuBlockType, TensorFormat
+from .numeric_util import round_up, round_up_divide
+from collections import namedtuple
+from configparser import ConfigParser
+from .supported_operators import SupportedOperators
+import numpy as np
+import enum
+
+PointXY = namedtuple("PointXY", "x y")
+PointXYZ = namedtuple("PointXYZ", "x y z")
+
+
+class Block:
+ def __init__(self, w, h, d):
+ self.width = w
+ self.height = h
+ self.depth = d
+
+ def __eq__(self, other):
+ if self.width == other.width and self.height == other.height and self.depth == other.depth:
+ return True
+ else:
+ return False
+
+ def __repr__(self):
+ return "<Block: {0},{1},{2}>".format(self.width, self.height, self.depth)
+
+ @classmethod
+ def from_string(cls, s):
+ w, h, c = (int(v) for v in s.split("x"))
+ return cls(w, h, c)
+
+
+class Rect:
+ def __init__(self, x, y, z, x2, y2, z2):
+ self.x = x
+ self.y = y
+ self.z = z
+ self.x2 = x2
+ self.y2 = y2
+ self.z2 = z2
+
+ def start(self):
+ return PointXYZ(self.x, self.y, self.z)
+
+ def end(self):
+ return PointXYZ(self.x2, self.y2, self.z2)
+
+ def size(self):
+ return Block(self.x2 - self.x + 1, self.y2 - self.y + 1, self.z2 - self.z + 1)
+
+ def __repr__(self):
+ return "<Rect: ({0},{1},{2}) ({3},{4},{5})>".format(self.x, self.y, self.z, self.x2, self.y2, self.z2)
+
+
+class Kernel:
+ def __init__(self, w, h, sx=1, sy=1, dx=1, dy=1):
+ assert sx > 0 and sy > 0
+ assert dx > 0 and dy > 0
+ self.width = w
+ self.height = h
+ self.stride = PointXY(sx, sy)
+ self.dilation = PointXY(dx, dy)
+
+
+class SHRAMElements:
+ IFM8 = 0
+ IFM16 = 1
+ IFM8_Elementwise = 2
+ IFM16_Elementwise = 3
+ Acc16 = 4
+ Acc32 = 5
+ Acc40 = 6
+ Last = Acc40
+ BitSizes = np.array([8, 16, 8, 16, 16, 32, 40], np.int32)
+
+
+class SHRAMBlockConfig:
+ def __init__(self, sizes, banks):
+ assert len(banks) == SHRAMElements.Last + 1
+ self.sizes = sizes
+ self.banks = banks
+
+
+# Area indices must match Ethos-U55 SHRAM layout spec
+class SharedBufferArea(enum.IntEnum):
+ OFM = 0
+ Weights = 1
+ IFM = 2
+ Accumulators = 3
+ Size = Accumulators + 1
+
+
+class ArchitectureFeatures:
+ """This class is a container for various parameters of the Ethos-U55 core
+and system configuration that can be tuned, either by command line
+parameters or by the Ethos-U55 architects. The class is often passed
+around to passes that need to do architecture-dependent actions.
+
+Note the difference between ArchitectureFeatures and CompilerOptions
+- ArchitectureFeatures is for changing the Ethos-U55 and system architecture
+- CompilerOptions is for changing the behaviour of the compiler
+
+"""
+
+ ArchitectureConfig = namedtuple(
+ "ArchitectureConfig", "macs cores ofm_ublock ifm_ublock shram_banks shram_granules elem_units"
+ )
+ accelerator_configs = {
+ "ethos-u55-256": ArchitectureConfig(256, 1, Block(2, 2, 8), Block(2, 2, 8), 48, [8, 8, 8, 8, 8, 16, 20], 8),
+ "ethos-u55-128": ArchitectureConfig(128, 1, Block(2, 1, 8), Block(2, 2, 8), 24, [4, 4, 4, 4, 4, 8, 12], 4),
+ "ethos-u55-64": ArchitectureConfig(64, 1, Block(1, 1, 8), Block(1, 1, 8), 16, [2, 2, 2, 2, 4, 4, 8], 2),
+ "ethos-u55-32": ArchitectureConfig(32, 1, Block(1, 1, 4), Block(1, 1, 8), 16, [2, 2, 2, 2, 4, 4, 4], 1),
+ }
+
+ OFMSplitDepth = 16
+
+ def __init__(
+ self,
+ vela_config: ConfigParser,
+ accelerator_config,
+ system_config,
+ permanent_storage,
+ inter_pass_cycle_delay,
+ dram_bandwidth,
+ override_block_config,
+ block_config_limit,
+ global_memory_clock_scale,
+ max_blockdep,
+ ):
+ accelerator_config = accelerator_config.lower()
+ self.vela_config = vela_config
+ self.accelerator_config = accelerator_config
+ if not self.accelerator_config in ArchitectureFeatures.accelerator_configs:
+ raise Exception("Unknown accelerator configuration " + self.accelerator_config)
+ accel_config = ArchitectureFeatures.accelerator_configs[self.accelerator_config]
+ self.config = accel_config
+
+ self.system_config = system_config
+
+ is_yoda_system = "yoda-" in self.accelerator_config
+
+ if is_yoda_system:
+ self.sram_size = 256 * 1024
+ else:
+ self.sram_size = 200 * 1024 * 1024
+
+ self.ncores = accel_config.cores
+ self.ofm_ublock = accel_config.ofm_ublock
+ self.ifm_ublock = accel_config.ifm_ublock
+ self.subkernel_max = Block(8, 8, 65536)
+ self.ofm_block_max = Block(64, 32, 128)
+ self.override_block_config = override_block_config
+ self.block_config_limit = block_config_limit
+
+ self.global_memory_clock_scale = global_memory_clock_scale
+ if self.global_memory_clock_scale <= 0.0 or self.global_memory_clock_scale > 1.0:
+ raise Exception(
+ "Invalid global_memory_clock_scale = "
+ + str(self.global_memory_clock_scale)
+ + " (must be > 0.0 and <= 1.0)"
+ )
+
+ self.max_blockdep = max_blockdep
+
+ dpu_min_height = accel_config.ofm_ublock.height
+ dpu_min_width = accel_config.ofm_ublock.width
+ dpu_dot_product_width = 8
+ dpu_min_ofm_channels = accel_config.ofm_ublock.depth
+
+ self.num_elem_wise_units = accel_config.elem_units
+ self.num_macs_per_cycle = dpu_min_height * dpu_min_width * dpu_dot_product_width * dpu_min_ofm_channels
+
+ self.memory_clock_scales = np.zeros(MemArea.Size)
+ self.memory_port_widths = np.zeros(MemArea.Size)
+
+ # Get system configuration
+ self.__read_sys_config()
+
+ # apply the global memory clock scales to the individual ones from the system config
+ for mem in MemArea.all():
+ self.memory_clock_scales[mem] *= self.global_memory_clock_scale
+
+ self.memory_clocks = self.memory_clock_scales * self.npu_clock
+ self.memory_bandwidths_per_cycle = self.memory_port_widths * self.memory_clock_scales / 8
+
+ if dram_bandwidth != 0:
+ self.memory_bandwidths_per_cycle[MemArea.Dram] = dram_bandwidth * 1e9 / self.npu_clock
+
+ self.memory_bandwidths_per_second = self.memory_bandwidths_per_cycle * self.npu_clock
+
+ # sizes as N x H x W x C. we need to round up to these when allocating storage
+ self.storage_rounding_quantums = {
+ TensorFormat.Unknown: (1, 1, 1, 1),
+ TensorFormat.WeightsCompressed: (1, 1, 1, 1),
+ TensorFormat.NHWC: (1, 1, 1, 1),
+ TensorFormat.NHCWB16: (1, 1, 1, 16),
+ }
+
+ # brick sizes as N x H x W x C. We have to fetch whole bricks at a time
+ self.brick_sizes = {
+ TensorFormat.Unknown: (1, 1, 1, 1),
+ TensorFormat.WeightsCompressed: (1, 1, 1, 1),
+ TensorFormat.NHWC: (1, 1, 1, 1),
+ TensorFormat.NHCWB16: (1, 1, 1, 16),
+ }
+
+ self.inter_pass_cycle_delay = inter_pass_cycle_delay
+
+ self.default_weight_format = TensorFormat.WeightsCompressed
+ self.default_feature_map_format = TensorFormat.NHWC
+
+ if permanent_storage != MemArea.OffChipFlash:
+ self.permanent_storage_mem_area = permanent_storage
+
+ self.tensor_storage_mem_area = {
+ # permanent mem_area
+ TensorPurpose.Weights: self.permanent_storage_mem_area,
+ TensorPurpose.FeatureMap: self.feature_map_storage_mem_area,
+ }
+
+ self.tensor_load_mem_area = dict(self.tensor_storage_mem_area)
+
+ if self.tensor_storage_mem_area[TensorPurpose.Weights] in (MemArea.OffChipFlash,):
+ self.tensor_load_mem_area[TensorPurpose.Weights] = MemArea.Sram
+
+ self.min_block_sizes = {
+ NpuBlockType.Default: (dpu_min_height, dpu_min_width),
+ NpuBlockType.VectorProduct: (1, 1),
+ NpuBlockType.ConvolutionMxN: (dpu_min_height, dpu_min_width),
+ NpuBlockType.Pooling: (dpu_min_height, dpu_min_width),
+ NpuBlockType.ConvolutionDepthWise: (dpu_min_height, dpu_min_width),
+ NpuBlockType.ElementWise: (1, 1),
+ }
+
+ self.sub_kernel_limits = {
+ NpuBlockType.Default: (8, 8),
+ NpuBlockType.VectorProduct: (1, 1),
+ NpuBlockType.ConvolutionMxN: (8, 8),
+ NpuBlockType.Pooling: (8, 8),
+ NpuBlockType.ConvolutionDepthWise: (8, 8),
+ NpuBlockType.ElementWise: (1, 1),
+ }
+
+ # weights for scheduler search
+ from .npu_performance import make_bandwidth_array
+
+ self.bandwidth_weights = make_bandwidth_array()
+ self.bandwidth_weights[MemArea.Sram] = 1.0
+ self.bandwidth_weights[MemArea.Dram] = 10.0
+ self.bandwidth_weights[MemArea.OnChipFlash] = 2.0
+ self.bandwidth_weights[MemArea.OffChipFlash] = 20.0
+ self.cycles_weight = 40
+ self.max_sram_used_weight = 1000
+
+ if is_yoda_system:
+ self.max_sram_used_weight = 0
+
+ # Shared Buffer Block allocations
+ self.shram_bank_size = 1024 # bytes
+ self.shram_size_bytes = accel_config.shram_banks * self.shram_bank_size
+ self.shram_reserved_output_banks = 2
+ self.shram_reserved_weight_banks = 0
+ self.shram_reserved_unused_banks = 2 if accel_config.shram_banks > 16 else 0
+ self.shram_total_banks = accel_config.shram_banks - self.shram_reserved_unused_banks
+ self.shram_bank_granules = np.array(accel_config.shram_granules, np.int32)
+
+ # Build a map of acceptable IFM/OFM block configurations up to the maximum
+ # IFM/OFM block size.
+ ifm_block_max = self.get_ifm_block_size(32, self.ofm_block_max, Kernel(8, 8))
+ self.block_config_map = dict()
+ self.generate_block_config_map(Block(ifm_block_max.width, ifm_block_max.height, 128))
+
+ # Setup supported operators and restriction checkers class
+ self.supported_operators = SupportedOperators()
+
+ # Calculate block configuration for ALL known IFM operations and
+ # accumulator sizes. Consumers will need to select their preferred
+ # operation and bit-width at read-time.
+ def generate_block_config(self, width, height, depth):
+ # Number of bytes required for any SRAM element for a FM of given dimensions
+ size_bytes = (SHRAMElements.BitSizes * (height * width * depth)) // 8
+ # Convert byte size (rounded) to size in banks
+ size_banks = round_up_divide(size_bytes, self.shram_bank_size)
+ size_banks *= 2 # Double buffer the IFM/Acc (need twice as many banks)
+ # Round bank requirement to bank granularity
+ required_banks = round_up(size_banks, self.shram_bank_granules)
+ return SHRAMBlockConfig(size_bytes, required_banks)
+
+ @staticmethod
+ def make_block_config_key(width, height, depth):
+ return (int(height), int(width), int(depth))
+
+ def get_block_config(self, width, height, depth):
+ assert depth <= self.ofm_block_max.depth
+ key = ArchitectureFeatures.make_block_config_key(width, height, depth)
+ config = self.block_config_map.get(key, None)
+ return config
+
+ # Generate a key:value map of possible block configurations, where the
+ # key is compounded from the block dimensions: 0x00HHWWCC
+ def generate_block_config_map(self, block: Block):
+ for h in range(1, block.height + 1):
+ for w in range(1, block.width + 1):
+ # All possible IFM/OFM depth values
+ for c in [4, 8, 12, 16, 24, 32, 40, 48, 56, 64, 72, 80, 88, 96, 104, 112, 120, 128]:
+ key = ArchitectureFeatures.make_block_config_key(w, h, c)
+ self.block_config_map[key] = self.generate_block_config(w, h, c)
+
+ def calc_ifm_block_depth(self, ifm_depth, ifm_bits):
+ assert ifm_bits == 8 or ifm_bits == 16
+ assert ifm_depth > 0
+ ifm_depth = round_up(ifm_depth, self.ifm_ublock.depth)
+ max_block_depth = 32 if ifm_bits == 8 else 16
+ return min(max_block_depth, ifm_depth)
+
+ # Calculate the size of the IFM block given a depth, target OFM block and a kernel
+ def get_ifm_block_size(
+ self, ifm_block_depth, ofm_block: Block, kernel: Kernel, subkernel: Block = Block(8, 8, 65536)
+ ):
+ upscaling = 1
+ # Height
+ ifm_odd_2x_height_enable = 0
+ dilated_kernel_height = ((kernel.height - 1) * kernel.dilation.y) + 1
+ ifm_block_height = (
+ (ofm_block.height - 1) * kernel.stride.y
+ + min(subkernel.height, dilated_kernel_height)
+ + ifm_odd_2x_height_enable
+ ) // upscaling
+
+ if kernel.stride.y == 1:
+ ifm_block_height = round_up(ifm_block_height, self.ofm_ublock.height)
+ elif kernel.stride.y == 2:
+ if (self.ofm_ublock.height == 2) and (ifm_block_height % 4 == 2):
+ ifm_block_height = ifm_block_height + 2
+ else:
+ ifm_block_height = round_up(ifm_block_height, self.ofm_ublock.height)
+ else:
+ assert False
+
+ # Width
+ ifm_odd_2x_width_enable = 0
+ dilated_kernel_width = ((kernel.width - 1) * kernel.dilation.x) + 1
+ ifm_block_width = (
+ (ofm_block.width - 1) * kernel.stride.x
+ + min(subkernel.width, dilated_kernel_width)
+ + ifm_odd_2x_width_enable
+ ) // upscaling
+
+ if kernel.stride.x == 1:
+ ifm_block_width = round_up(ifm_block_width, self.ofm_ublock.width)
+ elif kernel.stride.x == 2:
+ if (self.ofm_ublock.width == 2) and (ifm_block_width % 4 == 2):
+ ifm_block_width = ifm_block_width + 2
+ else:
+ ifm_block_width = round_up(ifm_block_width, self.ofm_ublock.width)
+ else:
+ assert False
+
+ return Block(ifm_block_width, ifm_block_height, ifm_block_depth)
+
+ @staticmethod
+ def intersects(start_a, end_a, start_b, end_b):
+ start_x = max(start_a[0], start_b[0])
+ end_x = min(end_a[0], end_b[0])
+ start_y = max(start_a[1], start_b[1])
+ end_y = min(end_a[1], end_b[1])
+ start_z = max(start_a[2], start_b[2])
+ end_z = min(end_a[2], end_b[2])
+ return ((end_x - start_x) > 0) and ((end_y - start_y) > 0) and ((end_z - start_z) > 0)
+
+ # Block job dependency:
+ # Does the VOLUME of IFMs for block job B(0) overlap with VOLUME of OFMs block jobs A(8,9,10)
+ #
+ # A | B
+ # ----------------------+------------------
+ # .... 3,4,5,6,7,8,9,10 | 0,1,2,3,4,5,6,8 10 < JOB NUMBER
+ # |<------->| dependency offset
+ #
+ MAX_BLOCKDEP = 3
+
+ # Get the coordinates of a block offset from either the end (negative)
+ # or the start (zero or positive) of the given 3d area
+ def get_offset_block_coords(self, area: Rect, block: Block, offset):
+ size = area.size()
+ # Dimensions of the region, in blocks
+ width_blocks = round_up_divide(size.width, block.width)
+ height_blocks = round_up_divide(size.height, block.height)
+ depth_blocks = round_up_divide(size.depth, block.depth)
+ total_blocks = width_blocks * height_blocks * depth_blocks
+ if offset < 0:
+ index = total_blocks + offset
+ else:
+ index = offset
+
+ if index >= total_blocks:
+ return None
+
+ # Coordinates of the indexed block
+ coord_z = block.depth * (index % depth_blocks)
+ coord_y = block.height * (index // (depth_blocks * width_blocks))
+ coord_x = block.width * ((index // depth_blocks) % width_blocks)
+
+ return (coord_x + area.x, coord_y + area.y, coord_z + area.z)
+
+ def get_first_job_input_volume(
+ self, ifm: Rect, ofm: Rect, ifm_block_depth, ofm_block: Block, kernel: Kernel, padLT, block_offset
+ ):
+ # Get ifm block size (jobs are invisibly decomposed into subkernels)
+ ifm_block = self.get_ifm_block_size(ifm_block_depth, ofm_block, kernel, self.ofm_block_max)
+ ifm_depth_blocks = round_up_divide(ifm.size().depth, ifm_block_depth)
+
+ # Which OFM block are we calculating
+ ofm_coord = self.get_offset_block_coords(ofm, ofm_block, block_offset // ifm_depth_blocks)
+ if ofm_coord is None:
+ return None
+
+ # Coordinate of the source IFM block
+ ifm_coord_x = max(0, ofm_coord[0] * kernel.stride.x - padLT[0])
+ ifm_coord_y = max(0, ofm_coord[1] * kernel.stride.y - padLT[1])
+ ifm_coord_z = ifm.z + (block_offset % ifm_depth_blocks) * ifm_block.depth
+
+ # IFM block that will be sampled for the FIRST+block_offset job in the next operator's OFM
+ start_coord = (ifm_coord_x, ifm_coord_y, ifm_coord_z)
+ end_coord = (
+ start_coord[0] + ifm_block.width,
+ start_coord[1] + ifm_block.height,
+ start_coord[2] + ifm_block.depth,
+ )
+
+ return (start_coord, end_coord, 1) # start, end, total jobs
+
+ def get_prev_job_output_volume(
+ self, ifm: Block, ofm: Rect, ifm_block_depth, ofm_block: Block, kernel: Kernel, block_offset
+ ):
+ assert block_offset >= 0
+
+ # Get OFM block's volume coordinates
+ start_coord = self.get_offset_block_coords(ofm, ofm_block, -1 - block_offset)
+ if start_coord is None:
+ return None
+ end_coord = (
+ start_coord[0] + ofm_block.width,
+ start_coord[1] + ofm_block.height,
+ start_coord[2] + ofm_block.depth,
+ )
+
+ # Calculate how many IFM blocks this OFM block requires (i.e how many jobs)
+ ifm_block = self.get_ifm_block_size(ifm_block_depth, ofm_block, kernel, self.ofm_block_max)
+ ifm_depth_blocks = round_up_divide(ifm.size().depth, ifm_block_depth)
+ ifm_depth_blocks = 1 # Overwrite with 1 to force OFM block dependency, not IFM
+
+ return (start_coord, end_coord, ifm_depth_blocks) # start, end, total jobs for this OFM block
+
+ def calc_block_dep(
+ self,
+ prev_ifm: Block,
+ prev_ofm: Block,
+ prev_ifm_block_depth,
+ prev_ofm_block: Block,
+ prev_kernel: Kernel,
+ ifm: Block,
+ ofm: Block,
+ ifm_block_depth,
+ ofm_block: Block,
+ kernel: Kernel,
+ padLT,
+ ):
+
+ blockdep = ArchitectureFeatures.MAX_BLOCKDEP
+
+ # Iterate over the next BLOCKDEP inputs, checking to see if a sliding window
+ # of IFM area overlaps with any previous OFM block generation.
+ elapsed_jobs = 0
+ ifm_depth = ifm.size().depth
+ for forward_offset in range(ArchitectureFeatures.MAX_BLOCKDEP):
+ # This is the IFM block we want to sample from
+ in_area = self.get_first_job_input_volume(
+ ifm, ofm, ifm_block_depth, ofm_block, kernel, padLT, forward_offset
+ )
+ if in_area is None:
+ break
+
+ # Try several previous-OFM blocks in the past (they still might comprise multiple IFM jobs)
+ outstanding_jobs = 0
+ for block_offset in range(ArchitectureFeatures.MAX_BLOCKDEP):
+ # This is the OFM block being generated by the previous op
+ out_area = self.get_prev_job_output_volume(
+ prev_ifm, prev_ofm, prev_ifm_block_depth, prev_ofm_block, prev_kernel, block_offset
+ )
+ if out_area is None:
+ break
+
+ # Block dependency is the max number of allowed outstanding jobs
+ # in the pipeline. Selected by determining how many jobs occur
+ # in between two operators' overlapping OFM->IFM block volumes
+ if ArchitectureFeatures.intersects(in_area[0], in_area[1], out_area[0], out_area[1]):
+ break
+ # Early exit if no intersections and we've seen enough jobs in the pipeline
+ elif outstanding_jobs > ArchitectureFeatures.MAX_BLOCKDEP:
+ break
+
+ # This OFM had this many jobs (accumulate over multiple OFM blocks)
+ outstanding_jobs += out_area[2]
+
+ blockdep = min(blockdep, elapsed_jobs + outstanding_jobs)
+ elapsed_jobs += in_area[2]
+ # Early exit if no intersections and we've seen enough jobs in the pipeline
+ if elapsed_jobs > ArchitectureFeatures.MAX_BLOCKDEP:
+ break
+
+ return blockdep
+
+ def cpu_cycle_estimate(self, op):
+ """
+ Gets estimated performance of a CPU operation, based on a linear model of intercept, slope,
+ specified in the vela config file, in ConfigParser file format (.ini file).
+ Example configuration snippet:
+ [CpuPerformance.MyOperationType]
+ Cortex-Mx.intercept=<some float value>
+ Cortex-Mx.slope=<some float value>
+ """
+ section = "CpuPerformance." + op.type
+ if self.vela_config is not None and section in self.vela_config:
+ op_config = self.vela_config[section]
+ try:
+ intercept = float(op_config.get(self.cpu_config + ".intercept", op_config["default.intercept"]))
+ slope = float(op_config.get(self.cpu_config + ".slope", op_config["default.slope"]))
+ n_elements = op.inputs[0].elements()
+ cycles = intercept + n_elements * slope
+ return cycles
+ except:
+ print("Error: Reading CPU cycle estimate in vela configuration file, section {}".format(section))
+ raise
+
+ print("Warning: No configured CPU performance estimate for", op.type)
+ return 0
+
+ def __read_sys_config(self):
+ """
+ Gets the system configuration with the given name from the vela configuration file
+ Example configuration snippet:
+ [SysConfig.MyConfigName]
+ npu_freq=<some float value>
+ cpu=Cortex-Mx
+ ...
+ """
+ # Get system configuration from the vela configuration file
+ if self.vela_config is None:
+ print("Warning: Using default values for system configuration")
+ else:
+ section_key = "SysConfig." + self.system_config
+ if not section_key in self.vela_config:
+ raise Exception("Unknown system configuration " + self.system_config)
+
+ try:
+ self.npu_clock = float(self.__sys_config("npu_freq", "500e6"))
+ self.cpu_config = self.__sys_config("cpu", "Cortex-M7")
+
+ self.memory_clock_scales[MemArea.Sram] = float(self.__sys_config("Sram_clock_scale", "1"))
+ self.memory_port_widths[MemArea.Sram] = int(self.__sys_config("Sram_port_width", "64"))
+
+ self.memory_clock_scales[MemArea.OnChipFlash] = float(self.__sys_config("OnChipFlash_clock_scale", "1"))
+ self.memory_port_widths[MemArea.OnChipFlash] = int(self.__sys_config("OnChipFlash_port_width", "64"))
+
+ self.memory_clock_scales[MemArea.OffChipFlash] = float(
+ self.__sys_config("OffChipFlash_clock_scale", "0.25")
+ )
+ self.memory_port_widths[MemArea.OffChipFlash] = int(self.__sys_config("OffChipFlash_port_width", "32"))
+
+ self.memory_clock_scales[MemArea.Dram] = float(self.__sys_config("Dram_clock_scale", "1"))
+ self.memory_port_widths[MemArea.Dram] = int(self.__sys_config("Dram_port_width", "32"))
+
+ self.fast_storage_mem_area = MemArea[self.__sys_config("fast_storage_mem_area", "Sram")]
+ self.feature_map_storage_mem_area = MemArea[self.__sys_config("feature_map_storage_mem_area", "Sram")]
+ self.permanent_storage_mem_area = MemArea[self.__sys_config("permanent_storage_mem_area", "OffChipFlash")]
+ if self.permanent_storage_mem_area not in set((MemArea.OnChipFlash, MemArea.OffChipFlash)):
+ raise Exception(
+ "Invalid permanent_storage_mem_area = "
+ + str(self.permanent_storage_mem_area)
+ + " (must be 'OnChipFlash' or 'OffChipFlash'). To store the weights and other constant data in SRAM"
+ " select 'OnChipFlash'"
+ )
+ except:
+ print("Error: Reading System Configuration in vela configuration file, section {}".format(section_key))
+ raise
+
+ def __sys_config(self, key, default_value):
+ """
+ Gets the system configuration value with the given key from the vela config file.
+ """
+ if self.vela_config is None:
+ return default_value
+ section = "SysConfig." + self.system_config
+ result = self.vela_config[section].get(key, None)
+ if result is None:
+ raise Exception("Error: System Configuration Missing key {} in section [{}] ".format(key, section))
+ return result
diff --git a/ethosu/vela/compiler_driver.py b/ethosu/vela/compiler_driver.py
new file mode 100644
index 0000000..7f8c4ca
--- /dev/null
+++ b/ethosu/vela/compiler_driver.py
@@ -0,0 +1,204 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Contains the main sequencing of the compiler.
+
+from . import graph_optimiser
+from . import mark_tensors
+from . import insert_dma
+from . import pass_packing
+from . import scheduler
+from . import tensor_allocation
+from . import npu_performance
+import time
+
+from . import high_level_command_stream
+from . import high_level_command_stream_generator
+from . import register_command_stream_generator
+from . import extract_npu_subgraphs
+from . import npu_serialisation
+from . import weight_compressor
+from . import live_range
+from .tensor import MemArea
+from .nn_graph import TensorAllocator, PassPlacement
+from .rewrite_graph import verify_graph_health, verify_subgraph_health
+
+
+class CompilerOptions:
+ """Set of options to change compiler behaviour - verbosity, targets, turning off passes.
+
+Note the difference between ArchitectureFeatures and CompilerOptions
+- ArchitectureFeatures is for changing the Ethos-U55 and system architecture
+- CompilerOptions is for changing the behaviour of the compiler
+"""
+
+ def __init__(
+ self,
+ verbose_graph=False,
+ verbose_quantization=False,
+ verbose_packing=False,
+ verbose_tensor_purpose=False,
+ verbose_tensor_format=False,
+ verbose_allocation=False,
+ verbose_high_level_command_stream=False,
+ verbose_register_command_stream=False,
+ verbose_operators=False,
+ show_minimum_possible_allocation=False,
+ show_cpu_operations=False,
+ tensor_allocator=TensorAllocator.Greedy,
+ timing=False,
+ output_dir="outputs",
+ ):
+
+ self.verbose_graph = verbose_graph
+ self.verbose_quantization = verbose_quantization
+ self.verbose_packing = verbose_packing
+ self.verbose_tensor_purpose = verbose_tensor_purpose
+ self.verbose_tensor_format = verbose_tensor_format
+ self.verbose_allocation = verbose_allocation
+ self.verbose_high_level_command_stream = verbose_high_level_command_stream
+ self.verbose_register_command_stream = verbose_register_command_stream
+ self.verbose_operators = verbose_operators
+ self.show_minimum_possible_allocation = show_minimum_possible_allocation
+ self.show_cpu_operations = show_cpu_operations
+ self.tensor_allocator = tensor_allocator
+ self.timing = timing
+ self.output_dir = output_dir
+
+ def __str__(self):
+ return type(self).__name__ + ": " + str(self.__dict__)
+
+ __repr__ = __str__
+
+
+def compiler_driver(nng, arch, options, scheduler_options):
+ assert verify_graph_health(nng)
+ nng = graph_optimiser.optimise_graph_a(nng, arch, options.verbose_graph)
+ assert verify_graph_health(nng)
+
+ if options.verbose_quantization:
+ nng.print_graph_with_tensor_quantization()
+
+ nng = graph_optimiser.optimise_graph_b(nng, arch, options.verbose_graph)
+ assert verify_graph_health(nng)
+
+ nng = mark_tensors.mark_tensor_purpose(nng, arch, options.verbose_tensor_purpose)
+ assert verify_graph_health(nng)
+ nng = insert_dma.insert_dma_commands(nng, arch, options.verbose_graph)
+ assert verify_graph_health(nng)
+ pass_packing.pack_into_passes(nng, arch, options.verbose_packing)
+ assert verify_graph_health(nng)
+
+ extract_npu_subgraphs.extract_npu_subgraphs(nng, arch)
+
+ mark_tensors.mark_tensor_format(nng, arch, options.verbose_tensor_format)
+ assert verify_graph_health(nng)
+ if options.timing:
+ start = time.time()
+
+ # Run the scheduler
+ scheduler.schedule_passes(nng, arch, scheduler_options)
+
+ if options.timing:
+ stop = time.time()
+ print("Scheduling took %f s" % (stop - start))
+ start = time.time()
+
+ # Update the compressed weights now that we have determined the
+ # block config, and calc and pack the scales and biases
+ weight_compressor.update_pass_weight_and_scale_tensors(nng, arch)
+
+ # Memory area for all non-constant tensors (Cpu and Npu)
+ non_const_mem_area = MemArea.Sram
+
+ # LiveRanges for constant tensors for all Npu subgraphs
+ permanent_storage = arch.permanent_storage_mem_area
+ lr_graph_flash = live_range.LiveRangeGraph()
+
+ # Placeholders for scratch and flash tensors that are common for all Npu subgraphs
+ scratch_tens = None
+ flash_tens = None
+
+ # Calculate live ranges for all constant Npu tensors, in permanent storage
+ for sg in nng.subgraphs:
+ if sg.placement == PassPlacement.Npu:
+ lr_graph_flash = live_range.extract_live_ranges_from_cascaded_passes(
+ sg, permanent_storage, ignore_subgraph_input_output_tensors=True, lr_graph=lr_graph_flash
+ )
+
+ # Allocate all Npu constant tensors to the first Npu subgraph since it is
+ # processed first during serialization into tensors
+ first_npu_sg = nng.subgraphs[1]
+ assert first_npu_sg.placement == PassPlacement.Npu
+ tensor_allocation.allocate_tensors(
+ nng,
+ first_npu_sg,
+ arch,
+ permanent_storage,
+ scheduler_options.use_ifm_ofm_overlap,
+ options.tensor_allocator,
+ options.verbose_allocation,
+ options.show_minimum_possible_allocation,
+ lr_graph_flash,
+ )
+
+ # Allocate all non-constant tensors to the root, i.e. Cpu, subgraph. This step
+ # will start at the root subgraph's input and traverse from top to bottom. When
+ # it comes across an Npu-op it will extract live ranges for it's corresponding
+ # Npu subgraph and add them to the root's live range graph. Finally, all of the
+ # non-constant tensors are allocated together
+ root_sg = nng.get_root_subgraph()
+ tensor_allocation.allocate_tensors(
+ nng,
+ root_sg,
+ arch,
+ non_const_mem_area,
+ scheduler_options.use_ifm_ofm_overlap,
+ options.tensor_allocator,
+ options.verbose_allocation,
+ options.show_minimum_possible_allocation,
+ )
+
+ # Generate command streams and serialise Npu-ops into tensors
+ for sg in nng.subgraphs:
+ high_level_command_stream_generator.generate_high_level_command_stream(
+ nng, sg, arch, options.verbose_high_level_command_stream
+ )
+ register_command_stream_generator.generate_register_command_stream(
+ nng, sg, arch, options.verbose_register_command_stream
+ )
+ scratch_tens, flash_tens = npu_serialisation.serialise_npu_subgraph_into_tensors(
+ nng, sg, arch, scratch_tens, flash_tens
+ )
+
+ npu_serialisation.rewrite_npu_call_ops(nng, root_sg, arch)
+
+ # Allocate all Cpu constant tensors, this is done last because the Npu-ops
+ # have to be serialized into flash and scratch tensors first
+ tensor_allocation.allocate_tensors(
+ nng,
+ root_sg,
+ arch,
+ permanent_storage,
+ scheduler_options.use_ifm_ofm_overlap,
+ options.tensor_allocator,
+ options.verbose_allocation,
+ options.show_minimum_possible_allocation,
+ )
+
+ npu_performance.calc_performance_for_network(nng, arch)
diff --git a/ethosu/vela/data_type.py b/ethosu/vela/data_type.py
new file mode 100644
index 0000000..1d3e94e
--- /dev/null
+++ b/ethosu/vela/data_type.py
@@ -0,0 +1,116 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Defines the basic numeric type classes for tensors.
+
+from .numeric_util import round_up_divide
+import enum
+
+
+class BaseType(enum.Flag):
+ Signed = 1
+ Unsigned = 2
+ Asymmetric = 4
+ Int = 8
+ SignedInt = Int | Signed
+ UnsignedInt = Int | Unsigned
+ AsymmSInt = Int | Asymmetric | Signed
+ AsymmUInt = Int | Asymmetric | Unsigned
+ Float = 16
+ BFloat = 32
+ Bool = 64
+ String = 128
+ Resource = 256
+ Variant = 512
+
+
+class DataType:
+ """Defines a data type. Consists of a base type, and the number of bits used for this type"""
+
+ __slots__ = "type", "bits"
+
+ def __init__(self, type_, bits):
+ self.type = type_
+ self.bits = bits
+
+ def __eq__(self, other):
+ return self.type == other.type and self.bits == other.bits
+
+ def __hash__(self):
+ return hash((self.type, self.bits))
+
+ def size_in_bytes(self):
+ return round_up_divide(self.bits, 8)
+
+ def size_in_bits(self):
+ return self.bits
+
+ def __str__(self):
+ stem, needs_format = DataType.stem_name[self.type]
+ if not needs_format:
+ return stem
+ else:
+ return stem % (self.bits,)
+
+ __repr__ = __str__
+
+ stem_name = {
+ BaseType.UnsignedInt: ("uint%s", True),
+ BaseType.SignedInt: ("int%s", True),
+ BaseType.AsymmUInt: ("quint%s", True),
+ BaseType.AsymmSInt: ("qint%s", True),
+ BaseType.Float: ("float%s", True),
+ BaseType.BFloat: ("bfloat%s", True),
+ BaseType.Bool: ("bool", False),
+ BaseType.String: ("string", False),
+ BaseType.Resource: ("resource", False),
+ BaseType.Variant: ("variant", False),
+ }
+
+
+# generate the standard set of data types
+DataType.int8 = DataType(BaseType.SignedInt, 8)
+DataType.int16 = DataType(BaseType.SignedInt, 16)
+DataType.int32 = DataType(BaseType.SignedInt, 32)
+DataType.int64 = DataType(BaseType.SignedInt, 64)
+
+DataType.uint8 = DataType(BaseType.UnsignedInt, 8)
+DataType.uint16 = DataType(BaseType.UnsignedInt, 16)
+DataType.uint32 = DataType(BaseType.UnsignedInt, 32)
+DataType.uint64 = DataType(BaseType.UnsignedInt, 64)
+
+DataType.quint4 = DataType(BaseType.AsymmUInt, 4)
+DataType.quint8 = DataType(BaseType.AsymmUInt, 8)
+DataType.quint12 = DataType(BaseType.AsymmUInt, 12)
+DataType.quint16 = DataType(BaseType.AsymmUInt, 16)
+DataType.quint32 = DataType(BaseType.AsymmUInt, 32)
+
+DataType.qint4 = DataType(BaseType.AsymmSInt, 4)
+DataType.qint8 = DataType(BaseType.AsymmSInt, 8)
+DataType.qint12 = DataType(BaseType.AsymmSInt, 12)
+DataType.qint16 = DataType(BaseType.AsymmSInt, 16)
+DataType.qint32 = DataType(BaseType.AsymmSInt, 32)
+
+DataType.float16 = DataType(BaseType.Float, 16)
+DataType.float32 = DataType(BaseType.Float, 32)
+DataType.float64 = DataType(BaseType.Float, 64)
+
+DataType.string = DataType(BaseType.String, 64)
+DataType.bool = DataType(BaseType.Bool, 8)
+DataType.resource = DataType(BaseType.Resource, 8)
+DataType.variant = DataType(BaseType.Variant, 8)
diff --git a/ethosu/vela/driver_actions.py b/ethosu/vela/driver_actions.py
new file mode 100644
index 0000000..86c4a36
--- /dev/null
+++ b/ethosu/vela/driver_actions.py
@@ -0,0 +1,107 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Creates driver actions that are embedded in the custom operator payload.
+
+import numpy as np
+from typing import List
+from .ethos_u55_regs.ethos_u55_regs import *
+
+
+class DACommands:
+ Reserved = 0x00
+ Config = 0x01
+ Config_PatchShift = 4
+ CmdStream = 0x02
+ ReadAPB = 0x03
+ ReadAPB_CountShift = 12
+ ReadAPB_IndexMask = (1 << ReadAPB_CountShift) - 1
+ DumpSHRAM = 0x04
+ NOP = 0x05
+
+
+def make_da_tag(id: int, reserved: int, param: int) -> int:
+ tag: int = id
+ tag |= reserved << 8
+ tag |= param << 16
+ return tag
+
+
+def emit_fourcc(data: List[int], fourcc: str):
+ assert data != None
+ assert fourcc != None
+ assert len(fourcc) == 4
+ value: int = 0
+ value = fourcc[0].encode()[0]
+ value |= fourcc[1].encode()[0] << 8
+ value |= fourcc[2].encode()[0] << 16
+ value |= fourcc[3].encode()[0] << 24
+ data.append(value)
+
+
+def build_id_word():
+ arch_major_rev, arch_minor_rev, arch_patch_rev = (int(x) for x in ARCH_VER.split("."))
+ n = id_r()
+ n.set_arch_major_rev(arch_major_rev)
+ n.set_arch_minor_rev(arch_minor_rev)
+ n.set_arch_patch_rev(arch_patch_rev)
+ return n.word
+
+
+def build_config_word(arch):
+ macs_cc = arch.config.macs
+ log2_macs_cc = int(np.log2(macs_cc) + 0.5)
+ shram_size = int(arch.shram_size_bytes / 1024)
+ n = config_r()
+ n.set_shram_size(shram_size)
+ n.set_cmd_stream_version(0) # may be incremented in the future
+ n.set_macs_per_cc(log2_macs_cc)
+ return n.word
+
+
+def emit_config(data: List[int], rel: int, patch: int, arch):
+ assert data != None
+ data.append(make_da_tag(DACommands.Config, 0, (patch << DACommands.Config_PatchShift) | rel))
+ data.append(build_config_word(arch))
+ data.append(build_id_word())
+
+
+def emit_cmd_stream_header(data: List[int], length: int):
+ assert data != None
+ # Insert NOPs to align start of command stream to 16 bytes
+ num_nops = 4 - ((len(data) + 1) % 4)
+ for _ in range(num_nops):
+ data.append(make_da_tag(DACommands.NOP, 0, 0))
+
+ # Use the reserved 8 bit as the length high
+ length_high = (length & 0x00FF0000) >> 16
+ length_low = length & 0x0000FFFF
+ data.append(make_da_tag(DACommands.CmdStream, length_high, length_low))
+
+
+def emit_reg_read(data: List[int], reg_index: int, reg_count: int = 1):
+ assert data != None
+ assert reg_index >= 0
+ assert reg_count >= 1
+ payload: int = (reg_index & DACommands.ReadAPB_IndexMask) | ((reg_count << DACommands.ReadAPB_CountShift) - 1)
+ data.append(make_da_tag(DACommands.ReadAPB, 0, payload))
+
+
+def emit_dump_shram(data: List[int]):
+ assert data != None
+ data.append(make_da_tag(DACommands.DumpSHRAM, 0, 0))
diff --git a/ethosu/vela/ethos_u55_regs/ethos_u55_regs.py b/ethosu/vela/ethos_u55_regs/ethos_u55_regs.py
new file mode 100644
index 0000000..37f7a67
--- /dev/null
+++ b/ethosu/vela/ethos_u55_regs/ethos_u55_regs.py
@@ -0,0 +1,3138 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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 ctypes import *
+from enum import Enum
+
+ARCH_VER = '0.154.0'
+
+
+class DEBUG_INTERNAL(Enum):
+ SHARED_BUFFER0 = 0x0400
+ SHARED_BUFFER1 = 0x0404
+ SHARED_BUFFER2 = 0x0408
+ SHARED_BUFFER3 = 0x040C
+ SHARED_BUFFER4 = 0x0410
+ SHARED_BUFFER5 = 0x0414
+ SHARED_BUFFER6 = 0x0418
+ SHARED_BUFFER7 = 0x041C
+ SHARED_BUFFER8 = 0x0420
+ SHARED_BUFFER9 = 0x0424
+ SHARED_BUFFER10 = 0x0428
+ SHARED_BUFFER11 = 0x042C
+ SHARED_BUFFER12 = 0x0430
+ SHARED_BUFFER13 = 0x0434
+ SHARED_BUFFER14 = 0x0438
+ SHARED_BUFFER15 = 0x043C
+ SHARED_BUFFER16 = 0x0440
+ SHARED_BUFFER17 = 0x0444
+ SHARED_BUFFER18 = 0x0448
+ SHARED_BUFFER19 = 0x044C
+ SHARED_BUFFER20 = 0x0450
+ SHARED_BUFFER21 = 0x0454
+ SHARED_BUFFER22 = 0x0458
+ SHARED_BUFFER23 = 0x045C
+ SHARED_BUFFER24 = 0x0460
+ SHARED_BUFFER25 = 0x0464
+ SHARED_BUFFER26 = 0x0468
+ SHARED_BUFFER27 = 0x046C
+ SHARED_BUFFER28 = 0x0470
+ SHARED_BUFFER29 = 0x0474
+ SHARED_BUFFER30 = 0x0478
+ SHARED_BUFFER31 = 0x047C
+ SHARED_BUFFER32 = 0x0480
+ SHARED_BUFFER33 = 0x0484
+ SHARED_BUFFER34 = 0x0488
+ SHARED_BUFFER35 = 0x048C
+ SHARED_BUFFER36 = 0x0490
+ SHARED_BUFFER37 = 0x0494
+ SHARED_BUFFER38 = 0x0498
+ SHARED_BUFFER39 = 0x049C
+ SHARED_BUFFER40 = 0x04A0
+ SHARED_BUFFER41 = 0x04A4
+ SHARED_BUFFER42 = 0x04A8
+ SHARED_BUFFER43 = 0x04AC
+ SHARED_BUFFER44 = 0x04B0
+ SHARED_BUFFER45 = 0x04B4
+ SHARED_BUFFER46 = 0x04B8
+ SHARED_BUFFER47 = 0x04BC
+ SHARED_BUFFER48 = 0x04C0
+ SHARED_BUFFER49 = 0x04C4
+ SHARED_BUFFER50 = 0x04C8
+ SHARED_BUFFER51 = 0x04CC
+ SHARED_BUFFER52 = 0x04D0
+ SHARED_BUFFER53 = 0x04D4
+ SHARED_BUFFER54 = 0x04D8
+ SHARED_BUFFER55 = 0x04DC
+ SHARED_BUFFER56 = 0x04E0
+ SHARED_BUFFER57 = 0x04E4
+ SHARED_BUFFER58 = 0x04E8
+ SHARED_BUFFER59 = 0x04EC
+ SHARED_BUFFER60 = 0x04F0
+ SHARED_BUFFER61 = 0x04F4
+ SHARED_BUFFER62 = 0x04F8
+ SHARED_BUFFER63 = 0x04FC
+ SHARED_BUFFER64 = 0x0500
+ SHARED_BUFFER65 = 0x0504
+ SHARED_BUFFER66 = 0x0508
+ SHARED_BUFFER67 = 0x050C
+ SHARED_BUFFER68 = 0x0510
+ SHARED_BUFFER69 = 0x0514
+ SHARED_BUFFER70 = 0x0518
+ SHARED_BUFFER71 = 0x051C
+ SHARED_BUFFER72 = 0x0520
+ SHARED_BUFFER73 = 0x0524
+ SHARED_BUFFER74 = 0x0528
+ SHARED_BUFFER75 = 0x052C
+ SHARED_BUFFER76 = 0x0530
+ SHARED_BUFFER77 = 0x0534
+ SHARED_BUFFER78 = 0x0538
+ SHARED_BUFFER79 = 0x053C
+ SHARED_BUFFER80 = 0x0540
+ SHARED_BUFFER81 = 0x0544
+ SHARED_BUFFER82 = 0x0548
+ SHARED_BUFFER83 = 0x054C
+ SHARED_BUFFER84 = 0x0550
+ SHARED_BUFFER85 = 0x0554
+ SHARED_BUFFER86 = 0x0558
+ SHARED_BUFFER87 = 0x055C
+ SHARED_BUFFER88 = 0x0560
+ SHARED_BUFFER89 = 0x0564
+ SHARED_BUFFER90 = 0x0568
+ SHARED_BUFFER91 = 0x056C
+ SHARED_BUFFER92 = 0x0570
+ SHARED_BUFFER93 = 0x0574
+ SHARED_BUFFER94 = 0x0578
+ SHARED_BUFFER95 = 0x057C
+ SHARED_BUFFER96 = 0x0580
+ SHARED_BUFFER97 = 0x0584
+ SHARED_BUFFER98 = 0x0588
+ SHARED_BUFFER99 = 0x058C
+ SHARED_BUFFER100 = 0x0590
+ SHARED_BUFFER101 = 0x0594
+ SHARED_BUFFER102 = 0x0598
+ SHARED_BUFFER103 = 0x059C
+ SHARED_BUFFER104 = 0x05A0
+ SHARED_BUFFER105 = 0x05A4
+ SHARED_BUFFER106 = 0x05A8
+ SHARED_BUFFER107 = 0x05AC
+ SHARED_BUFFER108 = 0x05B0
+ SHARED_BUFFER109 = 0x05B4
+ SHARED_BUFFER110 = 0x05B8
+ SHARED_BUFFER111 = 0x05BC
+ SHARED_BUFFER112 = 0x05C0
+ SHARED_BUFFER113 = 0x05C4
+ SHARED_BUFFER114 = 0x05C8
+ SHARED_BUFFER115 = 0x05CC
+ SHARED_BUFFER116 = 0x05D0
+ SHARED_BUFFER117 = 0x05D4
+ SHARED_BUFFER118 = 0x05D8
+ SHARED_BUFFER119 = 0x05DC
+ SHARED_BUFFER120 = 0x05E0
+ SHARED_BUFFER121 = 0x05E4
+ SHARED_BUFFER122 = 0x05E8
+ SHARED_BUFFER123 = 0x05EC
+ SHARED_BUFFER124 = 0x05F0
+ SHARED_BUFFER125 = 0x05F4
+ SHARED_BUFFER126 = 0x05F8
+ SHARED_BUFFER127 = 0x05FC
+ SHARED_BUFFER128 = 0x0600
+ SHARED_BUFFER129 = 0x0604
+ SHARED_BUFFER130 = 0x0608
+ SHARED_BUFFER131 = 0x060C
+ SHARED_BUFFER132 = 0x0610
+ SHARED_BUFFER133 = 0x0614
+ SHARED_BUFFER134 = 0x0618
+ SHARED_BUFFER135 = 0x061C
+ SHARED_BUFFER136 = 0x0620
+ SHARED_BUFFER137 = 0x0624
+ SHARED_BUFFER138 = 0x0628
+ SHARED_BUFFER139 = 0x062C
+ SHARED_BUFFER140 = 0x0630
+ SHARED_BUFFER141 = 0x0634
+ SHARED_BUFFER142 = 0x0638
+ SHARED_BUFFER143 = 0x063C
+ SHARED_BUFFER144 = 0x0640
+ SHARED_BUFFER145 = 0x0644
+ SHARED_BUFFER146 = 0x0648
+ SHARED_BUFFER147 = 0x064C
+ SHARED_BUFFER148 = 0x0650
+ SHARED_BUFFER149 = 0x0654
+ SHARED_BUFFER150 = 0x0658
+ SHARED_BUFFER151 = 0x065C
+ SHARED_BUFFER152 = 0x0660
+ SHARED_BUFFER153 = 0x0664
+ SHARED_BUFFER154 = 0x0668
+ SHARED_BUFFER155 = 0x066C
+ SHARED_BUFFER156 = 0x0670
+ SHARED_BUFFER157 = 0x0674
+ SHARED_BUFFER158 = 0x0678
+ SHARED_BUFFER159 = 0x067C
+ SHARED_BUFFER160 = 0x0680
+ SHARED_BUFFER161 = 0x0684
+ SHARED_BUFFER162 = 0x0688
+ SHARED_BUFFER163 = 0x068C
+ SHARED_BUFFER164 = 0x0690
+ SHARED_BUFFER165 = 0x0694
+ SHARED_BUFFER166 = 0x0698
+ SHARED_BUFFER167 = 0x069C
+ SHARED_BUFFER168 = 0x06A0
+ SHARED_BUFFER169 = 0x06A4
+ SHARED_BUFFER170 = 0x06A8
+ SHARED_BUFFER171 = 0x06AC
+ SHARED_BUFFER172 = 0x06B0
+ SHARED_BUFFER173 = 0x06B4
+ SHARED_BUFFER174 = 0x06B8
+ SHARED_BUFFER175 = 0x06BC
+ SHARED_BUFFER176 = 0x06C0
+ SHARED_BUFFER177 = 0x06C4
+ SHARED_BUFFER178 = 0x06C8
+ SHARED_BUFFER179 = 0x06CC
+ SHARED_BUFFER180 = 0x06D0
+ SHARED_BUFFER181 = 0x06D4
+ SHARED_BUFFER182 = 0x06D8
+ SHARED_BUFFER183 = 0x06DC
+ SHARED_BUFFER184 = 0x06E0
+ SHARED_BUFFER185 = 0x06E4
+ SHARED_BUFFER186 = 0x06E8
+ SHARED_BUFFER187 = 0x06EC
+ SHARED_BUFFER188 = 0x06F0
+ SHARED_BUFFER189 = 0x06F4
+ SHARED_BUFFER190 = 0x06F8
+ SHARED_BUFFER191 = 0x06FC
+ SHARED_BUFFER192 = 0x0700
+ SHARED_BUFFER193 = 0x0704
+ SHARED_BUFFER194 = 0x0708
+ SHARED_BUFFER195 = 0x070C
+ SHARED_BUFFER196 = 0x0710
+ SHARED_BUFFER197 = 0x0714
+ SHARED_BUFFER198 = 0x0718
+ SHARED_BUFFER199 = 0x071C
+ SHARED_BUFFER200 = 0x0720
+ SHARED_BUFFER201 = 0x0724
+ SHARED_BUFFER202 = 0x0728
+ SHARED_BUFFER203 = 0x072C
+ SHARED_BUFFER204 = 0x0730
+ SHARED_BUFFER205 = 0x0734
+ SHARED_BUFFER206 = 0x0738
+ SHARED_BUFFER207 = 0x073C
+ SHARED_BUFFER208 = 0x0740
+ SHARED_BUFFER209 = 0x0744
+ SHARED_BUFFER210 = 0x0748
+ SHARED_BUFFER211 = 0x074C
+ SHARED_BUFFER212 = 0x0750
+ SHARED_BUFFER213 = 0x0754
+ SHARED_BUFFER214 = 0x0758
+ SHARED_BUFFER215 = 0x075C
+ SHARED_BUFFER216 = 0x0760
+ SHARED_BUFFER217 = 0x0764
+ SHARED_BUFFER218 = 0x0768
+ SHARED_BUFFER219 = 0x076C
+ SHARED_BUFFER220 = 0x0770
+ SHARED_BUFFER221 = 0x0774
+ SHARED_BUFFER222 = 0x0778
+ SHARED_BUFFER223 = 0x077C
+ SHARED_BUFFER224 = 0x0780
+ SHARED_BUFFER225 = 0x0784
+ SHARED_BUFFER226 = 0x0788
+ SHARED_BUFFER227 = 0x078C
+ SHARED_BUFFER228 = 0x0790
+ SHARED_BUFFER229 = 0x0794
+ SHARED_BUFFER230 = 0x0798
+ SHARED_BUFFER231 = 0x079C
+ SHARED_BUFFER232 = 0x07A0
+ SHARED_BUFFER233 = 0x07A4
+ SHARED_BUFFER234 = 0x07A8
+ SHARED_BUFFER235 = 0x07AC
+ SHARED_BUFFER236 = 0x07B0
+ SHARED_BUFFER237 = 0x07B4
+ SHARED_BUFFER238 = 0x07B8
+ SHARED_BUFFER239 = 0x07BC
+ SHARED_BUFFER240 = 0x07C0
+ SHARED_BUFFER241 = 0x07C4
+ SHARED_BUFFER242 = 0x07C8
+ SHARED_BUFFER243 = 0x07CC
+ SHARED_BUFFER244 = 0x07D0
+ SHARED_BUFFER245 = 0x07D4
+ SHARED_BUFFER246 = 0x07D8
+ SHARED_BUFFER247 = 0x07DC
+ SHARED_BUFFER248 = 0x07E0
+ SHARED_BUFFER249 = 0x07E4
+ SHARED_BUFFER250 = 0x07E8
+ SHARED_BUFFER251 = 0x07EC
+ SHARED_BUFFER252 = 0x07F0
+ SHARED_BUFFER253 = 0x07F4
+ SHARED_BUFFER254 = 0x07F8
+ SHARED_BUFFER255 = 0x07FC
+ SIZE = 0x0800
+
+class HW_DEBUG_INTERNAL(Enum):
+ CLKFORCE = 0x0140
+ DEBUG = 0x0144
+ DEBUG2 = 0x0148
+ DEBUGCORE = 0x014C
+ SIZE = 0x0150
+
+class NPU_BP(Enum):
+ BASEP0 = 0x0080
+ BASEP1 = 0x0084
+ BASEP2 = 0x0088
+ BASEP3 = 0x008C
+ BASEP4 = 0x0090
+ BASEP5 = 0x0094
+ BASEP6 = 0x0098
+ BASEP7 = 0x009C
+ BASEP8 = 0x00A0
+ BASEP9 = 0x00A4
+ BASEP10 = 0x00A8
+ BASEP11 = 0x00AC
+ BASEP12 = 0x00B0
+ BASEP13 = 0x00B4
+ BASEP14 = 0x00B8
+ BASEP15 = 0x00BC
+ SIZE = 0x00C0
+
+class NPU_IDS(Enum):
+ REVISION = 0x0FC0
+ PID4 = 0x0FD0
+ PID5 = 0x0FD4
+ PID6 = 0x0FD8
+ PID7 = 0x0FDC
+ PID0 = 0x0FE0
+ PID1 = 0x0FE4
+ PID2 = 0x0FE8
+ PID3 = 0x0FEC
+ CID0 = 0x0FF0
+ CID1 = 0x0FF4
+ CID2 = 0x0FF8
+ CID3 = 0x0FFC
+ SIZE = 0x1000
+
+class NPU_REG(Enum):
+ ID = 0x0000
+ STATUS = 0x0004
+ CMD = 0x0008
+ RESET = 0x000C
+ QBASE0 = 0x0010
+ QBASE1 = 0x0014
+ QREAD = 0x0018
+ QCONFIG = 0x001C
+ QSIZE = 0x0020
+ PROT = 0x0024
+ CONFIG = 0x0028
+ LOCK = 0x002C
+ REGIONCFG = 0x003C
+ AXI_LIMIT0 = 0x0040
+ AXI_LIMIT1 = 0x0044
+ AXI_LIMIT2 = 0x0048
+ AXI_LIMIT3 = 0x004C
+ SIZE = 0x0050
+
+class PMU_INTERNAL(Enum):
+ PMCR = 0x0180
+ PMCNTENSET = 0x0184
+ PMCNTENCLR = 0x0188
+ PMOVSSET = 0x018C
+ PMOVSCLR = 0x0190
+ PMINTSET = 0x0194
+ PMINTCLR = 0x0198
+ PMCCNTR_LO = 0x01A0
+ PMCCNTR_HI = 0x01A4
+ PMCCNTR_CFG = 0x01A8
+ PMCAXI_CHAN = 0x01AC
+ PMEVCNTR0 = 0x0300
+ PMEVCNTR1 = 0x0304
+ PMEVCNTR2 = 0x0308
+ PMEVCNTR3 = 0x030C
+ PMEVTYPER0 = 0x0380
+ PMEVTYPER1 = 0x0384
+ PMEVTYPER2 = 0x0388
+ PMEVTYPER3 = 0x038C
+ SIZE = 0x0390
+
+class TSU_DEBUG_INTERNAL(Enum):
+ IFM_PAD_TOP = 0x0800
+ IFM_PAD_LEFT = 0x0804
+ IFM_PAD_RIGHT = 0x0808
+ IFM_PAD_BOTTOM = 0x080C
+ IFM_DEPTH_M1 = 0x0810
+ IFM_PRECISION = 0x0814
+ IFM_UPSCALE = 0x081C
+ IFM_ZERO_POINT = 0x0824
+ IFM_WIDTH0_M1 = 0x0828
+ IFM_HEIGHT0_M1 = 0x082C
+ IFM_HEIGHT1_M1 = 0x0830
+ IFM_IB_END = 0x0834
+ IFM_REGION = 0x083C
+ OFM_WIDTH_M1 = 0x0844
+ OFM_HEIGHT_M1 = 0x0848
+ OFM_DEPTH_M1 = 0x084C
+ OFM_PRECISION = 0x0850
+ OFM_BLK_WIDTH_M1 = 0x0854
+ OFM_BLK_HEIGHT_M1 = 0x0858
+ OFM_BLK_DEPTH_M1 = 0x085C
+ OFM_ZERO_POINT = 0x0860
+ OFM_WIDTH0_M1 = 0x0868
+ OFM_HEIGHT0_M1 = 0x086C
+ OFM_HEIGHT1_M1 = 0x0870
+ OFM_REGION = 0x087C
+ KERNEL_WIDTH_M1 = 0x0880
+ KERNEL_HEIGHT_M1 = 0x0884
+ KERNEL_STRIDE = 0x0888
+ PARALLEL_MODE = 0x088C
+ ACC_FORMAT = 0x0890
+ ACTIVATION = 0x0894
+ ACTIVATION_MIN = 0x0898
+ ACTIVATION_MAX = 0x089C
+ WEIGHT_REGION = 0x08A0
+ SCALE_REGION = 0x08A4
+ AB_START = 0x08B4
+ BLOCKDEP = 0x08BC
+ DMA0_SRC_REGION = 0x08C0
+ DMA0_DST_REGION = 0x08C4
+ DMA0_SIZE0 = 0x08C8
+ DMA0_SIZE1 = 0x08CC
+ IFM2_BROADCAST = 0x0900
+ IFM2_SCALAR = 0x0904
+ IFM2_PRECISION = 0x0914
+ IFM2_ZERO_POINT = 0x0924
+ IFM2_WIDTH0_M1 = 0x0928
+ IFM2_HEIGHT0_M1 = 0x092C
+ IFM2_HEIGHT1_M1 = 0x0930
+ IFM2_IB_START = 0x0934
+ IFM2_REGION = 0x093C
+ IFM_BASE0 = 0x0A00
+ IFM_BASE0_HI = 0x0A04
+ IFM_BASE1 = 0x0A08
+ IFM_BASE1_HI = 0x0A0C
+ IFM_BASE2 = 0x0A10
+ IFM_BASE2_HI = 0x0A14
+ IFM_BASE3 = 0x0A18
+ IFM_BASE3_HI = 0x0A1C
+ IFM_STRIDE_X = 0x0A20
+ IFM_STRIDE_X_HI = 0x0A24
+ IFM_STRIDE_Y = 0x0A28
+ IFM_STRIDE_Y_HI = 0x0A2C
+ IFM_STRIDE_C = 0x0A30
+ IFM_STRIDE_C_HI = 0x0A34
+ OFM_BASE0 = 0x0A40
+ OFM_BASE0_HI = 0x0A44
+ OFM_BASE1 = 0x0A48
+ OFM_BASE1_HI = 0x0A4C
+ OFM_BASE2 = 0x0A50
+ OFM_BASE2_HI = 0x0A54
+ OFM_BASE3 = 0x0A58
+ OFM_BASE3_HI = 0x0A5C
+ OFM_STRIDE_X = 0x0A60
+ OFM_STRIDE_X_HI = 0x0A64
+ OFM_STRIDE_Y = 0x0A68
+ OFM_STRIDE_Y_HI = 0x0A6C
+ OFM_STRIDE_C = 0x0A70
+ OFM_STRIDE_C_HI = 0x0A74
+ WEIGHT_BASE = 0x0A80
+ WEIGHT_BASE_HI = 0x0A84
+ WEIGHT_LENGTH = 0x0A88
+ WEIGHT_LENGTH_HI = 0x0A8C
+ SCALE_BASE = 0x0A90
+ SCALE_BASE_HI = 0x0A94
+ SCALE_LENGTH = 0x0A98
+ OFM_SCALE = 0x0AA0
+ OFM_SCALE_SHIFT = 0x0AA4
+ OPA_SCALE = 0x0AA8
+ OPA_SCALE_SHIFT = 0x0AAC
+ OPB_SCALE = 0x0AB0
+ DMA0_SRC = 0x0AC0
+ DMA0_SRC_HI = 0x0AC4
+ DMA0_DST = 0x0AC8
+ DMA0_DST_HI = 0x0ACC
+ DMA0_LEN = 0x0AD0
+ DMA0_LEN_HI = 0x0AD4
+ DMA0_SKIP0 = 0x0AD8
+ DMA0_SKIP0_HI = 0x0ADC
+ DMA0_SKIP1 = 0x0AE0
+ DMA0_SKIP1_HI = 0x0AE4
+ IFM2_BASE0 = 0x0B00
+ IFM2_BASE0_HI = 0x0B04
+ IFM2_BASE1 = 0x0B08
+ IFM2_BASE1_HI = 0x0B0C
+ IFM2_BASE2 = 0x0B10
+ IFM2_BASE2_HI = 0x0B14
+ IFM2_BASE3 = 0x0B18
+ IFM2_BASE3_HI = 0x0B1C
+ IFM2_STRIDE_X = 0x0B20
+ IFM2_STRIDE_X_HI = 0x0B24
+ IFM2_STRIDE_Y = 0x0B28
+ IFM2_STRIDE_Y_HI = 0x0B2C
+ IFM2_STRIDE_C = 0x0B30
+ IFM2_STRIDE_C_HI = 0x0B34
+ WEIGHT1_BASE = 0x0B40
+ WEIGHT1_BASE_HI = 0x0B44
+ WEIGHT1_LENGTH = 0x0B48
+ WEIGHT1_LENGTH_HI = 0x0B4C
+ SCALE1_BASE = 0x0B50
+ SCALE1_BASE_HI = 0x0B54
+ SCALE1_LENGTH = 0x0B58
+ SIZE = 0x0B5C
+
+class TSU_DEBUG_RO_INTERNAL(Enum):
+ KERNEL_X = 0x0200
+ KERNEL_Y = 0x0204
+ KERNEL_W_M1 = 0x0208
+ KERNEL_H_M1 = 0x020C
+ OFM_CBLK_WIDTH_M1 = 0x0210
+ OFM_CBLK_HEIGHT_M1 = 0x0214
+ OFM_CBLK_DEPTH_M1 = 0x0218
+ IFM_CBLK_DEPTH_M1 = 0x021C
+ OFM_X = 0x0220
+ OFM_Y = 0x0224
+ OFM_Z = 0x0228
+ IFM_Z = 0x022C
+ PAD_TOP = 0x0230
+ PAD_LEFT = 0x0234
+ IFM_CBLK_WIDTH = 0x0238
+ IFM_CBLK_HEIGHT = 0x023C
+ DMA_IFM_SRC = 0x0240
+ DMA_IFM_SRC_HI = 0x0244
+ DMA_IFM_DST = 0x0248
+ DMA_OFM_SRC = 0x024C
+ DMA_OFM_DST = 0x0250
+ DMA_OFM_DST_HI = 0x0254
+ DMA_WEIGHT_SRC = 0x0258
+ DMA_WEIGHT_SRC_HI = 0x025C
+ DMA_CMD_SRC = 0x0260
+ DMA_CMD_SRC_HI = 0x0264
+ DMA_CMD_SIZE = 0x0268
+ DMA_M2M_SRC = 0x026C
+ DMA_M2M_SRC_HI = 0x0270
+ DMA_M2M_DST = 0x0274
+ DMA_M2M_DST_HI = 0x0278
+ CURRENT_QREAD = 0x027C
+ DMA_SCALE_SRC = 0x0280
+ DMA_SCALE_SRC_HI = 0x0284
+ CURRENT_CMD = 0x02BC
+ SIZE = 0x02C0
+
+
+
+class acc_format(Enum):
+ INT_32BIT = 0
+ INT_40BIT = 1
+ FP_S5_10 = 2
+
+class activation(Enum):
+ NONE = 0
+ TANH = 3
+ SIGMOID = 4
+ LUT_START = 16
+ LUT_END = 23
+
+class clip_range(Enum):
+ OFM_PRECISION = 0
+ FORCE_UINT8 = 2
+ FORCE_INT8 = 3
+ FORCE_INT16 = 5
+
+class cmd0(Enum):
+ NPU_OP_STOP = 0x000
+ NPU_OP_IRQ = 0x001
+ NPU_OP_CONV = 0x002
+ NPU_OP_DEPTHWISE = 0x003
+ NPU_OP_POOL = 0x005
+ NPU_OP_ELEMENTWISE = 0x006
+ NPU_OP_DMA_START = 0x010
+ NPU_OP_DMA_WAIT = 0x011
+ NPU_OP_KERNEL_WAIT = 0x012
+ NPU_OP_PMU_MASK = 0x013
+ NPU_SET_IFM_PAD_TOP = 0x100
+ NPU_SET_IFM_PAD_LEFT = 0x101
+ NPU_SET_IFM_PAD_RIGHT = 0x102
+ NPU_SET_IFM_PAD_BOTTOM = 0x103
+ NPU_SET_IFM_DEPTH_M1 = 0x104
+ NPU_SET_IFM_PRECISION = 0x105
+ NPU_SET_IFM_UPSCALE = 0x107
+ NPU_SET_IFM_ZERO_POINT = 0x109
+ NPU_SET_IFM_WIDTH0_M1 = 0x10A
+ NPU_SET_IFM_HEIGHT0_M1 = 0x10B
+ NPU_SET_IFM_HEIGHT1_M1 = 0x10C
+ NPU_SET_IFM_IB_END = 0x10D
+ NPU_SET_IFM_REGION = 0x10F
+ NPU_SET_OFM_WIDTH_M1 = 0x111
+ NPU_SET_OFM_HEIGHT_M1 = 0x112
+ NPU_SET_OFM_DEPTH_M1 = 0x113
+ NPU_SET_OFM_PRECISION = 0x114
+ NPU_SET_OFM_BLK_WIDTH_M1 = 0x115
+ NPU_SET_OFM_BLK_HEIGHT_M1 = 0x116
+ NPU_SET_OFM_BLK_DEPTH_M1 = 0x117
+ NPU_SET_OFM_ZERO_POINT = 0x118
+ NPU_SET_OFM_WIDTH0_M1 = 0x11A
+ NPU_SET_OFM_HEIGHT0_M1 = 0x11B
+ NPU_SET_OFM_HEIGHT1_M1 = 0x11C
+ NPU_SET_OFM_REGION = 0x11F
+ NPU_SET_KERNEL_WIDTH_M1 = 0x120
+ NPU_SET_KERNEL_HEIGHT_M1 = 0x121
+ NPU_SET_KERNEL_STRIDE = 0x122
+ NPU_SET_PARALLEL_MODE = 0x123
+ NPU_SET_ACC_FORMAT = 0x124
+ NPU_SET_ACTIVATION = 0x125
+ NPU_SET_ACTIVATION_MIN = 0x126
+ NPU_SET_ACTIVATION_MAX = 0x127
+ NPU_SET_WEIGHT_REGION = 0x128
+ NPU_SET_SCALE_REGION = 0x129
+ NPU_SET_AB_START = 0x12D
+ NPU_SET_BLOCKDEP = 0x12F
+ NPU_SET_DMA0_SRC_REGION = 0x130
+ NPU_SET_DMA0_DST_REGION = 0x131
+ NPU_SET_DMA0_SIZE0 = 0x132
+ NPU_SET_DMA0_SIZE1 = 0x133
+ NPU_SET_IFM2_BROADCAST = 0x180
+ NPU_SET_IFM2_SCALAR = 0x181
+ NPU_SET_IFM2_PRECISION = 0x185
+ NPU_SET_IFM2_ZERO_POINT = 0x189
+ NPU_SET_IFM2_WIDTH0_M1 = 0x18A
+ NPU_SET_IFM2_HEIGHT0_M1 = 0x18B
+ NPU_SET_IFM2_HEIGHT1_M1 = 0x18C
+ NPU_SET_IFM2_IB_START = 0x18D
+ NPU_SET_IFM2_REGION = 0x18F
+
+class cmd1(Enum):
+ NPU_SET_IFM_BASE0 = 0x000
+ NPU_SET_IFM_BASE1 = 0x001
+ NPU_SET_IFM_BASE2 = 0x002
+ NPU_SET_IFM_BASE3 = 0x003
+ NPU_SET_IFM_STRIDE_X = 0x004
+ NPU_SET_IFM_STRIDE_Y = 0x005
+ NPU_SET_IFM_STRIDE_C = 0x006
+ NPU_SET_OFM_BASE0 = 0x010
+ NPU_SET_OFM_BASE1 = 0x011
+ NPU_SET_OFM_BASE2 = 0x012
+ NPU_SET_OFM_BASE3 = 0x013
+ NPU_SET_OFM_STRIDE_X = 0x014
+ NPU_SET_OFM_STRIDE_Y = 0x015
+ NPU_SET_OFM_STRIDE_C = 0x016
+ NPU_SET_WEIGHT_BASE = 0x020
+ NPU_SET_WEIGHT_LENGTH = 0x021
+ NPU_SET_SCALE_BASE = 0x022
+ NPU_SET_SCALE_LENGTH = 0x023
+ NPU_SET_OFM_SCALE = 0x024
+ NPU_SET_OPA_SCALE = 0x025
+ NPU_SET_OPB_SCALE = 0x026
+ NPU_SET_DMA0_SRC = 0x030
+ NPU_SET_DMA0_DST = 0x031
+ NPU_SET_DMA0_LEN = 0x032
+ NPU_SET_DMA0_SKIP0 = 0x033
+ NPU_SET_DMA0_SKIP1 = 0x034
+ NPU_SET_IFM2_BASE0 = 0x080
+ NPU_SET_IFM2_BASE1 = 0x081
+ NPU_SET_IFM2_BASE2 = 0x082
+ NPU_SET_IFM2_BASE3 = 0x083
+ NPU_SET_IFM2_STRIDE_X = 0x084
+ NPU_SET_IFM2_STRIDE_Y = 0x085
+ NPU_SET_IFM2_STRIDE_C = 0x086
+ NPU_SET_WEIGHT1_BASE = 0x090
+ NPU_SET_WEIGHT1_LENGTH = 0x091
+ NPU_SET_SCALE1_BASE = 0x092
+ NPU_SET_SCALE1_LENGTH = 0x093
+
+class data_format(Enum):
+ NHWC = 0
+ NHCWB16 = 1
+
+class elementwise_mode(Enum):
+ MUL = 0
+ ADD = 1
+ SUB = 2
+ MIN = 3
+ MAX = 4
+ LRELU = 5
+ ABS = 6
+ CLZ = 7
+ SHR = 8
+ SHL = 9
+
+class ifm_precision(Enum):
+ W8_U8 = 0
+ W8_S8 = 1
+ W8_U16 = 4
+ W8_S16 = 5
+ W8_S32 = 9
+
+class ifm_scale_mode(Enum):
+ SCALE_16BIT = 0
+ SCALE_OPA_32BIT = 1
+ SCALE_OPB_32BIT = 2
+
+class memory_type(Enum):
+ AXI0_OUTSTANDING_COUNTER0 = 0
+ AXI0_OUTSTANDING_COUNTER1 = 1
+ AXI1_OUTSTANDING_COUNTER2 = 2
+ AXI1_OUTSTANDING_COUNTER3 = 3
+
+class ofm_precision(Enum):
+ U8 = 0
+ S8 = 1
+ U16 = 2
+ S16 = 3
+ S32 = 5
+
+class pmu_event_type(Enum):
+ CYCLE = 0x11
+ NPU_IDLE = 0x20
+ MAC_ACTIVE = 0x30
+ MAC_ACTIVE_8BIT = 0x31
+ MAC_ACTIVE_16BIT = 0x32
+ MAC_DPU_ACTIVE = 0x33
+ MAC_STALLED_BY_WD_ACC = 0x34
+ MAC_STALLED_BY_WD = 0x35
+ MAC_STALLED_BY_ACC = 0x36
+ MAC_STALLED_BY_IB = 0x37
+ AO_ACTIVE = 0x40
+ AO_ACTIVE_8BIT = 0x41
+ AO_ACTIVE_16BIT = 0x42
+ AO_STALLED_BY_OFMP_OB = 0x43
+ AO_STALLED_BY_OFMP = 0x44
+ AO_STALLED_BY_OB = 0x45
+ AO_STALLED_BY_ACC_IB = 0x46
+ AO_STALLED_BY_ACC = 0x47
+ AO_STALLED_BY_IB = 0x48
+ WD_ACTIVE = 0x50
+ WD_STALLED = 0x51
+ WD_STALLED_BY_WS = 0x52
+ WD_STALLED_BY_WD_BUF = 0x53
+ WD_PARSE_ACTIVE = 0x54
+ WD_PARSE_STALLED = 0x55
+ WD_PARSE_STALLED_IN = 0x56
+ WD_PARSE_STALLED_OUT = 0x57
+ AXI0_RD_TRANS_ACCEPTED = 0x80
+ AXI0_RD_TRANS_COMPLETED = 0x81
+ AXI0_RD_DATA_BEAT_RECEIVED = 0x82
+ AXI0_RD_TRAN_REQ_STALLED = 0x83
+ AXI0_WR_TRANS_ACCEPTED = 0x84
+ AXI0_WR_TRANS_COMPLETED_M = 0x85
+ AXI0_WR_TRANS_COMPLETED_S = 0x86
+ AXI0_WR_DATA_BEAT_WRITTEN = 0x87
+ AXI0_WR_TRAN_REQ_STALLED = 0x88
+ AXI0_WR_DATA_BEAT_STALLED = 0x89
+ AXI0_ENABLED_CYCLES = 0x8c
+ AXI0_RD_STALL_LIMIT = 0x8e
+ AXI0_WR_STALL_LIMIT = 0x8f
+ AXI1_RD_TRANS_ACCEPTED = 0x180
+ AXI1_RD_TRANS_COMPLETED = 0x181
+ AXI1_RD_DATA_BEAT_RECEIVED = 0x182
+ AXI1_RD_TRAN_REQ_STALLED = 0x183
+ AXI1_WR_TRANS_ACCEPTED = 0x184
+ AXI1_WR_TRANS_COMPLETED_M = 0x185
+ AXI1_WR_TRANS_COMPLETED_S = 0x186
+ AXI1_WR_DATA_BEAT_WRITTEN = 0x187
+ AXI1_WR_TRAN_REQ_STALLED = 0x188
+ AXI1_WR_DATA_BEAT_STALLED = 0x189
+ AXI1_ENABLED_CYCLES = 0x18c
+ AXI1_RD_STALL_LIMIT = 0x18e
+ AXI1_WR_STALL_LIMIT = 0x18f
+ AXI_LATENCY_ANY = 0xa0
+ AXI_LATENCY_32 = 0xa1
+ AXI_LATENCY_64 = 0xa2
+ AXI_LATENCY_128 = 0xa3
+ AXI_LATENCY_256 = 0xa4
+ AXI_LATENCY_512 = 0xa5
+ AXI_LATENCY_1024 = 0xa6
+
+class pooling_mode(Enum):
+ MAX = 0
+ AVERAGE = 1
+ REDUCE_SUM = 2
+
+class privilege_level(Enum):
+ USER = 0
+ PRIVILEGED = 1
+
+class product(Enum):
+ ETHOS_U55 = 0
+
+class resampling_mode(Enum):
+ NONE = 0
+ NEAREST = 1
+ TRANSPOSE = 2
+
+class rounding(Enum):
+ TFL = 0
+ TRUNCATE = 1
+ NATURAL = 2
+
+class security_level(Enum):
+ SECURE = 0
+ NON_SECURE = 1
+
+class state(Enum):
+ STOPPED = 0
+ RUNNING = 1
+
+class stride_mode(Enum):
+ STRIDE_MODE_1D = 0
+ STRIDE_MODE_2D = 1
+ STRIDE_MODE_3D = 2
+
+
+class clkforce_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("top_level_clk", c_uint32, 1),
+ ("cc_clk", c_uint32, 1),
+ ("dma_clk", c_uint32, 1),
+ ("mac_clk", c_uint32, 1),
+ ("ao_clk", c_uint32, 1),
+ ("wd_clk", c_uint32, 1),
+ ("reserved0", c_uint32, 26),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_top_level_clk(self, value): self.bits.top_level_clk = value
+ def get_top_level_clk(self): value = self.bits.top_level_clk; return value
+ def set_cc_clk(self, value): self.bits.cc_clk = value
+ def get_cc_clk(self): value = self.bits.cc_clk; return value
+ def set_dma_clk(self, value): self.bits.dma_clk = value
+ def get_dma_clk(self): value = self.bits.dma_clk; return value
+ def set_mac_clk(self, value): self.bits.mac_clk = value
+ def get_mac_clk(self): value = self.bits.mac_clk; return value
+ def set_ao_clk(self, value): self.bits.ao_clk = value
+ def get_ao_clk(self): value = self.bits.ao_clk; return value
+ def set_wd_clk(self, value): self.bits.wd_clk = value
+ def get_wd_clk(self): value = self.bits.wd_clk; return value
+
+
+class basep0_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep1_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep2_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep3_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep4_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep5_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep6_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep7_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep8_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep9_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep10_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep11_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep12_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep13_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep14_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class basep15_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("addr_word", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_addr_word(self, value): self.bits.addr_word = value
+ def get_addr_word(self): value = self.bits.addr_word; return value
+
+
+class pid4_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("pid4", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_pid4(self, value): self.bits.pid4 = value
+ def get_pid4(self): value = self.bits.pid4; return value
+
+
+class pid5_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("pid5", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_pid5(self, value): self.bits.pid5 = value
+ def get_pid5(self): value = self.bits.pid5; return value
+
+
+class pid6_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("pid6", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_pid6(self, value): self.bits.pid6 = value
+ def get_pid6(self): value = self.bits.pid6; return value
+
+
+class pid7_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("pid7", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_pid7(self, value): self.bits.pid7 = value
+ def get_pid7(self): value = self.bits.pid7; return value
+
+
+class pid0_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("pid0", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_pid0(self, value): self.bits.pid0 = value
+ def get_pid0(self): value = self.bits.pid0; return value
+
+
+class pid1_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("pid1", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_pid1(self, value): self.bits.pid1 = value
+ def get_pid1(self): value = self.bits.pid1; return value
+
+
+class pid2_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("pid2", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_pid2(self, value): self.bits.pid2 = value
+ def get_pid2(self): value = self.bits.pid2; return value
+
+
+class pid3_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("pid3", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_pid3(self, value): self.bits.pid3 = value
+ def get_pid3(self): value = self.bits.pid3; return value
+
+
+class cid0_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("cid0", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_cid0(self, value): self.bits.cid0 = value
+ def get_cid0(self): value = self.bits.cid0; return value
+
+
+class cid1_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("cid1", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_cid1(self, value): self.bits.cid1 = value
+ def get_cid1(self): value = self.bits.cid1; return value
+
+
+class cid2_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("cid2", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_cid2(self, value): self.bits.cid2 = value
+ def get_cid2(self): value = self.bits.cid2; return value
+
+
+class cid3_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("cid3", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_cid3(self, value): self.bits.cid3 = value
+ def get_cid3(self): value = self.bits.cid3; return value
+
+
+class id_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("version_status", c_uint32, 4),
+ ("version_minor", c_uint32, 4),
+ ("version_major", c_uint32, 4),
+ ("product_major", c_uint32, 4),
+ ("arch_patch_rev", c_uint32, 4),
+ ("arch_minor_rev", c_uint32, 8),
+ ("arch_major_rev", c_uint32, 4),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_version_status(self, value): self.bits.version_status = value
+ def get_version_status(self): value = self.bits.version_status; return value
+ def set_version_minor(self, value): self.bits.version_minor = value
+ def get_version_minor(self): value = self.bits.version_minor; return value
+ def set_version_major(self, value): self.bits.version_major = value
+ def get_version_major(self): value = self.bits.version_major; return value
+ def set_product_major(self, value): self.bits.product_major = value
+ def get_product_major(self): value = self.bits.product_major; return value
+ def set_arch_patch_rev(self, value): self.bits.arch_patch_rev = value
+ def get_arch_patch_rev(self): value = self.bits.arch_patch_rev; return value
+ def set_arch_minor_rev(self, value): self.bits.arch_minor_rev = value
+ def get_arch_minor_rev(self): value = self.bits.arch_minor_rev; return value
+ def set_arch_major_rev(self, value): self.bits.arch_major_rev = value
+ def get_arch_major_rev(self): value = self.bits.arch_major_rev; return value
+
+
+class status_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("state", c_uint32, 1),
+ ("irq_raised", c_uint32, 1),
+ ("bus_status", c_uint32, 1),
+ ("reset_status", c_uint32, 1),
+ ("cmd_parse_error", c_uint32, 1),
+ ("cmd_end_reached", c_uint32, 1),
+ ("pmu_irq_raised", c_uint32, 1),
+ ("wd_fault", c_uint32, 1),
+ ("reserved0", c_uint32, 3),
+ ("faulting_interface", c_uint32, 1),
+ ("faulting_channel", c_uint32, 4),
+ ("irq_history_mask", c_uint32, 16),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_state(self, value): self.bits.state = value
+ def get_state(self): value = self.bits.state; return value
+ def set_irq_raised(self, value): self.bits.irq_raised = value
+ def get_irq_raised(self): value = self.bits.irq_raised; return value
+ def set_bus_status(self, value): self.bits.bus_status = value
+ def get_bus_status(self): value = self.bits.bus_status; return value
+ def set_reset_status(self, value): self.bits.reset_status = value
+ def get_reset_status(self): value = self.bits.reset_status; return value
+ def set_cmd_parse_error(self, value): self.bits.cmd_parse_error = value
+ def get_cmd_parse_error(self): value = self.bits.cmd_parse_error; return value
+ def set_cmd_end_reached(self, value): self.bits.cmd_end_reached = value
+ def get_cmd_end_reached(self): value = self.bits.cmd_end_reached; return value
+ def set_pmu_irq_raised(self, value): self.bits.pmu_irq_raised = value
+ def get_pmu_irq_raised(self): value = self.bits.pmu_irq_raised; return value
+ def set_wd_fault(self, value): self.bits.wd_fault = value
+ def get_wd_fault(self): value = self.bits.wd_fault; return value
+ def set_faulting_interface(self, value): self.bits.faulting_interface = value
+ def get_faulting_interface(self): value = self.bits.faulting_interface; return value
+ def set_faulting_channel(self, value): self.bits.faulting_channel = value
+ def get_faulting_channel(self): value = self.bits.faulting_channel; return value
+ def set_irq_history_mask(self, value): self.bits.irq_history_mask = value
+ def get_irq_history_mask(self): value = self.bits.irq_history_mask; return value
+
+
+class cmd_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("transition_to_running_state", c_uint32, 1),
+ ("clear_irq", c_uint32, 1),
+ ("clock_q_enable", c_uint32, 1),
+ ("power_q_enable", c_uint32, 1),
+ ("stop_request", c_uint32, 1),
+ ("reserved0", c_uint32, 11),
+ ("clear_irq_history", c_uint32, 16),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_transition_to_running_state(self, value): self.bits.transition_to_running_state = value
+ def get_transition_to_running_state(self): value = self.bits.transition_to_running_state; return value
+ def set_clear_irq(self, value): self.bits.clear_irq = value
+ def get_clear_irq(self): value = self.bits.clear_irq; return value
+ def set_clock_q_enable(self, value): self.bits.clock_q_enable = value
+ def get_clock_q_enable(self): value = self.bits.clock_q_enable; return value
+ def set_power_q_enable(self, value): self.bits.power_q_enable = value
+ def get_power_q_enable(self): value = self.bits.power_q_enable; return value
+ def set_stop_request(self, value): self.bits.stop_request = value
+ def get_stop_request(self): value = self.bits.stop_request; return value
+ def set_clear_irq_history(self, value): self.bits.clear_irq_history = value
+ def get_clear_irq_history(self): value = self.bits.clear_irq_history; return value
+
+
+class reset_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("pending_cpl", c_uint32, 1),
+ ("pending_csl", c_uint32, 1),
+ ("reserved0", c_uint32, 30),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_pending_cpl(self, value): self.bits.pending_cpl = value
+ def get_pending_cpl(self): value = self.bits.pending_cpl; return value
+ def set_pending_csl(self, value): self.bits.pending_csl = value
+ def get_pending_csl(self): value = self.bits.pending_csl; return value
+
+
+class qbase0_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("qbase0", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_qbase0(self, value): self.bits.qbase0 = value
+ def get_qbase0(self): value = self.bits.qbase0; return value
+
+
+class qbase1_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("qbase1", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_qbase1(self, value): self.bits.qbase1 = value
+ def get_qbase1(self): value = self.bits.qbase1; return value
+
+
+class qread_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("qread", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_qread(self, value): self.bits.qread = value
+ def get_qread(self): value = self.bits.qread; return value
+
+
+class qconfig_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("qconfig", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_qconfig(self, value): self.bits.qconfig = value
+ def get_qconfig(self): value = self.bits.qconfig; return value
+
+
+class qsize_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("qsize", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_qsize(self, value): self.bits.qsize = value
+ def get_qsize(self): value = self.bits.qsize; return value
+
+
+class prot_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("active_cpl", c_uint32, 1),
+ ("active_csl", c_uint32, 1),
+ ("reserved0", c_uint32, 30),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_active_cpl(self, value): self.bits.active_cpl = value
+ def get_active_cpl(self): value = self.bits.active_cpl; return value
+ def set_active_csl(self, value): self.bits.active_csl = value
+ def get_active_csl(self): value = self.bits.active_csl; return value
+
+
+class config_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("macs_per_cc", c_uint32, 4),
+ ("cmd_stream_version", c_uint32, 4),
+ ("shram_size", c_uint32, 8),
+ ("reserved0", c_uint32, 12),
+ ("product", c_uint32, 4),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_macs_per_cc(self, value): self.bits.macs_per_cc = value
+ def get_macs_per_cc(self): value = self.bits.macs_per_cc; return value
+ def set_cmd_stream_version(self, value): self.bits.cmd_stream_version = value
+ def get_cmd_stream_version(self): value = self.bits.cmd_stream_version; return value
+ def set_shram_size(self, value): self.bits.shram_size = value
+ def get_shram_size(self): value = self.bits.shram_size; return value
+ def set_product(self, value): self.bits.product = value
+ def get_product(self): value = self.bits.product; return value
+
+
+class lock_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("lock", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_lock(self, value): self.bits.lock = value
+ def get_lock(self): value = self.bits.lock; return value
+
+
+class regioncfg_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("region0", c_uint32, 2),
+ ("region1", c_uint32, 2),
+ ("region2", c_uint32, 2),
+ ("region3", c_uint32, 2),
+ ("region4", c_uint32, 2),
+ ("region5", c_uint32, 2),
+ ("region6", c_uint32, 2),
+ ("region7", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_region0(self, value): self.bits.region0 = value
+ def get_region0(self): value = self.bits.region0; return value
+ def set_region1(self, value): self.bits.region1 = value
+ def get_region1(self): value = self.bits.region1; return value
+ def set_region2(self, value): self.bits.region2 = value
+ def get_region2(self): value = self.bits.region2; return value
+ def set_region3(self, value): self.bits.region3 = value
+ def get_region3(self): value = self.bits.region3; return value
+ def set_region4(self, value): self.bits.region4 = value
+ def get_region4(self): value = self.bits.region4; return value
+ def set_region5(self, value): self.bits.region5 = value
+ def get_region5(self): value = self.bits.region5; return value
+ def set_region6(self, value): self.bits.region6 = value
+ def get_region6(self): value = self.bits.region6; return value
+ def set_region7(self, value): self.bits.region7 = value
+ def get_region7(self): value = self.bits.region7; return value
+
+
+class axi_limit0_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("max_beats", c_uint32, 2),
+ ("reserved0", c_uint32, 2),
+ ("memtype", c_uint32, 4),
+ ("reserved1", c_uint32, 8),
+ ("max_outstanding_read_m1", c_uint32, 8),
+ ("max_outstanding_write_m1", c_uint32, 8),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_max_beats(self, value): self.bits.max_beats = value
+ def get_max_beats(self): value = self.bits.max_beats; return value
+ def set_memtype(self, value): self.bits.memtype = value
+ def get_memtype(self): value = self.bits.memtype; return value
+ def set_max_outstanding_read_m1(self, value): self.bits.max_outstanding_read_m1 = value
+ def get_max_outstanding_read_m1(self): value = self.bits.max_outstanding_read_m1; return value
+ def set_max_outstanding_write_m1(self, value): self.bits.max_outstanding_write_m1 = value
+ def get_max_outstanding_write_m1(self): value = self.bits.max_outstanding_write_m1; return value
+
+
+class axi_limit1_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("max_beats", c_uint32, 2),
+ ("reserved0", c_uint32, 2),
+ ("memtype", c_uint32, 4),
+ ("reserved1", c_uint32, 8),
+ ("max_outstanding_read_m1", c_uint32, 8),
+ ("max_outstanding_write_m1", c_uint32, 8),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_max_beats(self, value): self.bits.max_beats = value
+ def get_max_beats(self): value = self.bits.max_beats; return value
+ def set_memtype(self, value): self.bits.memtype = value
+ def get_memtype(self): value = self.bits.memtype; return value
+ def set_max_outstanding_read_m1(self, value): self.bits.max_outstanding_read_m1 = value
+ def get_max_outstanding_read_m1(self): value = self.bits.max_outstanding_read_m1; return value
+ def set_max_outstanding_write_m1(self, value): self.bits.max_outstanding_write_m1 = value
+ def get_max_outstanding_write_m1(self): value = self.bits.max_outstanding_write_m1; return value
+
+
+class axi_limit2_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("max_beats", c_uint32, 2),
+ ("reserved0", c_uint32, 2),
+ ("memtype", c_uint32, 4),
+ ("reserved1", c_uint32, 8),
+ ("max_outstanding_read_m1", c_uint32, 8),
+ ("max_outstanding_write_m1", c_uint32, 8),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_max_beats(self, value): self.bits.max_beats = value
+ def get_max_beats(self): value = self.bits.max_beats; return value
+ def set_memtype(self, value): self.bits.memtype = value
+ def get_memtype(self): value = self.bits.memtype; return value
+ def set_max_outstanding_read_m1(self, value): self.bits.max_outstanding_read_m1 = value
+ def get_max_outstanding_read_m1(self): value = self.bits.max_outstanding_read_m1; return value
+ def set_max_outstanding_write_m1(self, value): self.bits.max_outstanding_write_m1 = value
+ def get_max_outstanding_write_m1(self): value = self.bits.max_outstanding_write_m1; return value
+
+
+class axi_limit3_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("max_beats", c_uint32, 2),
+ ("reserved0", c_uint32, 2),
+ ("memtype", c_uint32, 4),
+ ("reserved1", c_uint32, 8),
+ ("max_outstanding_read_m1", c_uint32, 8),
+ ("max_outstanding_write_m1", c_uint32, 8),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_max_beats(self, value): self.bits.max_beats = value
+ def get_max_beats(self): value = self.bits.max_beats; return value
+ def set_memtype(self, value): self.bits.memtype = value
+ def get_memtype(self): value = self.bits.memtype; return value
+ def set_max_outstanding_read_m1(self, value): self.bits.max_outstanding_read_m1 = value
+ def get_max_outstanding_read_m1(self): value = self.bits.max_outstanding_read_m1; return value
+ def set_max_outstanding_write_m1(self, value): self.bits.max_outstanding_write_m1 = value
+ def get_max_outstanding_write_m1(self): value = self.bits.max_outstanding_write_m1; return value
+
+
+class pmcr_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("cnt_en", c_uint32, 1),
+ ("event_cnt_rst", c_uint32, 1),
+ ("cycle_cnt_rst", c_uint32, 1),
+ ("mask_en", c_uint32, 1),
+ ("reserved0", c_uint32, 7),
+ ("num_event_cnt", c_uint32, 5),
+ ("reserved1", c_uint32, 16),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_cnt_en(self, value): self.bits.cnt_en = value
+ def get_cnt_en(self): value = self.bits.cnt_en; return value
+ def set_event_cnt_rst(self, value): self.bits.event_cnt_rst = value
+ def get_event_cnt_rst(self): value = self.bits.event_cnt_rst; return value
+ def set_cycle_cnt_rst(self, value): self.bits.cycle_cnt_rst = value
+ def get_cycle_cnt_rst(self): value = self.bits.cycle_cnt_rst; return value
+ def set_mask_en(self, value): self.bits.mask_en = value
+ def get_mask_en(self): value = self.bits.mask_en; return value
+ def set_num_event_cnt(self, value): self.bits.num_event_cnt = value
+ def get_num_event_cnt(self): value = self.bits.num_event_cnt; return value
+
+
+class pmcntenset_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("event_cnt_0", c_uint32, 1),
+ ("event_cnt_1", c_uint32, 1),
+ ("event_cnt_2", c_uint32, 1),
+ ("event_cnt_3", c_uint32, 1),
+ ("reserved0", c_uint32, 27),
+ ("cycle_cnt", c_uint32, 1),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_event_cnt_0(self, value): self.bits.event_cnt_0 = value
+ def get_event_cnt_0(self): value = self.bits.event_cnt_0; return value
+ def set_event_cnt_1(self, value): self.bits.event_cnt_1 = value
+ def get_event_cnt_1(self): value = self.bits.event_cnt_1; return value
+ def set_event_cnt_2(self, value): self.bits.event_cnt_2 = value
+ def get_event_cnt_2(self): value = self.bits.event_cnt_2; return value
+ def set_event_cnt_3(self, value): self.bits.event_cnt_3 = value
+ def get_event_cnt_3(self): value = self.bits.event_cnt_3; return value
+ def set_cycle_cnt(self, value): self.bits.cycle_cnt = value
+ def get_cycle_cnt(self): value = self.bits.cycle_cnt; return value
+
+
+class pmcntenclr_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("event_cnt_0", c_uint32, 1),
+ ("event_cnt_1", c_uint32, 1),
+ ("event_cnt_2", c_uint32, 1),
+ ("event_cnt_3", c_uint32, 1),
+ ("reserved0", c_uint32, 27),
+ ("cycle_cnt", c_uint32, 1),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_event_cnt_0(self, value): self.bits.event_cnt_0 = value
+ def get_event_cnt_0(self): value = self.bits.event_cnt_0; return value
+ def set_event_cnt_1(self, value): self.bits.event_cnt_1 = value
+ def get_event_cnt_1(self): value = self.bits.event_cnt_1; return value
+ def set_event_cnt_2(self, value): self.bits.event_cnt_2 = value
+ def get_event_cnt_2(self): value = self.bits.event_cnt_2; return value
+ def set_event_cnt_3(self, value): self.bits.event_cnt_3 = value
+ def get_event_cnt_3(self): value = self.bits.event_cnt_3; return value
+ def set_cycle_cnt(self, value): self.bits.cycle_cnt = value
+ def get_cycle_cnt(self): value = self.bits.cycle_cnt; return value
+
+
+class pmovsset_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("event_cnt_0_ovf", c_uint32, 1),
+ ("event_cnt_1_ovf", c_uint32, 1),
+ ("event_cnt_2_ovf", c_uint32, 1),
+ ("event_cnt_3_ovf", c_uint32, 1),
+ ("reserved0", c_uint32, 27),
+ ("cycle_cnt_ovf", c_uint32, 1),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_event_cnt_0_ovf(self, value): self.bits.event_cnt_0_ovf = value
+ def get_event_cnt_0_ovf(self): value = self.bits.event_cnt_0_ovf; return value
+ def set_event_cnt_1_ovf(self, value): self.bits.event_cnt_1_ovf = value
+ def get_event_cnt_1_ovf(self): value = self.bits.event_cnt_1_ovf; return value
+ def set_event_cnt_2_ovf(self, value): self.bits.event_cnt_2_ovf = value
+ def get_event_cnt_2_ovf(self): value = self.bits.event_cnt_2_ovf; return value
+ def set_event_cnt_3_ovf(self, value): self.bits.event_cnt_3_ovf = value
+ def get_event_cnt_3_ovf(self): value = self.bits.event_cnt_3_ovf; return value
+ def set_cycle_cnt_ovf(self, value): self.bits.cycle_cnt_ovf = value
+ def get_cycle_cnt_ovf(self): value = self.bits.cycle_cnt_ovf; return value
+
+
+class pmovsclr_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("event_cnt_0_ovf", c_uint32, 1),
+ ("event_cnt_1_ovf", c_uint32, 1),
+ ("event_cnt_2_ovf", c_uint32, 1),
+ ("event_cnt_3_ovf", c_uint32, 1),
+ ("reserved0", c_uint32, 27),
+ ("cycle_cnt_ovf", c_uint32, 1),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_event_cnt_0_ovf(self, value): self.bits.event_cnt_0_ovf = value
+ def get_event_cnt_0_ovf(self): value = self.bits.event_cnt_0_ovf; return value
+ def set_event_cnt_1_ovf(self, value): self.bits.event_cnt_1_ovf = value
+ def get_event_cnt_1_ovf(self): value = self.bits.event_cnt_1_ovf; return value
+ def set_event_cnt_2_ovf(self, value): self.bits.event_cnt_2_ovf = value
+ def get_event_cnt_2_ovf(self): value = self.bits.event_cnt_2_ovf; return value
+ def set_event_cnt_3_ovf(self, value): self.bits.event_cnt_3_ovf = value
+ def get_event_cnt_3_ovf(self): value = self.bits.event_cnt_3_ovf; return value
+ def set_cycle_cnt_ovf(self, value): self.bits.cycle_cnt_ovf = value
+ def get_cycle_cnt_ovf(self): value = self.bits.cycle_cnt_ovf; return value
+
+
+class pmintset_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("event_cnt_0_int", c_uint32, 1),
+ ("event_cnt_1_int", c_uint32, 1),
+ ("event_cnt_2_int", c_uint32, 1),
+ ("event_cnt_3_int", c_uint32, 1),
+ ("reserved0", c_uint32, 27),
+ ("cycle_cnt_int", c_uint32, 1),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_event_cnt_0_int(self, value): self.bits.event_cnt_0_int = value
+ def get_event_cnt_0_int(self): value = self.bits.event_cnt_0_int; return value
+ def set_event_cnt_1_int(self, value): self.bits.event_cnt_1_int = value
+ def get_event_cnt_1_int(self): value = self.bits.event_cnt_1_int; return value
+ def set_event_cnt_2_int(self, value): self.bits.event_cnt_2_int = value
+ def get_event_cnt_2_int(self): value = self.bits.event_cnt_2_int; return value
+ def set_event_cnt_3_int(self, value): self.bits.event_cnt_3_int = value
+ def get_event_cnt_3_int(self): value = self.bits.event_cnt_3_int; return value
+ def set_cycle_cnt_int(self, value): self.bits.cycle_cnt_int = value
+ def get_cycle_cnt_int(self): value = self.bits.cycle_cnt_int; return value
+
+
+class pmintclr_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("event_cnt_0_int", c_uint32, 1),
+ ("event_cnt_1_int", c_uint32, 1),
+ ("event_cnt_2_int", c_uint32, 1),
+ ("event_cnt_3_int", c_uint32, 1),
+ ("reserved0", c_uint32, 27),
+ ("cycle_cnt_int", c_uint32, 1),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_event_cnt_0_int(self, value): self.bits.event_cnt_0_int = value
+ def get_event_cnt_0_int(self): value = self.bits.event_cnt_0_int; return value
+ def set_event_cnt_1_int(self, value): self.bits.event_cnt_1_int = value
+ def get_event_cnt_1_int(self): value = self.bits.event_cnt_1_int; return value
+ def set_event_cnt_2_int(self, value): self.bits.event_cnt_2_int = value
+ def get_event_cnt_2_int(self): value = self.bits.event_cnt_2_int; return value
+ def set_event_cnt_3_int(self, value): self.bits.event_cnt_3_int = value
+ def get_event_cnt_3_int(self): value = self.bits.event_cnt_3_int; return value
+ def set_cycle_cnt_int(self, value): self.bits.cycle_cnt_int = value
+ def get_cycle_cnt_int(self): value = self.bits.cycle_cnt_int; return value
+
+
+class pmccntr_lo_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("cycle_cnt_lo", c_uint32, 32),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_cycle_cnt_lo(self, value): self.bits.cycle_cnt_lo = value
+ def get_cycle_cnt_lo(self): value = self.bits.cycle_cnt_lo; return value
+
+
+class pmccntr_hi_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("cycle_cnt_hi", c_uint32, 16),
+ ("reserved0", c_uint32, 16),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_cycle_cnt_hi(self, value): self.bits.cycle_cnt_hi = value
+ def get_cycle_cnt_hi(self): value = self.bits.cycle_cnt_hi; return value
+
+
+class pmccntr_cfg_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("cycle_cnt_cfg_start", c_uint32, 10),
+ ("reserved0", c_uint32, 6),
+ ("cycle_cnt_cfg_stop", c_uint32, 10),
+ ("reserved1", c_uint32, 6),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_cycle_cnt_cfg_start(self, value): self.bits.cycle_cnt_cfg_start = value
+ def get_cycle_cnt_cfg_start(self): value = self.bits.cycle_cnt_cfg_start; return value
+ def set_cycle_cnt_cfg_stop(self, value): self.bits.cycle_cnt_cfg_stop = value
+ def get_cycle_cnt_cfg_stop(self): value = self.bits.cycle_cnt_cfg_stop; return value
+
+
+class pmcaxi_chan_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("axi_chan", c_uint32, 4),
+ ("reserved0", c_uint32, 3),
+ ("rw", c_uint32, 1),
+ ("axi_cnt", c_uint32, 2),
+ ("reserved1", c_uint32, 22),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_axi_chan(self, value): self.bits.axi_chan = value
+ def get_axi_chan(self): value = self.bits.axi_chan; return value
+ def set_rw(self, value): self.bits.rw = value
+ def get_rw(self): value = self.bits.rw; return value
+ def set_axi_cnt(self, value): self.bits.axi_cnt = value
+ def get_axi_cnt(self): value = self.bits.axi_cnt; return value
+
+
+class pmevtyper0_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("ev_type", c_uint32, 10),
+ ("reserved0", c_uint32, 22),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_ev_type(self, value): self.bits.ev_type = value
+ def get_ev_type(self): value = self.bits.ev_type; return value
+
+
+class pmevtyper1_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("ev_type", c_uint32, 10),
+ ("reserved0", c_uint32, 22),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_ev_type(self, value): self.bits.ev_type = value
+ def get_ev_type(self): value = self.bits.ev_type; return value
+
+
+class pmevtyper2_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("ev_type", c_uint32, 10),
+ ("reserved0", c_uint32, 22),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_ev_type(self, value): self.bits.ev_type = value
+ def get_ev_type(self): value = self.bits.ev_type; return value
+
+
+class pmevtyper3_r(Union):
+ class _bitfield(Structure):
+ _fields_ = [
+ ("ev_type", c_uint32, 10),
+ ("reserved0", c_uint32, 22),
+ ]
+ _fields_ = [("bits", _bitfield),
+ ("word", c_uint32)]
+ def set_ev_type(self, value): self.bits.ev_type = value
+ def get_ev_type(self): value = self.bits.ev_type; return value
+
+class command_no_payload_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class command_with_payload_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("param", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_op_stop_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("mask", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_STOP and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_mask(self): return mask
+ def set_mask(self, value): mask = value
+
+class npu_op_irq_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("mask", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_IRQ and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_mask(self): return mask
+ def set_mask(self, value): mask = value
+
+class npu_op_conv_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("reserved0", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_CONV and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+
+class npu_op_depthwise_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("reserved0", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_DEPTHWISE and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+
+class npu_op_pool_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("mode", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_POOL and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_mode(self): return mode
+ def set_mode(self, value): mode = value
+
+class npu_op_elementwise_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("mode", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_ELEMENTWISE and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_mode(self): return mode
+ def set_mode(self, value): mode = value
+
+class npu_op_dma_start_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("channel_mode", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_DMA_START and must_be_zero0==0;
+ def get_channel_mode(self): return channel_mode
+ def set_channel_mode(self, value): channel_mode = value
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+
+class npu_op_dma_wait_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("reserved0", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_DMA_WAIT and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+
+class npu_op_kernel_wait_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_KERNEL_WAIT and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_op_pmu_mask_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_OP_PMU_MASK and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_pad_top_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_PAD_TOP and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_pad_left_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_PAD_LEFT and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_pad_right_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_PAD_RIGHT and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_pad_bottom_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_PAD_BOTTOM and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_depth_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_DEPTH_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_precision_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 4),
+ ("reserved0", c_uint32, 2),
+ ("format", c_uint32, 2),
+ ("scale_mode", c_uint32, 2),
+ ("reserved1", c_uint32, 4),
+ ("round_mode", c_uint32, 2),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_PRECISION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_format(self): return format
+ def set_format(self, value): format = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+ def get_round_mode(self): return round_mode
+ def set_round_mode(self, value): round_mode = value
+ def get_scale_mode(self): return scale_mode
+ def set_scale_mode(self, value): scale_mode = value
+
+class npu_set_ifm_upscale_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("mode", c_uint32, 2),
+ ("reserved0", c_uint32, 14),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_UPSCALE and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_mode(self): return mode
+ def set_mode(self, value): mode = value
+
+class npu_set_ifm_zero_point_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_ZERO_POINT and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_width0_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_WIDTH0_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_height0_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_HEIGHT0_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_height1_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_HEIGHT1_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_ib_end_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_IB_END and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_region_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM_REGION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_width_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_WIDTH_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_height_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_HEIGHT_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_depth_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_DEPTH_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_precision_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("precision", c_uint32, 3),
+ ("reserved0", c_uint32, 3),
+ ("format", c_uint32, 2),
+ ("scaling", c_uint32, 1),
+ ("reserved1", c_uint32, 5),
+ ("rounding", c_uint32, 2),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_PRECISION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_format(self): return format
+ def set_format(self, value): format = value
+ def get_precision(self): return precision
+ def set_precision(self, value): precision = value
+ def get_rounding(self): return rounding
+ def set_rounding(self, value): rounding = value
+ def get_scaling(self): return scaling
+ def set_scaling(self, value): scaling = value
+
+class npu_set_ofm_blk_width_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_BLK_WIDTH_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_blk_height_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_BLK_HEIGHT_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_blk_depth_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_BLK_DEPTH_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_zero_point_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_ZERO_POINT and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_width0_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_WIDTH0_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_height0_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_HEIGHT0_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_height1_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_HEIGHT1_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ofm_region_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_OFM_REGION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_kernel_width_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_KERNEL_WIDTH_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_kernel_height_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_KERNEL_HEIGHT_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_kernel_stride_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_KERNEL_STRIDE and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_parallel_mode_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_PARALLEL_MODE and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_acc_format_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_ACC_FORMAT and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_activation_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("type", c_uint32, 12),
+ ("act_clip_range", c_uint32, 4),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_ACTIVATION and must_be_zero0==0;
+ def get_act_clip_range(self): return act_clip_range
+ def set_act_clip_range(self, value): act_clip_range = value
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_type(self): return type
+ def set_type(self, value): type = value
+
+class npu_set_activation_min_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_ACTIVATION_MIN and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_activation_max_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_ACTIVATION_MAX and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_weight_region_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_WEIGHT_REGION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_scale_region_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_SCALE_REGION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ab_start_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_AB_START and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_blockdep_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_BLOCKDEP and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_dma0_src_region_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("region", c_uint32, 8),
+ ("internal", c_uint32, 1),
+ ("stride_mode", c_uint32, 2),
+ ("reserved0", c_uint32, 5),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_DMA0_SRC_REGION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_internal(self): return internal
+ def set_internal(self, value): internal = value
+ def get_region(self): return region
+ def set_region(self, value): region = value
+ def get_stride_mode(self): return stride_mode
+ def set_stride_mode(self, value): stride_mode = value
+
+class npu_set_dma0_dst_region_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("region", c_uint32, 8),
+ ("internal", c_uint32, 1),
+ ("stride_mode", c_uint32, 2),
+ ("reserved0", c_uint32, 5),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_DMA0_DST_REGION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_internal(self): return internal
+ def set_internal(self, value): internal = value
+ def get_region(self): return region
+ def set_region(self, value): region = value
+ def get_stride_mode(self): return stride_mode
+ def set_stride_mode(self, value): stride_mode = value
+
+class npu_set_dma0_size0_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_DMA0_SIZE0 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_dma0_size1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_DMA0_SIZE1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm2_broadcast_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("broadcast_height", c_uint32, 1),
+ ("broadcast_width", c_uint32, 1),
+ ("broadcast_depth", c_uint32, 1),
+ ("reserved0", c_uint32, 3),
+ ("operand_order", c_uint32, 1),
+ ("broadcast_scalar", c_uint32, 1),
+ ("reserved1", c_uint32, 8),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM2_BROADCAST and must_be_zero0==0;
+ def get_broadcast_depth(self): return broadcast_depth
+ def set_broadcast_depth(self, value): broadcast_depth = value
+ def get_broadcast_height(self): return broadcast_height
+ def set_broadcast_height(self, value): broadcast_height = value
+ def get_broadcast_scalar(self): return broadcast_scalar
+ def set_broadcast_scalar(self, value): broadcast_scalar = value
+ def get_broadcast_width(self): return broadcast_width
+ def set_broadcast_width(self, value): broadcast_width = value
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_operand_order(self): return operand_order
+ def set_operand_order(self, value): operand_order = value
+
+class npu_set_ifm2_scalar_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM2_SCALAR and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm2_precision_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 4),
+ ("reserved0", c_uint32, 2),
+ ("format", c_uint32, 2),
+ ("reserved1", c_uint32, 8),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM2_PRECISION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_format(self): return format
+ def set_format(self, value): format = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm2_zero_point_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM2_ZERO_POINT and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm2_width0_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM2_WIDTH0_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm2_height0_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM2_HEIGHT0_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm2_height1_m1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM2_HEIGHT1_M1 and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm2_ib_start_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM2_IB_START and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm2_region_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero0", c_uint32, 6),
+ ("param", c_uint32, 16),
+ ]
+ def valid(self): return cmd_code==cmd0.NPU_SET_IFM2_REGION and must_be_zero0==0;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+
+class npu_set_ifm_base0_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM_BASE0 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm_base1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM_BASE1 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm_base2_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM_BASE2 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm_base3_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM_BASE3 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm_stride_x_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM_STRIDE_X and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm_stride_y_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM_STRIDE_Y and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm_stride_c_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM_STRIDE_C and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ofm_base0_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OFM_BASE0 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ofm_base1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OFM_BASE1 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ofm_base2_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OFM_BASE2 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ofm_base3_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OFM_BASE3 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ofm_stride_x_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OFM_STRIDE_X and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ofm_stride_y_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OFM_STRIDE_Y and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ofm_stride_c_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OFM_STRIDE_C and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_weight_base_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_WEIGHT_BASE and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_weight_length_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_WEIGHT_LENGTH and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_scale_base_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_SCALE_BASE and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_scale_length_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_SCALE_LENGTH and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ofm_scale_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("shift", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OFM_SCALE and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+ def get_shift(self): return shift
+ def set_shift(self, value): shift = value
+
+class npu_set_opa_scale_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("shift", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OPA_SCALE and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+ def get_shift(self): return shift
+ def set_shift(self, value): shift = value
+
+class npu_set_opb_scale_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_OPB_SCALE and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_dma0_src_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_DMA0_SRC and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_dma0_dst_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_DMA0_DST and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_dma0_len_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_DMA0_LEN and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_dma0_skip0_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("param", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_DMA0_SKIP0 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_dma0_skip1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("param", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_DMA0_SKIP1 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm2_base0_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM2_BASE0 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm2_base1_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM2_BASE1 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm2_base2_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM2_BASE2 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm2_base3_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM2_BASE3 and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm2_stride_x_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM2_STRIDE_X and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm2_stride_y_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM2_STRIDE_Y and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_ifm2_stride_c_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_IFM2_STRIDE_C and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_weight1_base_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("param", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_WEIGHT1_BASE and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_weight1_length_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_WEIGHT1_LENGTH and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_scale1_base_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("param", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_SCALE1_BASE and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_param(self): return param
+ def set_param(self, value): param = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
+
+class npu_set_scale1_length_t(Structure):
+ _fields_ = [
+ ("cmd_code", c_uint32, 10),
+ ("must_be_zero", c_uint32, 4),
+ ("payload_size", c_uint32, 2),
+ ("reserved0", c_uint32, 16),
+ ("data", c_uint32, 32),
+ ]
+ def valid(self): return cmd_code==cmd1.NPU_SET_SCALE1_LENGTH and must_be_zero==0 and payload_size>=1 and payload_size<=2;
+ def get_cmd_code(self): return cmd_code
+ def set_cmd_code(self, value): cmd_code = value
+ def get_data(self): return data
+ def set_data(self, value): data = value
+ def get_payload_size(self): return payload_size
+ def set_payload_size(self, value): payload_size = value
diff --git a/ethosu/vela/extract_npu_subgraphs.py b/ethosu/vela/extract_npu_subgraphs.py
new file mode 100644
index 0000000..5b9ba8b
--- /dev/null
+++ b/ethosu/vela/extract_npu_subgraphs.py
@@ -0,0 +1,253 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Vela separates CPU operations and NPU operations into separate internal subgraphs. The CPU operations are left
+# untouched in the final output.
+#
+# Vela does this by identifying NPU passes and pulling them out from the main CPU graph into separate subgraphs, invoked
+# by NpuOp operations. Later, Vela generates command streams and compressed weight streams for the NPU subgraphs and
+# attaches them to the NpuOp. This encapsulates everything the NPU subgraph is supposed to do.
+
+from .nn_graph import Pass, PassPlacement, NpuBlockType, Subgraph
+from .operation import Operation
+import numpy as np
+
+
+def make_npu_call_op_pass(npu_subgraph):
+ op = Operation("NpuOp", "call_" + npu_subgraph.name)
+ op.attrs["subgraph"] = npu_subgraph
+ ps = Pass(op.name, PassPlacement.MemoryOnly, False, NpuBlockType.Default)
+ ps.ops = [op]
+ ps.primary_op = op
+ op.attrs["npu_block_type"] = ps.npu_block_type
+ op.scheduled_pass = ps
+
+ # Inputs and outputs filled in later as we cut the graphs
+ return ps
+
+
+def switch_tensor_for_op(op, orig_tens, new_tens):
+
+ op.inputs = [new_tens if tens == orig_tens else tens for tens in op.inputs]
+ op.outputs = [new_tens if tens == orig_tens else tens for tens in op.outputs]
+
+ ps = op.scheduled_pass
+ if ps is None:
+ return
+
+ ps.inputs = [new_tens if tens == orig_tens else tens for tens in ps.inputs]
+ ps.outputs = [new_tens if tens == orig_tens else tens for tens in ps.outputs]
+
+ if ps.ifm_tensor == orig_tens:
+ ps.ifm_tensor = new_tens
+ if ps.ifm2_tensor == orig_tens:
+ ps.ifm2_tensor = new_tens
+ if ps.ofm_tensor == orig_tens:
+ ps.ofm_tensor = new_tens
+ if ps.weight_tensor == orig_tens:
+ ps.weight_tensor = new_tens
+ if ps.scale_tensor == orig_tens:
+ ps.scale_tensor = new_tens
+
+
+def rewrite_tensor_cpu_producer_npu_consumers(
+ orig_tens, call_ps, startup_init_ps, npu_subgraph, cpu_subgraph, subgraph_for_pass
+):
+ is_const = orig_tens.ops[0].type == "Const"
+
+ new_tens = orig_tens.clone("_npu")
+ orig_tens.npu_tensor = new_tens
+ new_tens.cpu_tensor = orig_tens
+
+ op_type = "SubgraphInput"
+ if is_const:
+ op_type = "Const"
+ op = Operation(op_type, orig_tens.name + "_input")
+ op.attrs["npu_block_type"] = NpuBlockType.Default
+ op.outputs = [new_tens]
+ op.scheduled_pass = startup_init_ps
+ new_tens.ops = [op]
+ startup_init_ps.ops.append(op)
+ startup_init_ps.outputs.append(new_tens)
+
+ if not is_const:
+ call_ps.inputs.append(orig_tens)
+ call_ps.primary_op.inputs.append(orig_tens)
+
+ for op in list(orig_tens.consumers()):
+ if op is None:
+ continue # Subgraph consumers handled separately.
+ ps = op.scheduled_pass
+ if subgraph_for_pass[ps] == npu_subgraph:
+ switch_tensor_for_op(op, orig_tens, new_tens)
+ orig_tens.consumer_list.remove(op)
+ new_tens.consumer_list.append(op)
+
+ # Deal with output tensors for the NPU graph. These are special.
+ npu_subgraph.output_tensors = [new_tens if tens == orig_tens else tens for tens in npu_subgraph.output_tensors]
+
+
+def rewrite_tensor_npu_producer_cpu_consumers(
+ orig_tens, call_ps, startup_init_ps, npu_subgraph, cpu_subgraph, subgraph_for_pass
+):
+
+ new_tens = orig_tens.clone("_cpu")
+ new_tens.npu_tensor = orig_tens
+ orig_tens.cpu_tensor = new_tens
+
+ npu_subgraph.output_tensors.append(orig_tens)
+
+ call_ps.outputs.append(new_tens)
+ call_ps.primary_op.outputs.append(new_tens)
+ new_tens.ops = [call_ps.primary_op]
+
+ for op in list(orig_tens.consumers()):
+ if op is None:
+ continue # Subgraph consumers handled separately.
+ ps = op.scheduled_pass
+ if subgraph_for_pass[ps] != npu_subgraph:
+ switch_tensor_for_op(op, orig_tens, new_tens)
+ orig_tens.consumer_list.remove(op)
+ new_tens.consumer_list.append(op)
+
+ # Deal with output tensors for the CPU graph. These are special.
+ cpu_subgraph.output_tensors = [new_tens if tens == orig_tens else tens for tens in cpu_subgraph.output_tensors]
+
+
+def extract_subgraph(nng, orig_sg, arch):
+ assert orig_sg.placement == PassPlacement.Cpu
+
+ passes = list(orig_sg.passes)
+ place_vec = np.array([ps.placement for ps in passes])
+ place_vec[
+ place_vec == PassPlacement.StartupInit
+ ] = PassPlacement.Cpu # Keep the startup init pass on the CPU, we'll make new ones to move onto NPU.
+
+ # MemoryOnly passes that are either squeezed between NPU passes or on the boundary of NPU and CPU
+ # passes should be assigned to the NPU.
+
+ # Forward, then backwards
+ for is_reversed in range(2):
+ last_place = PassPlacement.Cpu
+ seq = enumerate(place_vec)
+ if is_reversed:
+ seq = reversed(list(seq))
+ for idx, place in seq:
+ if place == PassPlacement.MemoryOnly:
+ if last_place == PassPlacement.Npu:
+ place = PassPlacement.Npu
+ place_vec[idx] = place
+
+ if place != PassPlacement.MemoryOnly:
+ last_place = place
+
+ # Anything left, assign to the CPU.
+ place_vec[place_vec == PassPlacement.MemoryOnly] = PassPlacement.Cpu
+
+ if np.all(place_vec == PassPlacement.Cpu):
+ return [] # Nothing to do
+
+ # Create the subgraphs and split passes between them
+
+ new_subgraphs = []
+ split_count = 0
+ subgraph_for_pass = {}
+ orig_sg.passes = []
+ call_pass = {}
+ startup_init_passes = {}
+
+ last_place = PassPlacement.Cpu
+ curr_sg = orig_sg
+
+ for idx, place in enumerate(place_vec):
+ if place != last_place:
+ if place == PassPlacement.Npu:
+ split_count += 1
+ curr_sg = Subgraph("%s_split_%d" % (orig_sg.name, split_count), PassPlacement.Npu)
+ new_subgraphs.append(curr_sg)
+ call_ps = make_npu_call_op_pass(curr_sg)
+ subgraph_for_pass[call_ps] = orig_sg
+ orig_sg.passes.append(call_ps)
+ call_pass[curr_sg] = call_ps
+
+ startup_init_ps = Pass(
+ curr_sg.name + "_startup_init", PassPlacement.StartupInit, False, NpuBlockType.Default
+ )
+ curr_sg.passes.append(startup_init_ps)
+ startup_init_passes[curr_sg] = startup_init_ps
+ subgraph_for_pass[startup_init_ps] = curr_sg
+
+ else:
+ curr_sg = orig_sg
+ last_place = place
+ ps = passes[idx]
+ subgraph_for_pass[ps] = curr_sg
+ curr_sg.passes.append(ps)
+
+ # Rewrite tensors to fix up graphs.
+
+ for curr_sg in new_subgraphs:
+ for ps in curr_sg.passes:
+ for tens in ps.inputs:
+ source_sgs = [subgraph_for_pass[op.scheduled_pass] for op in tens.ops]
+ assert len(source_sgs) >= 0
+ producer_sg = source_sgs[0]
+ for sg in source_sgs:
+ assert sg == producer_sg # All need to be the same.
+
+ if producer_sg != curr_sg:
+ assert (
+ producer_sg == orig_sg
+ ) # Because we go in-order, all the producers must be the original graph.
+ rewrite_tensor_cpu_producer_npu_consumers(
+ tens, call_pass[curr_sg], startup_init_passes[curr_sg], curr_sg, orig_sg, subgraph_for_pass
+ )
+
+ for tens in ps.outputs:
+
+ dest_sgs = [subgraph_for_pass[op.scheduled_pass] for op in tens.consumers() if op is not None]
+ need_rewrite = False
+ for sg in dest_sgs:
+ if sg != curr_sg:
+ need_rewrite = True
+ break
+ if tens in orig_sg.output_tensors:
+ need_rewrite = True
+
+ if need_rewrite:
+ rewrite_tensor_npu_producer_cpu_consumers(
+ tens, call_pass[curr_sg], startup_init_passes[curr_sg], curr_sg, orig_sg, subgraph_for_pass
+ )
+
+ return new_subgraphs
+
+
+def extract_npu_subgraphs(nng, arch):
+
+ nng.refresh_after_modification()
+
+ for sg in list(nng.subgraphs):
+ if sg.placement == PassPlacement.Cpu:
+ new_subgraphs = extract_subgraph(nng, sg, arch)
+ nng.subgraphs += new_subgraphs
+
+ nng.refresh_after_modification()
+ nng.prune_startup_init_pass()
+
+ for sg in nng.subgraphs:
+ sg.build_pass_links()
diff --git a/ethosu/vela/graph_optimiser.py b/ethosu/vela/graph_optimiser.py
new file mode 100644
index 0000000..f0afcf8
--- /dev/null
+++ b/ethosu/vela/graph_optimiser.py
@@ -0,0 +1,485 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Early optimisation of the network graph, using the rewrite_graph module to do the traversal of the graph. These are
+# split into two parts optimise_graph_a and optimise_graph_b.
+
+from .nn_graph import Operation, NpuBlockType, Tensor
+from . import rewrite_graph
+from .data_type import BaseType, DataType
+import numpy as np
+import math
+from .numeric_util import round_up_divide
+
+passthrough_nodes = set(("Identity",))
+
+
+def remove_passthrough_tensor(tens, arch):
+ if len(tens.ops) == 1 and tens.ops[0].type in passthrough_nodes:
+ assert len(tens.ops[0].inputs) == 1
+ tens = tens.ops[0].inputs[0]
+ return tens
+
+
+def rewrite_concat(tens, arch):
+ if len(tens.ops) == 1 and tens.ops[0].is_concat_op():
+ concat_op = tens.ops[0]
+ if tens != concat_op.outputs[0]:
+ return tens # don't attempt to rewrite the min/max outputs of QuantizedConcat
+
+ # Not supported so leave it and run on CPU
+ if not concat_op.run_on_npu:
+ return tens
+
+ inputs, axis = concat_op.get_concat_inputs_axis()
+
+ tens.ops = []
+ offset = 0
+ for idx, inp in enumerate(inputs):
+ new_op = Operation("ConcatSliceWrite", concat_op.name + str(idx))
+ new_op.inputs = [inp]
+ new_op.outputs = [tens]
+ new_op.attrs["concat_axis"] = axis
+ new_op.attrs["concat_start"] = offset
+ offset += inp.shape[axis]
+ new_op.attrs["concat_end"] = offset
+ new_op.run_on_npu = True
+ tens.ops.append(new_op)
+ assert tens.shape[axis] == offset
+
+ return tens
+
+
+def rewrite_split(tens, arch):
+
+ if len(tens.ops) == 1 and tens.ops[0].is_split_op():
+ split_op = tens.ops[0]
+
+ # Not supported so leave it and run on CPU
+ if not split_op.run_on_npu:
+ return tens
+
+ inp, outputs, axis, offset_start, offset_end = split_op.get_split_inputs_axis()
+
+ tens.ops = []
+ new_op = Operation("SplitSliceRead", split_op.name)
+ new_op.inputs = [inp]
+ new_op.outputs = [tens]
+
+ # For Split the offset cannot be extracted from the tensor so it has to
+ # be calculated from the index of the output tensor
+ if axis != None:
+ # Get the start and end of the split
+ offset_start = [0] * len(tens.shape)
+ offset_end = [0] * len(tens.shape)
+ for out in outputs:
+ if out == tens:
+ break
+ offset_start[axis] += out.shape[axis]
+
+ offset_end[axis] = offset_start[axis] + tens.shape[axis]
+
+ new_op.attrs["split_start"] = offset_start
+ new_op.attrs["split_end"] = offset_end
+ new_op.run_on_npu = True
+ tens.ops.append(new_op)
+
+ return tens
+
+
+def needed_total_padding(input_size, stride, filter_size):
+ out_size = (input_size + stride - 1) // stride
+ needed_input = (out_size - 1) * stride + filter_size
+ total_padding = max(0, needed_input - input_size)
+ return total_padding
+
+
+def calc_padding_and_skirt(padding_type, kernel_size, stride, input_dims):
+ ypad = needed_total_padding(int(input_dims[1]), int(stride[1]), int(kernel_size[0]))
+ xpad = needed_total_padding(int(input_dims[2]), int(stride[2]), int(kernel_size[1]))
+ if padding_type == b"SAME":
+ left_pad = (xpad + 0) // 2
+ right_pad = (xpad + 1) // 2
+ top_pad = (ypad + 0) // 2
+ bottom_pad = (ypad + 1) // 2
+ elif padding_type == b"VALID":
+ left_pad = 0
+ right_pad = 0
+ top_pad = 0
+ bottom_pad = 0
+ else:
+ assert 0, "Unknown padding"
+ padding = (top_pad, left_pad, bottom_pad, right_pad)
+ skirt = (top_pad, left_pad, ypad - top_pad, xpad - left_pad)
+ return padding, skirt
+
+
+def fixup_conv2d_backprop(op, arch):
+ if op.type == "Conv2DBackpropInput":
+ # flip the inputs
+ op.inputs[0], op.inputs[2] = op.inputs[2], op.inputs[0]
+ op.type = "Conv2DBackpropInputSwitched"
+
+ return op
+
+
+def fixup_fully_connected_input(op, arch):
+ if op.type == "FullyConnectedAct":
+ inp = op.inputs[0]
+ weights = op.inputs[1]
+
+ n_in_elems = weights.shape[-2]
+ elms = inp.elements()
+ batch_size = elms // n_in_elems
+ assert batch_size * n_in_elems == elms
+
+ desired_shape = [batch_size, n_in_elems]
+ if inp.shape != desired_shape:
+ # mismatch, insert a reshape to fix this.
+ reshape_name = op.name + "_reshape"
+ new_shape_tens = Tensor([1], DataType.int32, reshape_name + "_shape")
+ new_shape_tens.values = np.array(desired_shape)
+ new_shape_tens_const = Operation("Const", new_shape_tens.name + "_const")
+ new_shape_tens.ops = [new_shape_tens_const]
+ new_shape_tens_const.outputs = [new_shape_tens]
+
+ reshape_op = Operation("Reshape", reshape_name)
+ reshape_op.inputs = [inp, new_shape_tens]
+ reshape_op.attrs["new_shape"] = desired_shape
+ reshape_out = inp.clone("_reshaped")
+ reshape_out.shape = reshape_out.storage_shape = reshape_out.bandwidth_shape = desired_shape
+ reshape_out.ops = [reshape_op]
+ reshape_op.outputs = [reshape_out]
+
+ op.inputs[0] = reshape_out
+
+ return op
+
+
+def fixup_pack_input(op, arch):
+ if op.type == "Pack":
+ # Pack is also referred to as Stack
+ # Requires the rewrite_concat function to be called on the op afterwards
+ axis = int(op.attrs["axis"])
+ desired_shape = op.inputs[0].shape[:axis] + [1] + op.inputs[0].shape[axis:]
+
+ # Construct 1 shape tensor to be used by all inserted reshape ops
+ new_shape_name = op.name + "_reshape_shape"
+ new_shape_tens = Tensor([1], DataType.int32, new_shape_name)
+ new_shape_tens.values = np.array(desired_shape)
+ new_shape_tens_const = Operation("Const", new_shape_tens.name + "_const")
+ new_shape_tens.ops = [new_shape_tens_const]
+ new_shape_tens_const.outputs = [new_shape_tens]
+
+ for idx, inp in enumerate(op.inputs):
+ reshape_name = op.name + str(idx) + "_reshape"
+ reshape_op = Operation("Reshape", reshape_name)
+ reshape_op.inputs = [inp, new_shape_tens]
+ reshape_op.attrs["new_shape"] = desired_shape
+ reshape_out = inp.clone("_reshaped")
+ reshape_out.shape = reshape_out.storage_shape = reshape_out.bandwidth_shape = desired_shape
+ reshape_out.ops = [reshape_op]
+ reshape_op.outputs = [reshape_out]
+
+ op.inputs[idx] = reshape_out
+
+ op.type = "PackReshaped"
+
+ return op
+
+
+def fixup_unpack_output(tens, arch):
+ op = tens.ops[0]
+ if op.type in set(("Unpack", "StridedSlice")):
+ # Unpack is also referred to as Unstack
+ # Requires the rewrite_split function to be called on the op afterwards
+ if op.type == "StridedSlice":
+ shrink_axis_mask = op.attrs["shrink_axis_mask"]
+ if shrink_axis_mask == 0:
+ # Equal Rank StridedSlice, no need to insert reshape
+ return tens
+
+ # Only allow shrinking 1 axis for now
+ assert shrink_axis_mask & (shrink_axis_mask - 1) == 0
+ assert len(tens.shape) == (len(op.inputs[0].shape) - 1)
+
+ axis = int(math.log2(shrink_axis_mask))
+ op.attrs["shrink_axis_mask"] = 0
+ else:
+ axis = int(op.attrs["axis"])
+ op.type = "UnpackReshaped"
+
+ desired_shape = tens.shape[:axis] + [1] + tens.shape[axis:]
+
+ # Construct 1 shape tensor to be used by all inserted reshape ops
+ new_shape_name = op.name + "_reshape_shape"
+ new_shape_tens = Tensor([1], DataType.int32, new_shape_name)
+ new_shape_tens.values = np.array(tens.shape)
+ new_shape_tens_const = Operation("Const", new_shape_tens.name + "_const")
+ new_shape_tens.ops = [new_shape_tens_const]
+ new_shape_tens_const.outputs = [new_shape_tens]
+
+ for idx, out_tens in enumerate(op.outputs):
+ reshape_name = op.name + str(idx) + "_reshape"
+ reshape_op = Operation("Reshape", reshape_name)
+ reshape_op.outputs = [out_tens]
+ reshape_in = out_tens.clone("_reshaped")
+ reshape_in.shape = reshape_in.storage_shape = reshape_in.bandwidth_shape = desired_shape
+ reshape_in.ops = [op]
+ out_tens.ops = [reshape_op]
+ reshape_op.inputs = [reshape_in, new_shape_tens]
+
+ op.outputs[idx] = reshape_in
+
+ return tens
+
+
+def add_padding_fields(op, arch):
+ if "padding" in op.attrs:
+ if "Conv" in op.type:
+ kernel_size = op.inputs[1].shape[:2]
+ input_shape = op.inputs[0].shape
+ elif "Pool" in op.type:
+ kernel_size = op.attrs["ksize"][1:3]
+ input_shape = op.inputs[0].shape
+ elif op.type == "ExtractImagePatches":
+ kernel_size = op.attrs["ksizes"][1:3]
+ input_shape = op.inputs[0].shape
+ else:
+ assert 0, "Unknown operation that uses padding"
+
+ padding, skirt = calc_padding_and_skirt(op.attrs["padding"], kernel_size, op.attrs["strides"], input_shape)
+ op.attrs["explicit_padding"] = padding
+ op.attrs["skirt"] = skirt
+ return op
+
+
+conv_op = set(("Conv2D", "QuantizedConv2D", "Conv2DBackpropInputSwitched", "Conv2DBiasAct"))
+fc_op = set(
+ (
+ "MatMul",
+ "QuantizedMatMul",
+ "BlockLSTM",
+ "RnnAct",
+ "UnidirectionalSequenceRnnAct",
+ "BidirectionalSequenceRnnAct",
+ "LstmAct",
+ "UnidirectionalSequenceLstmAct",
+ "BidirectionalSequenceLstmAct",
+ "FullyConnectedAct",
+ )
+)
+depthwise_op = set(("DepthwiseConv2dNative", "DepthwiseConv2dBiasAct",))
+pool_op = set(("AvgPool", "MaxPool", "QuantizedAvgPool", "QuantizedMaxPool", "AvgPoolAct", "MaxPoolAct"))
+elementwise_op = set(("AddAct", "MulAct", "SubAct", "Maximum", "Minimum", "LeakyRelu", "Abs"))
+activation_ops = set(("Relu", "Relu6", "ReluN1To1", "Sigmoid", "Tanh"))
+memory_only_ops = set(("Reshape",))
+
+# Check if the op can be reordered
+def get_prepend_op(op):
+ inp = op.inputs[0]
+ # The op should be reordered between prev_op and prep_op
+ prev_op = inp.ops[-1]
+ prep_op = None
+ while prev_op.type in memory_only_ops and len(prev_op.outputs) == 1 and len(prev_op.outputs[0].consumers()) == 1:
+ prep_op = prev_op
+ inp = prev_op.inputs[0]
+ prev_op = inp.ops[-1]
+ if prev_op != None and len(prev_op.outputs) == 1 and len(prev_op.outputs[0].consumers()) == 1:
+ return prep_op
+
+ return None
+
+
+def mark_npu_block_type(op, arch):
+ npu_block_type = NpuBlockType.Default
+ if op.type in conv_op:
+ npu_block_type = NpuBlockType.ConvolutionMxN
+ elif op.type in fc_op:
+ npu_block_type = NpuBlockType.VectorProduct
+ elif op.type in depthwise_op:
+ npu_block_type = NpuBlockType.ConvolutionDepthWise
+ elif op.type in pool_op:
+ npu_block_type = NpuBlockType.Pooling
+ elif op.type in elementwise_op:
+ npu_block_type = NpuBlockType.ElementWise
+
+ op.attrs["npu_block_type"] = npu_block_type
+ return op
+
+
+def convert_depthwise_to_conv(op, arch):
+ # Depthwise is equivalent to a single conv2d if the ifm depth is 1 and
+ # the ofm depth equals the depth multipler.
+ # If those conditions are true, then we can perform a simple
+ # switch of the operator type (and weight order)
+
+ if ("DepthwiseConv2d" in op.type) and (op.attrs["depth_multiplier"] != 1):
+ ifm_tensor = op.inputs[0]
+ weight_tensor = op.inputs[1]
+ ofm_tensor = op.outputs[0]
+ if (ifm_tensor.shape[3] == 1) and (ofm_tensor.shape[3] == op.attrs["depth_multiplier"]):
+ # Change op type to Conv2d
+ op.type = op.type.replace("DepthwiseConv2d", "Conv2D")
+ del op.attrs["channel_multiplier"]
+ del op.attrs["depth_multiplier"]
+
+ weight_tensor.quant_values = np.transpose(weight_tensor.quant_values, (0, 1, 3, 2))
+ weight_tensor.shape = weight_tensor.storage_shape = weight_tensor.bandwidth_shape = list(
+ weight_tensor.quant_values.shape
+ )
+ else:
+ print(
+ "Error: Unsupported DepthwiseConv2d with depth_multiplier = {0}, "
+ "ifm channels = {1}, ofm channels = {2}".format(
+ op.attrs["depth_multiplier"], ifm_tensor.shape[3], ofm_tensor.shape[3]
+ )
+ )
+ assert False
+ return op
+
+
+# Reorder activation op if it's after the memory only operations
+def fixup_act_reorder(op, arch):
+ if op.type in activation_ops:
+ prep_op = get_prepend_op(op)
+ if prep_op != None:
+ act_op = op.clone("_reordered")
+ act_op.inputs = [prep_op.inputs[0]]
+ act_op_out = act_op.inputs[0].clone("_acted")
+ act_op_out.quantization = op.outputs[0].quantization.clone()
+ act_op_out.ops = [act_op]
+ act_op.outputs = [act_op_out]
+ prep_op.inputs[0] = act_op_out
+ prep_op.outputs[0].quantization = act_op_out.quantization.clone()
+
+ # Mark the op so that it will be removed as passthrough later on
+ op.type = "Identity"
+ return op
+
+
+def convert_mul_max_to_abs_or_lrelu(op, arch):
+ """Whenever there is a subgraph with this topology:
+
+ Input X For X = -1 or X > 0
+ | \ / This subgraph can be replaced with either
+ | Mul an Abs (if X = -1) or a LeakyReLU (if X > 0)
+ | /
+ Max
+ """
+
+ if op.type == "Maximum":
+ # finds the Mul input(s) to the Max
+ muls = [i for i in op.inputs if i.ops[0].type == "MulAct"]
+ if len(muls) == 1:
+ mul = muls[0].ops[0]
+ elif len(muls) == 2:
+ # In the case both inputs are Muls, find the one with the same input as the Max
+ mul = [m for m in muls if len(set(op.inputs + m.ops[0].inputs)) == 1][0].ops[0]
+ else:
+ # No Mul inputs
+ return op
+
+ # make sure the Mul doesn't have any other consumers
+ if len(mul.outputs[0].consumers()) != 1:
+ return op
+ # make sure the Mul doesn't have a faf
+ if mul.attrs["fused_activation_function"]:
+ return op
+
+ # finds the branched input that goes to both the Max and the Mul
+ shared = set(op.inputs) & set(mul.inputs)
+ if len(shared) == 1:
+ shared_in = shared.pop()
+ # find the constant scalar input to the Mul
+ const_tens = (set(mul.inputs) - {shared_in}).pop()
+ # check that it is a scalar
+ if const_tens.shape != []:
+ return op
+ const = const_tens.ops[0]
+ # check that it is a constant
+ if const.type != "Const":
+ return op
+ else:
+ return op
+
+ val = const.outputs[0].values
+ if val >= 0:
+ new_op = "LeakyRelu"
+ op.attrs["alpha"] = val
+ elif val == -1:
+ new_op = "Abs"
+ else:
+ return op
+
+ op.type = op.type.replace("Maximum", new_op)
+ op.name = op.name.replace("Maximum", new_op)
+ op.outputs[0].name = op.outputs[0].name.replace("Maximum", new_op)
+ op.inputs = [shared_in]
+ return op
+
+
+def supported_operator_check(op, arch):
+ op.run_on_npu = arch.supported_operators.is_operator_supported(op)
+ return op
+
+
+def optimise_graph_a(nng, arch, verbose_graph=False):
+ if verbose_graph:
+ nng.print_graph()
+
+ op_rewrite_list = [
+ # mark block type and check if the operations are supported
+ mark_npu_block_type,
+ supported_operator_check,
+ # then do any rewrites of supported operators
+ convert_depthwise_to_conv,
+ fixup_fully_connected_input,
+ fixup_pack_input,
+ fixup_conv2d_backprop,
+ fixup_act_reorder,
+ add_padding_fields,
+ mark_npu_block_type,
+ # convert_mul_max_to_abs_or_lrelu # TODO: enable optimisation once quantisation issues are resolved
+ ]
+
+ for idx, sg in enumerate(nng.subgraphs):
+ # rewrite graph pass
+ nng.subgraphs[idx] = rewrite_graph.rewrite_graph_pre_order(
+ sg, arch, [fixup_unpack_output,], op_rewrite_list, rewrite_unsupported=False
+ )
+
+ for idx, sg in enumerate(nng.subgraphs):
+ # remove passthrough tensors
+ nng.subgraphs[idx] = rewrite_graph.rewrite_graph_pre_order(sg, arch, [remove_passthrough_tensor,], [])
+
+ if verbose_graph:
+ nng.print_graph()
+ return nng
+
+def optimise_graph_b(nng, arch, verbose_graph=False):
+ if verbose_graph:
+ nng.print_graph()
+
+ for idx, sg in enumerate(nng.subgraphs):
+ # combined rewrite graph pass
+ nng.subgraphs[idx] = rewrite_graph.rewrite_graph_pre_order(sg, arch, [rewrite_concat, rewrite_split,], [])
+
+ if verbose_graph:
+ nng.print_graph()
+ return nng
diff --git a/ethosu/vela/greedy_allocation.py b/ethosu/vela/greedy_allocation.py
new file mode 100644
index 0000000..6b3d2c1
--- /dev/null
+++ b/ethosu/vela/greedy_allocation.py
@@ -0,0 +1,95 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Allocate tensor addresses using a greedy algorithm.
+
+from . import numeric_util
+
+
+class GreedyAllocator:
+ def __init__(self, nng, arch, live_ranges, mem_area):
+ self.nng = nng
+ self.arch = arch
+ self.mem_area = mem_area
+
+ self.live_ranges = live_ranges
+ self.memory_required = 0
+
+ self.current_allocs = []
+
+ def alloc(self, new_lr):
+ size = new_lr.size
+ current_top = 0
+ if self.current_allocs:
+ current_top = max(start_addr + lr.size for start_addr, lr in self.current_allocs)
+ best_offset = numeric_util.round_up(current_top, new_lr.get_alignment())
+ best_offset_fit = (1 << 64) - 1
+
+ current_offset = 0
+ for start_addr, lr in self.current_allocs:
+ aligned_current_offset = numeric_util.round_up(current_offset, new_lr.get_alignment())
+ if aligned_current_offset + size <= start_addr and start_addr - current_offset < best_offset_fit:
+ best_offset = current_offset
+ best_offset_fit = start_addr - current_offset
+
+ current_offset = start_addr + lr.size
+
+ self.memory_required = max(self.memory_required, best_offset + size)
+ new_lr.set_address(best_offset)
+ self.current_allocs.append((best_offset, new_lr))
+ self.current_allocs = list(sorted(self.current_allocs))
+
+ def dealloc(self, lr_to_dealloc):
+ self.current_allocs = [(start_addr, lr) for start_addr, lr in self.current_allocs if lr != lr_to_dealloc]
+
+ def allocate_live_ranges(self, verbose_allocation):
+ lrs = set()
+ for lr in self.live_ranges.ranges.values():
+ lrs.add((lr.start_time, lr.end_time, lr))
+
+ lrs = sorted(lrs)
+
+ for curr_time, _, new_lr in lrs:
+ for _, lr in list(self.current_allocs):
+ if lr.end_time < curr_time:
+ self.dealloc(lr)
+
+ self.alloc(new_lr)
+
+ assert self.verify_allocation()
+ return self.memory_required
+
+ def verify_allocation(self):
+ lrs = list(self.live_ranges.ranges.values())
+ for n in lrs:
+ for m in lrs:
+ if n != m and n.overlaps_ranges(m):
+ overlap, tens_n, tens_m = n.overlaps_address(m)
+ if overlap:
+ print("Solution failed, overlapping buffer!")
+ print(tens_n.address, tens_n.address + n.size, n.name)
+ print(tens_m.address, tens_m.address + m.size, m.name)
+ print()
+ return False
+
+ return True
+
+
+def allocate_live_ranges(nng, arch, live_ranges, mem_area, verbose_allocation=False):
+ g = GreedyAllocator(nng, arch, live_ranges, mem_area)
+ return g.allocate_live_ranges(verbose_allocation)
diff --git a/ethosu/vela/high_level_command_stream.py b/ethosu/vela/high_level_command_stream.py
new file mode 100644
index 0000000..952e203
--- /dev/null
+++ b/ethosu/vela/high_level_command_stream.py
@@ -0,0 +1,365 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Contains classes that hold commands for the high-level command stream (one command per DMA or NPU stripe).
+
+from enum import Enum, IntEnum
+import numpy as np
+from .operation import NpuBlockType
+from .numeric_util import round_up_divide
+from .range_set import MemoryAccessSet, AccessDirection
+
+
+class Box:
+ def __init__(self, start_coord, end_coord):
+ self.start_coord = list(start_coord)
+ self.end_coord = list(end_coord)
+ assert len(self.start_coord) == len(end_coord)
+ for i in range(len(self.start_coord)):
+ assert self.start_coord[i] <= self.end_coord[i]
+
+ def transform_with_strides_and_skirt(
+ self, strides, skirt, ifm_shape, npu_block_type, concat_axis=0, concat_offset=0, split_offset=None, k_height=1
+ ):
+ new_start_coord = list(self.start_coord)
+ new_end_coord = list(self.end_coord)
+
+ new_start_coord[concat_axis] -= concat_offset
+ new_end_coord[concat_axis] -= concat_offset
+
+ if split_offset != None:
+ for idx in range(len(split_offset)):
+ new_start_coord[idx] += split_offset[idx]
+ new_end_coord[idx] += split_offset[idx]
+
+ if split_offset == None and npu_block_type in set((NpuBlockType.ConvolutionMxN, NpuBlockType.VectorProduct)):
+ # these types of operations do a "dot product" over the entire IFM
+ new_start_coord[-1] = 0
+ new_end_coord[-1] = ifm_shape[-1]
+
+ if min(len(new_end_coord), len(ifm_shape)) >= 2:
+ new_end_coord[-2] = min(new_end_coord[-2], ifm_shape[-2])
+ if min(len(new_end_coord), len(ifm_shape)) >= 3:
+ new_end_coord[-3] = min(new_end_coord[-3], ifm_shape[-3])
+
+ pad_top = 0
+ pad_bottom = 0
+ if strides is not None and skirt is not None:
+ if len(new_start_coord) >= 2:
+ stride = strides[2]
+ new_start_coord[-2] = max(new_start_coord[-2] * stride - skirt[1], 0)
+ new_end_coord[-2] = min(new_end_coord[-2] * stride + skirt[3], ifm_shape[-2])
+
+ if len(new_start_coord) >= 3:
+ stride = strides[1]
+
+ total_stride = stride * (new_end_coord[-3] - new_start_coord[-3] - 1)
+ new_start_coord[-3] = new_start_coord[-3] * stride - skirt[0]
+
+ pad_top = max(0, 0 - new_start_coord[-3])
+ new_start_coord[-3] = max(new_start_coord[-3], 0)
+
+ while len(ifm_shape) < 3:
+ ifm_shape = [1] + ifm_shape
+ if (new_end_coord[-3] * stride + skirt[2]) > ifm_shape[-3]:
+ # pad_bottom is calculated based the diff between the end position of the weight kernel,
+ # after last stride and the ifm height.
+ k_start = new_start_coord[-3] - pad_top
+ pad_bottom = max(0, k_start + total_stride + k_height - ifm_shape[-3])
+
+ new_end_coord[-3] = min(new_end_coord[-3] * stride + skirt[2], ifm_shape[-3])
+
+ return Box(new_start_coord, new_end_coord), pad_top, pad_bottom
+
+ def make_weight_box(weight_shape, npu_block_type, oc_range_start=None, oc_range_end=None, weights_transposed=False):
+ start = [0] * len(weight_shape)
+ end = list(weight_shape)
+ if oc_range_start is not None and oc_range_end is not None:
+ if npu_block_type == NpuBlockType.ConvolutionDepthWise:
+ # input range is output range divided by channel multiplier
+ if weights_transposed:
+ start[-1] = oc_range_start // weight_shape[-2]
+ end[-1] = oc_range_end // weight_shape[-2]
+ else:
+ start[-2] = oc_range_start // weight_shape[-1]
+ end[-2] = oc_range_end // weight_shape[-1]
+ else:
+ start[-1] = oc_range_start
+ end[-1] = oc_range_end
+ for i in range(len(end)):
+ assert 0 <= start[i] < weight_shape[i]
+ assert 0 < end[i] <= weight_shape[i]
+
+ return Box(start, end)
+
+ def get_size_shape(self):
+ return [int(self.end_coord[i] - self.start_coord[i]) for i in range(len(self.end_coord))]
+
+ def get_size(self):
+ return int(np.prod(self.get_size_shape()))
+
+ def __str__(self):
+ return "<Box %s - %s>" % (self.start_coord, self.end_coord)
+
+ __repr__ = __str__
+
+
+class CommandType(IntEnum):
+ NpuStripe = 0
+ DMA = 1
+ Size = 2
+
+
+class Command:
+ def get_ofm_y_range_for_pass(self, ps_requested):
+ return None
+
+ def is_npu_pass_command(self):
+ return False
+
+ def get_memory_accesses(self):
+ return None
+
+ def get_operation_count(self):
+ # returns numpy array of (DPU blocks, dma_ops). Should line up with the CommandType enum
+ return np.array((0, 0))
+
+
+class NpuStripe(Command):
+ def __init__(
+ self,
+ ps,
+ block_config,
+ is_first,
+ is_last,
+ is_first_h_stripe,
+ is_last_h_stripe,
+ ifm_tensor,
+ ifm_box,
+ ofm_tensor,
+ ofm_box,
+ weight_tensor=None,
+ weight_box=None,
+ scale_tensor=None,
+ concat_axis=0,
+ concat_offset=0,
+ ifm2_tensor=None,
+ ifm2_box=None,
+ pad_top=0,
+ pad_bottom=0,
+ ):
+ self.cmdtype = CommandType.NpuStripe
+ self.ps = ps
+ self.block_config = block_config
+ self.is_first = is_first
+ self.is_last = is_last
+ self.is_first_h_stripe = is_first_h_stripe
+ self.is_last_h_stripe = is_last_h_stripe
+ self.ifm_tensor = ifm_tensor
+ self.ifm_box = ifm_box
+ self.ifm2_tensor = ifm2_tensor
+ self.ifm2_box = ifm2_box
+ self.ofm_tensor = ofm_tensor
+ self.ofm_box = ofm_box
+ self.weight_tensor = weight_tensor
+ self.scale_tensor = scale_tensor
+ self.weight_box = weight_box
+ self.concat_axis = concat_axis
+ self.concat_offset = concat_offset
+ self.pad_top = pad_top
+ self.pad_bottom = pad_bottom
+ for i in range(len(self.ofm_box.end_coord)):
+ assert self.ofm_box.end_coord[i] <= self.ofm_tensor.shape[i]
+
+ def get_memory_accesses(self):
+ res = MemoryAccessSet()
+ if self.ifm_tensor is not None and self.ifm_tensor.shape != []:
+ res.add(
+ self.ifm_tensor.get_address_ranges_for_coordinates(self.ifm_box.start_coord, self.ifm_box.end_coord),
+ AccessDirection.Read,
+ )
+ if self.ifm2_tensor is not None and self.ifm2_tensor.shape != []:
+ res.add(
+ self.ifm2_tensor.get_address_ranges_for_coordinates(self.ifm2_box.start_coord, self.ifm2_box.end_coord),
+ AccessDirection.Read,
+ )
+ if self.ofm_tensor is not None:
+ res.add(
+ self.ofm_tensor.get_address_ranges_for_coordinates(self.ofm_box.start_coord, self.ofm_box.end_coord),
+ AccessDirection.Write,
+ )
+ if self.weight_tensor is not None:
+ res.add(
+ self.weight_tensor.get_address_ranges_for_coordinates(
+ self.weight_box.start_coord, self.weight_box.end_coord
+ ),
+ AccessDirection.Read,
+ )
+ return res
+
+ def is_npu_pass_command(self):
+ return True
+
+ def __str__(self):
+ return "<NPUStripe: ps=%s, ifm_box=%s, ifm2_box=%s, ofm_box=%s, weight_box=%s, block_config=%s>" % (
+ self.ps.name,
+ self.ifm_box,
+ self.ifm2_box,
+ self.ofm_box,
+ self.weight_box,
+ self.block_config,
+ )
+
+ __repr__ = __str__
+
+ def get_ofm_y_range_for_pass(self, ps_requested):
+ if ps_requested != self.ps:
+ return None
+ if len(self.ofm_box.start_coord) >= 3:
+ return (self.ofm_box.start_coord[-3], self.ofm_box.end_coord[-3])
+ return None
+
+ def get_block_dimensions(self):
+ ofm_box = self.ofm_box
+ block_config = self.block_config
+
+ out_height = 1
+ out_width = 1
+ out_depth = ofm_box.end_coord[-1] - ofm_box.start_coord[-1]
+ if len(ofm_box.end_coord) >= 4:
+ out_width = ofm_box.end_coord[-2] - ofm_box.start_coord[-2]
+ out_height = ofm_box.end_coord[-3] - ofm_box.start_coord[-3]
+
+ assert out_height >= 0
+ assert out_width >= 0
+ assert out_depth >= 0
+ return (
+ round_up_divide(out_height, block_config[0]),
+ round_up_divide(out_width, block_config[1]),
+ round_up_divide(out_depth, block_config[3]),
+ )
+
+ def get_operation_count(self):
+ # returns numpy array of (DPU blocks, dma_ops)
+ return np.array((self.get_n_blocks(), 0))
+
+ def get_n_blocks(self):
+ h, w, d = self.get_block_dimensions()
+ res = h * w * d
+ assert res >= 0
+ return res
+
+ def get_single_block_command(self, block_idx):
+ block_cfg = (self.block_config[0], self.block_config[1], self.block_config[3])
+ dims = self.get_block_dimensions()
+ strides = dims[1] * dims[2], dims[2], 1
+ coord = []
+ idx_left = block_idx
+ for s in strides:
+ c = idx_left // s
+ idx_left -= c * s
+ coord.append(c)
+
+ assert idx_left == 0
+
+ # put in dummy height/widths in case we're dealing with FC layers
+ ofm_start = list(self.ofm_box.start_coord)
+ ofm_end = list(self.ofm_box.end_coord)
+
+ # cut out a nice block shape
+ for idx in (-1, -2, -3):
+ if len(ofm_start) >= -idx:
+ ofm_start[idx] += block_cfg[idx] * coord[idx]
+ ofm_end[idx] = min(ofm_end[idx], ofm_start[idx] + block_cfg[idx])
+
+ ps = self.ps
+ strides = None
+ skirt = None
+ if ps.primary_op is not None:
+ strides = ps.primary_op.attrs.get("strides", None)
+ skirt = ps.primary_op.attrs.get("skirt", None)
+ npu_block_type = ps.npu_block_type
+
+ ofm_box = Box(ofm_start, ofm_end)
+ ifm_box, _, _ = ofm_box.transform_with_strides_and_skirt(
+ strides, skirt, self.ifm_tensor.shape, npu_block_type, self.concat_axis, self.concat_offset
+ )
+
+ weight_box = None
+ if self.weight_tensor is not None:
+ weight_oc_start = ofm_start[-1]
+ weight_oc_end = ofm_end[-1]
+ if self.concat_axis - len(self.weight_tensor.shape) == -1:
+ weight_oc_start -= self.concat_offset
+ weight_oc_end -= self.concat_offset
+
+ weight_box = Box.make_weight_box(
+ self.weight_tensor.shape,
+ npu_block_type,
+ weight_oc_start,
+ weight_oc_end,
+ self.weight_tensor.weight_transpose_depthwise,
+ )
+
+ return NpuStripe(
+ self.ps,
+ self.block_config,
+ self.is_first,
+ self.is_last,
+ self.is_first_h_stripe,
+ self.is_last_h_stripe,
+ self.ifm_tensor,
+ ifm_box,
+ self.ofm_tensor,
+ ofm_box,
+ self.weight_tensor,
+ weight_box,
+ self.scale_tensor,
+ self.concat_axis,
+ self.concat_offset,
+ )
+
+
+class DMA(Command):
+ def __init__(self, in_tensor, out_tensor, box):
+ self.cmdtype = CommandType.DMA
+ self.in_tensor = in_tensor
+ self.out_tensor = out_tensor
+ self.box = box
+
+ def __str__(self):
+ return "<DMA: in=%s, out=%s, box=%s>" % (self.in_tensor.name, self.out_tensor.name, self.box)
+
+ __repr__ = __str__
+
+ def get_memory_accesses(self):
+ res = MemoryAccessSet()
+
+ res.add(
+ self.in_tensor.get_address_ranges_for_coordinates(self.box.start_coord, self.box.end_coord),
+ AccessDirection.Read,
+ )
+ res.add(
+ self.out_tensor.get_address_ranges_for_coordinates(self.box.start_coord, self.box.end_coord),
+ AccessDirection.Write,
+ )
+ return res
+
+ def get_operation_count(self):
+ # returns numpy array of (DPU blocks, dma_ops)
+ return np.array((0, 1))
diff --git a/ethosu/vela/high_level_command_stream_generator.py b/ethosu/vela/high_level_command_stream_generator.py
new file mode 100644
index 0000000..364df6f
--- /dev/null
+++ b/ethosu/vela/high_level_command_stream_generator.py
@@ -0,0 +1,315 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Generate a high-level command stream from a scheduled subgraph with CascadedPasses.
+#
+# Also used during scheduling to work out allowable IFM/OFM overlap, this functionality can be accessed using
+# calc_allowed_ofm_ifm_overlap_for_cascaded_pass().
+
+from .nn_graph import SchedulingStrategy, PassPlacement
+import numpy as np
+from .operation import NpuBlockType
+from .high_level_command_stream import Box, CommandType, Command, NpuStripe, DMA
+
+
+def need_dma(tens):
+ return len(tens.ops) == 1 and tens.ops[0].type == "DMA"
+
+
+def dma_weights_if_necessary(ps, box, weight_tensor):
+ if need_dma(weight_tensor):
+ dma_op = weight_tensor.ops[0]
+ in_tensor = dma_op.inputs[0]
+ yield DMA(in_tensor, weight_tensor, box)
+
+
+def generate_high_level_command_stream_for_pass(strat, passes, block_configs, idx):
+ is_first = idx == 0
+ is_last = idx == len(passes) - 1
+ ps = passes[idx]
+ block_config = block_configs[idx]
+
+ ifm_tensor = ps.ifm_tensor
+ ifm2_tensor = ps.ifm2_tensor
+ ofm_tensor = ps.ofm_tensor
+ weight_tensor = ps.weight_tensor
+ scale_tensor = ps.scale_tensor
+
+ ofm_start = [0] * len(ofm_tensor.shape)
+ ofm_end = list(ofm_tensor.shape)
+
+ strides = None
+ skirt = None
+ if ps.primary_op is not None:
+ strides = ps.primary_op.attrs.get("strides", None)
+ skirt = ps.primary_op.attrs.get("skirt", None)
+
+ npu_block_type = ps.npu_block_type
+
+ concat_axis = 0
+ concat_offset = 0
+
+ split_offsets = [None, None] # offset for [ifm, ifm2]
+
+ # Fusable activation functions
+ activation_ops = set(("Sigmoid", "Tanh", "Relu", "Relu6", "ReluN1To1"))
+
+ for op in ps.ops:
+ if op.type == "ConcatSliceWrite":
+ concat_axis = op.attrs["concat_axis"]
+ concat_start = op.attrs["concat_start"]
+ concat_end = op.attrs["concat_end"]
+
+ ofm_start[concat_axis] = concat_start
+ ofm_end[concat_axis] = concat_end
+ concat_offset = concat_start
+ ps.primary_op.attrs["fused_memory_function"] = op.type
+ elif op.type in activation_ops:
+ ps.primary_op.attrs["fused_activation_function"] = op.type
+
+ # The ops list has to be reversed here since the Pass Packing is done in reverse
+ ifm_idx = 0
+ for op in reversed(ps.ops):
+ if op.type == "SplitSliceRead":
+ split_offsets[ifm_idx] = op.attrs["split_start"]
+ ps.primary_op.attrs["fused_memory_function"] = op.type
+ ifm_idx += 1
+
+ if strat == SchedulingStrategy.WeightStream:
+ ofm_step = block_config[-1]
+ ofm_stop = ofm_end[-1]
+ if weight_tensor is None or not need_dma(weight_tensor):
+ ofm_step = ofm_stop
+ for start in range(ofm_start[-1], ofm_stop, ofm_step):
+ end = min(start + ofm_step, ofm_stop)
+ ofm_start[-1] = start
+ ofm_end[-1] = end
+ ofm_box = Box(ofm_start, ofm_end)
+ ifm_box = None
+ ifm2_box = None
+
+ if ifm_tensor.shape != []:
+ ifm_box, _, _ = ofm_box.transform_with_strides_and_skirt(
+ strides, skirt, ifm_tensor.shape, npu_block_type, concat_axis, concat_offset, split_offsets[0]
+ )
+ else:
+ ifm_box = Box([], [])
+ if ifm2_tensor is not None and ifm2_tensor.shape != []:
+ ifm2_box, _, _ = ofm_box.transform_with_strides_and_skirt(
+ strides, skirt, ifm2_tensor.shape, npu_block_type, concat_axis, concat_offset, split_offsets[1]
+ )
+ else:
+ ifm2_box = Box([], [])
+
+ weight_box = None
+ if weight_tensor is not None:
+ weight_oc_start = start
+ weight_oc_end = end
+ if concat_axis - len(weight_tensor.shape) == -1:
+ weight_oc_start -= concat_offset
+ weight_oc_end -= concat_offset
+
+ weight_box = Box.make_weight_box(
+ weight_tensor.shape,
+ npu_block_type,
+ weight_oc_start,
+ weight_oc_end,
+ weight_tensor.weight_transpose_depthwise,
+ )
+ yield from dma_weights_if_necessary(ps, weight_box, weight_tensor)
+
+ yield NpuStripe(
+ ps,
+ block_config,
+ is_first,
+ is_last,
+ True,
+ True,
+ ifm_tensor,
+ ifm_box,
+ ofm_tensor,
+ ofm_box,
+ weight_tensor,
+ weight_box,
+ scale_tensor,
+ concat_axis,
+ concat_offset,
+ ifm2_tensor=ifm2_tensor,
+ ifm2_box=ifm2_box,
+ )
+
+ elif strat == SchedulingStrategy.IfmStream:
+ y_step = block_config[0]
+ y_start = 0
+ y_dim = 1
+ if len(ofm_tensor.shape) >= 3:
+ y_start = ofm_start[-3]
+ y_dim = ofm_end[-3]
+ if idx > 0:
+ ifm_y_present = 0
+ prev_pass = passes[idx - 1]
+ prev_pass_gen = generate_high_level_command_stream_for_pass(strat, passes, block_configs, idx - 1)
+ else:
+ ifm_y_present = 1
+ if len(ifm_tensor.shape) >= 3:
+ ifm_y_present = ifm_tensor.shape[-3]
+ prev_pass_gen = []
+ prev_pass = None
+
+ if len(passes) == 1:
+ # no cascading, can just issue one big stripe
+ # but only if we've done allocation and OFM does not overlap IFM
+ if ifm_tensor.address != -1 and ofm_tensor.address != -1:
+ if (
+ ifm_tensor.address + ifm_tensor.storage_size() <= ofm_tensor.address
+ or ofm_tensor.address + ofm_tensor.storage_size() <= ifm_tensor.address
+ ):
+ y_step = y_dim
+
+ weight_box = None
+
+ for start in range(y_start, y_dim, y_step):
+ end = min(start + y_step, y_dim)
+ if len(ofm_tensor.shape) >= 3:
+ ofm_start[-3] = start
+ ofm_end[-3] = end
+ ofm_box = Box(ofm_start, ofm_end)
+
+ k_height = 1
+ if npu_block_type == NpuBlockType.Pooling:
+ if ps.primary_op is not None:
+ k_height = ps.primary_op.attrs["ksize"][1]
+ else:
+ if weight_tensor is not None:
+ k_height = weight_tensor.shape[0]
+
+ ifm_box, pad_top, pad_bottom = ofm_box.transform_with_strides_and_skirt(
+ strides, skirt, ifm_tensor.shape, npu_block_type, concat_axis, concat_offset, split_offsets[0], k_height
+ )
+
+ ifm_y_needed = 1
+ if len(ifm_box.end_coord) >= 3:
+ ifm_y_needed = ifm_box.end_coord[-3]
+ if ifm_y_present < ifm_y_needed:
+ for prev_cmd in prev_pass_gen:
+ yield prev_cmd
+ rng = prev_cmd.get_ofm_y_range_for_pass(prev_pass)
+ if rng is not None:
+ ifm_y_present = max(ifm_y_present, rng[1])
+ if ifm_y_present >= ifm_y_needed:
+ break
+
+ if weight_tensor is not None and weight_box is None:
+ weight_box = Box.make_weight_box(
+ weight_tensor.shape, npu_block_type, weights_transposed=weight_tensor.weight_transpose_depthwise
+ )
+ yield from dma_weights_if_necessary(ps, weight_box, weight_tensor)
+
+ # Check if first/last stripe in pass
+ is_first_h_stripe = start == y_start
+ is_last_h_stripe = (start + y_step) >= y_dim
+
+ stripe = NpuStripe(
+ ps,
+ block_config,
+ is_first,
+ is_last,
+ is_first_h_stripe,
+ is_last_h_stripe,
+ ifm_tensor,
+ ifm_box,
+ ofm_tensor,
+ ofm_box,
+ weight_tensor,
+ weight_box,
+ scale_tensor,
+ concat_axis,
+ concat_offset,
+ None,
+ None,
+ pad_top,
+ pad_bottom,
+ )
+ yield stripe
+ else:
+ assert 0, "unknown scheduling strategy"
+
+
+def generate_high_level_command_stream_for_pass_list(strat, passes, block_configs):
+ if strat == SchedulingStrategy.WeightStream:
+ for idx in range(len(passes)):
+ yield from generate_high_level_command_stream_for_pass(strat, passes, block_configs, idx)
+ elif strat == SchedulingStrategy.IfmStream:
+ yield from generate_high_level_command_stream_for_pass(strat, passes, block_configs, len(passes) - 1)
+ else:
+ assert 0, "Unknown streaming strategy"
+
+
+def generate_high_level_command_stream_for_cascaded_pass(cps):
+ yield from generate_high_level_command_stream_for_pass_list(
+ cps.strategy, cps.passes, [ps.block_config for ps in cps.passes]
+ )
+
+
+def generate_high_level_command_stream(nng, sg, arch, verbose_high_level_command_stream):
+ res = []
+ for cps in sg.cascaded_passes:
+ if cps.placement == PassPlacement.Npu:
+ res += list(generate_high_level_command_stream_for_cascaded_pass(cps))
+
+ sg.high_level_command_stream = res
+ if verbose_high_level_command_stream:
+ sg.print_high_level_command_stream()
+
+
+def calc_allowed_ofm_ifm_overlap_for_pass_list(strat, passes, block_configs):
+ highest_ofm_write = 0
+ if not passes[0].ifm_tensor or not passes[-1].ofm_tensor:
+ return 0
+
+ ifm_read = passes[0].ifm_tensor.storage_size
+ min_overlap = 999999999999999999999
+ ofm_size = passes[-1].ofm_tensor.storage_size()
+ if strat == SchedulingStrategy.WeightStream:
+ return 0
+ for cmd in generate_high_level_command_stream_for_pass_list(strat, passes, block_configs):
+ if cmd.is_npu_pass_command():
+ if cmd.is_first:
+ ifm_read = cmd.ifm_tensor.address_offset_for_coordinate(cmd.ifm_box.start_coord, is_top_box=False)
+ if ifm_read is None:
+ return 0
+ if cmd.is_last:
+ write_offset = cmd.ofm_tensor.address_offset_for_coordinate(cmd.ofm_box.end_coord, is_top_box=True)
+ if write_offset is None:
+ return 0
+ highest_ofm_write = max(write_offset, highest_ofm_write)
+
+ if cmd.is_first or cmd.is_last:
+ overlap_required = max(highest_ofm_write - min(ifm_read, ofm_size), 0)
+ can_overwrite = ofm_size - overlap_required
+ min_overlap = min(min_overlap, can_overwrite)
+
+ if cmd.is_first:
+ ifm_read = cmd.ifm_tensor.address_offset_for_coordinate(cmd.ifm_box.end_coord, is_top_box=True)
+
+ min_overlap = max(min_overlap, 0)
+ return min_overlap
+
+
+def calc_allowed_ofm_ifm_overlap_for_cascaded_pass(cps):
+ return calc_allowed_ofm_ifm_overlap_for_pass_list(cps.strategy, cps.passes, [ps.block_config for ps in cps.passes])
diff --git a/ethosu/vela/insert_dma.py b/ethosu/vela/insert_dma.py
new file mode 100644
index 0000000..b63c1ea
--- /dev/null
+++ b/ethosu/vela/insert_dma.py
@@ -0,0 +1,60 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Insert DMA operations into the graph for transfering weights.
+
+from .nn_graph import Operation, MemArea, TensorPurpose, NpuBlockType
+from . import rewrite_graph
+
+
+def insert_dma_cmd(op, arch):
+ if op.type == "DMA":
+ return op # Already rewritten
+ for idx, tens in enumerate(op.inputs):
+
+ if tens.mem_area in (MemArea.Dram, MemArea.OffChipFlash) and tens.mem_area != arch.fast_storage_mem_area:
+ if tens.purpose == TensorPurpose.Weights:
+ only_vector_product_consumers = True
+ for oper in tens.consumers():
+ if oper is None or oper.attrs.get("npu_block_type") != NpuBlockType.VectorProduct:
+ only_vector_product_consumers = False
+ break
+
+ # Tensor products has no need for DMA, tensors are only read once and can be in flash.
+ # Other operations re-reads tensors, this is better done from SRAM.
+ if not only_vector_product_consumers:
+ # Insert a DMA command here, as well as a new tensor situated in SRAM of the same size.
+ new_tens = tens.clone_into_fast_storage(arch)
+ dma_cmd = Operation("DMA", tens.ops[0].name + "_dma")
+ dma_cmd.inputs = [tens]
+ dma_cmd.outputs = [new_tens]
+ dma_cmd.attrs["source"] = tens.mem_area
+ dma_cmd.attrs["destination"] = new_tens.mem_area
+ dma_cmd.run_on_npu = True
+ new_tens.ops = [dma_cmd]
+ op.inputs[idx] = new_tens
+ return op
+
+
+def insert_dma_commands(nng, arch, verbose_graph=False):
+
+ for idx, sg in enumerate(nng.subgraphs):
+ nng.subgraphs[idx] = rewrite_graph.rewrite_graph_pre_order(sg, arch, [], [insert_dma_cmd])
+ if verbose_graph:
+ nng.print_graph()
+ return nng
diff --git a/ethosu/vela/live_range.py b/ethosu/vela/live_range.py
new file mode 100644
index 0000000..24f1f64
--- /dev/null
+++ b/ethosu/vela/live_range.py
@@ -0,0 +1,324 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Build a live range graph for tensors in one or more subgraphs. Used for tensor allocation as well as in the scheduler.
+# Can work with either a pass packed subgraph or a scheduled subgraph.
+
+from .tensor import Tensor, MemArea
+from .nn_graph import TensorPurpose, PassPlacement
+from .high_level_command_stream_generator import calc_allowed_ofm_ifm_overlap_for_cascaded_pass
+
+
+class LiveRange:
+ def __init__(self, tens):
+ self.tensors = [] # Tensors that are assigned to the same LiveRange will be allocated to the same address
+ self.start_time = 99999999999
+ self.end_time = -1
+ self.size = 0
+ self.name = ""
+
+ if tens:
+ self.add_tensor(tens)
+
+ def __str__(self):
+ return "<live_range.LiveRange: '%s' start_time=%s, end_time=%s>" % (self.name, self.start_time, self.end_time)
+
+ __repr__ = __str__
+
+ def add_tensor(self, tens):
+ if self.size == 0:
+ self.size = tens.storage_size()
+ self.name = tens.name # LiveRange will be named after the first tensor added
+ else:
+ assert (
+ self.size >= tens.storage_size()
+ ), "Tensors assigned to the same LiveRange need to fit the size of the LiveRange."
+
+ self.tensors.append(tens)
+
+ def mark_usage(self, op_time):
+ if op_time == -1:
+ return
+ op_time_start = op_time
+ op_time_end = op_time + 1
+
+ self.start_time = min(self.start_time, op_time_start)
+ self.end_time = max(self.end_time, op_time_end)
+
+ def overlaps_ranges(self, other):
+ return max(self.start_time, other.start_time) < min(self.end_time, other.end_time)
+
+ def overlaps_address(self, other):
+ # Returns the first pair of tensors in this LiveRange and 'other' which have
+ # overlapping addresses
+ for tens in self.tensors:
+ for other_tens in other.tensors:
+ if max(tens.address, other_tens.address) < min(
+ tens.address + self.size, other_tens.address + other.size
+ ):
+ return True, tens, other_tens
+
+ return False, None, None
+
+ def __lt__(self, other):
+ if self.start_time != other.start_time:
+ return self.start_time < other.start_time
+ if self.end_time != other.end_time:
+ return self.end_time < other.end_time
+ if self.size != other.size:
+ return self.size < other.size
+ return self.name < other.name
+
+ def set_address(self, address):
+ # Set address of all unaddressed tensors in LiveRange
+ for tens in self.tensors:
+ if tens.address == 0:
+ tens.address = address
+ # Also need to set the address to the tensor's cpu/npu clones
+ if tens.cpu_tensor != None:
+ tens.cpu_tensor.address = address
+ if tens.npu_tensor != None:
+ tens.npu_tensor.address = address
+
+ def get_alignment(self):
+ # Get max alignment of LiveRange's tensors
+ if self.tensors:
+ alignment = 0
+ for tens in self.tensors:
+ alignment = max(alignment, tens.alignment)
+
+ return alignment
+
+ return Tensor.AllocationQuantum
+
+
+def merge_memory_op_ranges(sg, lr_graph, tensor_should_be_ignored, target_mem_area):
+ for ps in sg.passes:
+ if ps.placement == PassPlacement.MemoryOnly:
+ # For memory only passes, e.g. Reshape. Add input and output tensor to the same LiveRange
+ input_tensor = ps.inputs[0]
+ output_tensor = ps.outputs[0]
+ # If the input or output tensor is tied to a Cpu tensor, i.e. a subgraph input
+ # or output, fuse the live-range with the Cpu tensors' live-range instead.
+ input_tensor = input_tensor.cpu_tensor if input_tensor.cpu_tensor != None else input_tensor
+ output_tensor = output_tensor.cpu_tensor if output_tensor.cpu_tensor != None else output_tensor
+ if not tensor_should_be_ignored(input_tensor, target_mem_area) and not tensor_should_be_ignored(
+ output_tensor, target_mem_area
+ ):
+ lr_graph.fuse_ranges(input_tensor, output_tensor)
+
+
+class LiveRangeGraph:
+ def __init__(self):
+ self.ranges = {} # tens -> range
+ self.allowed_overlaps = {} # (tens,tens) -> overlap_int
+ self.ignore_tensors = set()
+ self.processed_subgraphs = set()
+ self.current_time = 0
+
+ def get_or_create_range(self, tens):
+ for rng in self.ranges.values():
+ # Return the live range of the tensor (or it's cpu/npu clone)
+ if any(tensor in rng.tensors for tensor in [tens, tens.npu_tensor, tens.cpu_tensor]):
+ return rng
+
+ # No live range found for the tensor, create a new one
+ rng = LiveRange(tens)
+ self.ranges[tens] = rng
+ return rng
+
+ def fuse_ranges(self, in_tens, out_tens):
+ live_range = self.get_or_create_range(in_tens)
+ assert out_tens not in self.ranges, out_tens
+ live_range.add_tensor(out_tens)
+ self.ranges[out_tens] = live_range
+ return live_range
+
+
+def extract_live_ranges_from_passes(
+ sg,
+ target_mem_area,
+ mark_output_tensors_overlapping_with_input_tensors=False,
+ ignore_subgraph_input_output_tensors=False,
+):
+ lr_graph = LiveRangeGraph()
+
+ if ignore_subgraph_input_output_tensors:
+ lr_graph.ignore_tensors.update(sg.input_tensors)
+ lr_graph.ignore_tensors.update(sg.output_tensors)
+
+ def tensor_should_be_ignored(tens, target_mem_area):
+ if tens.mem_area != target_mem_area:
+ return True
+ if tens in lr_graph.ignore_tensors:
+ return True
+ if tens.name.endswith("reshape_shape_npu"):
+ # Reshape tensor, no need to allocate
+ lr_graph.ignore_tensors.add(tens)
+ return True
+ return False
+
+ # Merge only memory operations in the NPU subgraphs
+ if sg.placement == PassPlacement.Npu:
+ merge_memory_op_ranges(sg, lr_graph, tensor_should_be_ignored, target_mem_area)
+
+ for idx, ps in enumerate(sg.passes):
+ ps.time = 2 * idx
+
+ time_for_pass = ps.time
+
+ for tens in ps.inputs:
+ if tensor_should_be_ignored(tens, target_mem_area):
+ continue
+ rng = lr_graph.get_or_create_range(tens)
+ rng.mark_usage(time_for_pass)
+
+ for tens in ps.intermediates:
+ if tensor_should_be_ignored(tens, target_mem_area):
+ continue
+ rng = lr_graph.get_or_create_range(tens)
+ rng.mark_usage(time_for_pass)
+
+ for tens in ps.outputs:
+ if tensor_should_be_ignored(tens, target_mem_area):
+ continue
+ rng = lr_graph.get_or_create_range(tens)
+ output_time = time_for_pass
+ if not mark_output_tensors_overlapping_with_input_tensors and ps.is_element_wise:
+ output_time += 1
+ rng.mark_usage(output_time)
+
+ end_time = len(sg.passes) * 2
+ for tens in sg.output_tensors:
+ if tensor_should_be_ignored(tens, target_mem_area):
+ continue
+ rng = lr_graph.get_or_create_range(tens)
+ rng.mark_usage(end_time)
+
+ return lr_graph
+
+
+def extract_live_ranges_from_cascaded_passes(
+ sg,
+ target_mem_area,
+ mark_output_tensors_overlapping_with_input_tensors=False,
+ use_ifm_ofm_overlap=True,
+ ignore_subgraph_input_output_tensors=False,
+ lr_graph=None,
+):
+ if lr_graph == None:
+ lr_graph = LiveRangeGraph()
+
+ if sg in lr_graph.processed_subgraphs:
+ # if subgraph has been processed already, return the lr_graph as is
+ return lr_graph
+
+ if ignore_subgraph_input_output_tensors:
+ lr_graph.ignore_tensors.update(sg.input_tensors)
+ lr_graph.ignore_tensors.update(sg.output_tensors)
+
+ def tensor_should_be_ignored(tens, target_mem_area):
+ if tens.mem_area != target_mem_area:
+ return True
+ if tens in lr_graph.ignore_tensors:
+ return True
+ if tens.name.endswith("reshape_shape_npu"):
+ # Reshape tensor, no need to allocate
+ lr_graph.ignore_tensors.add(tens)
+ return True
+ return False
+
+ # Merge only memory operations in the NPU subgraphs
+ if sg.placement == PassPlacement.Npu:
+ merge_memory_op_ranges(sg, lr_graph, tensor_should_be_ignored, target_mem_area)
+
+ for cps in sg.cascaded_passes:
+ cps.time = lr_graph.current_time
+
+ time_for_pass = cps.time
+
+ is_element_wise = cps.is_element_wise
+
+ for tens in cps.inputs:
+ if tensor_should_be_ignored(tens, target_mem_area):
+ continue
+ rng = lr_graph.get_or_create_range(tens)
+ rng.mark_usage(time_for_pass)
+
+ cps_primary_op = cps.passes[0].primary_op
+ if cps_primary_op and cps_primary_op.type == "NpuOp" and target_mem_area in set((MemArea.Sram, MemArea.Dram)):
+ # If the primary-op is an NpuOp that means this is where an Npu subgraph
+ # is called. Go into said subgraph and extract live ranges before continuing.
+ npu_sg = cps_primary_op.attrs["subgraph"]
+ lr_graph = extract_live_ranges_from_cascaded_passes(
+ npu_sg,
+ target_mem_area,
+ mark_output_tensors_overlapping_with_input_tensors,
+ use_ifm_ofm_overlap,
+ False,
+ lr_graph,
+ )
+ # Set the new time after handling the Npu subgraph
+ time_for_pass = lr_graph.current_time
+ cps.time = time_for_pass
+
+ for tens in cps.intermediates:
+ if tensor_should_be_ignored(tens, target_mem_area):
+ continue
+ rng = lr_graph.get_or_create_range(tens)
+ rng.mark_usage(time_for_pass)
+
+ for tens in cps.outputs:
+ if tensor_should_be_ignored(tens, target_mem_area):
+ continue
+ rng = lr_graph.get_or_create_range(tens)
+ output_time = time_for_pass
+ if not mark_output_tensors_overlapping_with_input_tensors and is_element_wise:
+ output_time += 1
+ rng.mark_usage(output_time)
+
+ if use_ifm_ofm_overlap:
+ # fill allowed overlap for ifm and ofm tensor
+ ifm_tensor = cps.passes[0].ifm_tensor
+ ofm_tensor = cps.passes[-1].ofm_tensor
+ if (
+ ifm_tensor is not None
+ and ofm_tensor is not None
+ and not tensor_should_be_ignored(ifm_tensor, target_mem_area)
+ and not tensor_should_be_ignored(ofm_tensor, target_mem_area)
+ ):
+ lr_graph.allowed_overlaps[(ifm_tensor, ofm_tensor)] = calc_allowed_ofm_ifm_overlap_for_cascaded_pass(
+ cps
+ )
+
+ lr_graph.current_time += 2
+
+ end_time = 0
+ for rng in lr_graph.ranges.values():
+ # Find the maximum end time of all live-ranges in the graph
+ end_time = max(end_time, rng.end_time)
+
+ for tens in sg.output_tensors:
+ if tensor_should_be_ignored(tens, target_mem_area):
+ continue
+ rng = lr_graph.get_or_create_range(tens)
+ rng.mark_usage(end_time)
+
+ # Add subgraph to set of processed subgraphs
+ lr_graph.processed_subgraphs.add(sg)
+ return lr_graph
diff --git a/ethosu/vela/mark_tensors.py b/ethosu/vela/mark_tensors.py
new file mode 100644
index 0000000..9b1824b
--- /dev/null
+++ b/ethosu/vela/mark_tensors.py
@@ -0,0 +1,363 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Mark purpose and select formats for Tensors. Also compresses the weights.
+
+from . import rewrite_graph
+from . import weight_compressor
+from .architecture_features import Block
+from .nn_graph import TensorPurpose, TensorFormat, PassPlacement
+from .operation import NpuBlockType
+
+
+def purpose_from_list(lst):
+ def purpose(op, idx):
+ return lst[idx]
+
+ return purpose
+
+
+def all_fm(op, idx):
+ return TensorPurpose.FeatureMap
+
+
+def all_parameter(op, idx):
+ return TensorPurpose.FeatureMap
+
+
+def input0_from_output_rest_parameter(op, idx):
+ if idx == 0:
+ res = op.outputs[0].purpose
+ if res == TensorPurpose.Unknown:
+ print("Warning: Propagating unknown tensor purpose", op)
+ return res
+ return TensorPurpose.FeatureMap
+
+
+def inputs_from_output(op, idx):
+ res = op.outputs[0].purpose
+ if res == TensorPurpose.Unknown:
+ print("Warning: Propagating unknown tensor purpose", op)
+ return res
+
+tensor_purposes = [ # ops, input_purpose
+ (
+ set(
+ (
+ "Relu",
+ "Relu6",
+ "Mul",
+ "Add",
+ "Sub",
+ "Rsqrt",
+ "Abs",
+ "Cast",
+ "Exp",
+ "Floor",
+ "FloorDiv",
+ "FloorMod",
+ "SquaredDifference",
+ "AddN",
+ "BiasAdd",
+ "RealDiv",
+ "Maximum",
+ "Minimum",
+ "Sigmoid",
+ "Tanh",
+ "FusedBatchNorm",
+ "AvgPool",
+ "MaxPool",
+ "Squeeze",
+ "Softmax",
+ "LRN",
+ "Assign",
+ "BatchMatMul",
+ "ZerosLike",
+ "ExtractImagePatches",
+ "MulAct",
+ "AddAct",
+ "SubAct",
+ "DivAct",
+ "AvgPoolAct",
+ "MaxPoolAct",
+ "LeakyRelu",
+ )
+ ),
+ all_fm,
+ ),
+ (
+ set(
+ (
+ "Conv2D",
+ "DepthwiseConv2dNative",
+ "MatMul",
+ "Conv2DBiasAct",
+ "DepthwiseConv2dBiasAct",
+ "FullyConnectedAct",
+ )
+ ),
+ purpose_from_list([TensorPurpose.FeatureMap, TensorPurpose.Weights, TensorPurpose.FeatureMap]),
+ ),
+ (
+ set(("Conv2DBackpropInputSwitched",)),
+ purpose_from_list([TensorPurpose.FeatureMap, TensorPurpose.Weights, TensorPurpose.FeatureMap]),
+ ),
+ (
+ set(("QuantizedConv2D", "QuantizedMatMul")),
+ purpose_from_list(
+ [
+ TensorPurpose.FeatureMap,
+ TensorPurpose.Weights,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ ]
+ ),
+ ),
+ (
+ set(
+ (
+ "Reshape",
+ "Min",
+ "Max",
+ "Mean",
+ "Pad",
+ "MirrorPad",
+ "ArgMax",
+ "ArgMin",
+ "ExpandDims",
+ "ResizeNearestNeighbor",
+ "ResizeBilinear",
+ "Tile",
+ "Transpose",
+ "Mfcc",
+ )
+ ),
+ purpose_from_list([TensorPurpose.FeatureMap, TensorPurpose.FeatureMap]),
+ ),
+ (
+ set(("QuantizedReshape", "QuantizedResizeBilinear")),
+ purpose_from_list(
+ [TensorPurpose.FeatureMap, TensorPurpose.FeatureMap, TensorPurpose.FeatureMap, TensorPurpose.FeatureMap]
+ ),
+ ),
+ (
+ set(("QuantizedBiasAdd", "QuantizedAdd", "QuantizedMul")),
+ purpose_from_list(
+ [
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ ]
+ ),
+ ),
+ (
+ set(
+ (
+ "Dequantize",
+ "Quantize",
+ "QuantizeV2",
+ "QuantizedRelu",
+ "QuantizedRelu1",
+ "QuantizedRelu6",
+ "QuantizedAvgPool",
+ "QuantizedMaxPool",
+ "Slice",
+ "SplitV",
+ )
+ ),
+ purpose_from_list([TensorPurpose.FeatureMap, TensorPurpose.FeatureMap, TensorPurpose.FeatureMap]),
+ ),
+ (
+ set(("BatchToSpaceND", "SpaceToBatchND", "DepthToSpaceND", "SpaceToDepthND")),
+ purpose_from_list([TensorPurpose.FeatureMap, TensorPurpose.FeatureMap, TensorPurpose.FeatureMap]),
+ ),
+ (
+ set(("BlockLSTM",)),
+ purpose_from_list(
+ [
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.Weights,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ ]
+ ),
+ ),
+ (set(("SplitSliceRead",)), purpose_from_list([TensorPurpose.FeatureMap, TensorPurpose.FeatureMap])),
+ (set(("Shape", "ConcatSliceWrite", "AudioSpectrogram")), purpose_from_list([TensorPurpose.FeatureMap])),
+ (
+ set(("StridedSlice",)),
+ purpose_from_list(
+ [TensorPurpose.FeatureMap, TensorPurpose.FeatureMap, TensorPurpose.FeatureMap, TensorPurpose.FeatureMap]
+ ),
+ ),
+ (set(("Fill", "Pack", "Range")), all_parameter),
+ (
+ set(("Requantize",)),
+ purpose_from_list(
+ [
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ TensorPurpose.FeatureMap,
+ ]
+ ),
+ ),
+ (set(("Placeholder", "SubgraphInput", "Const", "VariableV2")), purpose_from_list([])),
+ (set(("FakeQuantWithMinMaxArgs", "FakeQuantWithMinMaxVars")), input0_from_output_rest_parameter),
+ (
+ set(("Square", "Sqrt", "Log", "Less", "Enter", "Exit", "Identity", "StopGradient", "Merge", "Switch")),
+ inputs_from_output,
+ ),
+ (None, all_fm),
+]
+
+
+for ops, input_purpose in tensor_purposes:
+ if ops is None:
+ continue
+ for op in ops:
+ assert len(op) > 1, "string literal has been decomposed"
+
+
+def mark_tensor_purpose(nng, arch, verbose_tensor_purpose=False):
+ def mark_tensor_helper(tens, purpose):
+
+ if tens.purpose == TensorPurpose.Unknown or tens.purpose == purpose:
+ tens.purpose = purpose
+ else:
+ assert 0, "Cannot resolve tensor purpose %s and %s for tensor %s" % (tens.purpose, purpose, tens)
+ tens.mem_area = arch.tensor_storage_mem_area[tens.purpose]
+
+ if len(tens.ops) == 1 and tens.ops[0].type == "Const":
+ tens.mem_area = (
+ arch.permanent_storage_mem_area
+ ) # special case constants, as they must be in permanent storage
+
+ def rewrite_mark_tensor_purpose(op, arch):
+ # find disconnected outputs and mark as parameters
+ for tens in op.outputs:
+ if not tens.consumers():
+ mark_tensor_helper(tens, TensorPurpose.FeatureMap)
+
+ for ops, input_purpose in tensor_purposes:
+ if ops is None or op.type in ops:
+ if ops is None:
+ print(
+ "warning: don't know how to mark up purpose for",
+ op.type,
+ op.inputs,
+ "triggering all feature map fallback",
+ )
+ for idx, tens in enumerate(op.inputs):
+ purpose = input_purpose(op, idx)
+ mark_tensor_helper(tens, purpose)
+ break
+ return op
+
+ for sg in nng.subgraphs:
+ sg = rewrite_graph.rewrite_graph_pre_order(sg, arch, [], [rewrite_mark_tensor_purpose])
+ for tens in sg.output_tensors:
+ mark_tensor_helper(tens, TensorPurpose.FeatureMap)
+
+ if verbose_tensor_purpose:
+ nng.print_graph_with_tensors()
+
+ return nng
+
+
+reshape_operations = set(
+ (
+ "Reshape",
+ "QuantizedReshape",
+ "ExpandDims",
+ "Squeeze",
+ "BatchToSpaceND",
+ "SpaceToBatchND",
+ "DepthToSpaceND",
+ "SpaceToDepthND",
+ "Placeholder",
+ )
+)
+
+
+def mark_tensor_format(nng, arch, verbose_tensor_format=False):
+ formats_for_tensor = {}
+
+ def init_tens(tens):
+ if tens.purpose == TensorPurpose.FeatureMap:
+ fmt = arch.default_feature_map_format
+ elif tens.purpose == TensorPurpose.Weights:
+ fmt = arch.default_weight_format
+ else:
+ assert 0, "unknown tensor purpose %s" % (tens.purpose,)
+ return fmt
+
+ def find_npu_usage_of_tensor(tens):
+ for op in tens.consumers():
+ if op.type == "DMA":
+ return find_npu_usage_of_tensor(op.outputs[0])
+ if "npu_block_type" in op.attrs:
+ return op.attrs["npu_block_type"]
+ return NpuBlockType.Default
+
+ def visit_tens(tens, ps):
+ if not tens in formats_for_tensor:
+ fmt = init_tens(tens)
+ else:
+ fmt = formats_for_tensor[tens]
+
+ formats_for_tensor[tens] = fmt
+
+ for sg in nng.subgraphs:
+ for ps in sg.passes:
+ for tens in ps.outputs:
+ visit_tens(tens, ps)
+ for tens in ps.intermediates:
+ visit_tens(tens, ps)
+ for tens in ps.inputs:
+ visit_tens(tens, ps)
+
+ for tens, fmt in formats_for_tensor.items():
+ tens.set_format(fmt, arch)
+ if fmt == TensorFormat.WeightsCompressed and tens.values is not None:
+ npu_block_type = find_npu_usage_of_tensor(tens)
+ if len(tens.ops) == 1 and tens.ops[0].type == "DMA":
+ weight_compressor.compress_weights(tens, arch, npu_block_type, Block(32, 32, 32), 32)
+ # Alias compressed weights back into source tensor
+ src_tens = tens.ops[0].inputs[0]
+ src_tens.compressed_values = tens.compressed_values
+ src_tens.storage_shape = tens.storage_shape
+ src_tens.brick_size = tens.brick_size
+ src_tens.weight_compression_scales = tens.weight_compression_scales
+ src_tens.weight_compressed_offsets = tens.weight_compressed_offsets
+ src_tens.compression_scale_for_worst_weight_stream = tens.compression_scale_for_worst_weight_stream
+ src_tens.storage_compression_scale = tens.storage_compression_scale
+
+ if verbose_tensor_format:
+ nng.print_passes_with_tensors()
diff --git a/ethosu/vela/model_reader.py b/ethosu/vela/model_reader.py
new file mode 100644
index 0000000..6d7a3a4
--- /dev/null
+++ b/ethosu/vela/model_reader.py
@@ -0,0 +1,45 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Dispatcher for reading a neural network model.
+
+
+class ModelReaderOptions:
+ def __init__(self, batch_size=1):
+ self.batch_size = batch_size
+
+ def __str__(self):
+ return type(self).__name__ + ": " + str(self.__dict__)
+
+ __repr__ = __str__
+
+
+def read_model(fname, options, feed_dict={}, output_node_names=[], initialisation_nodes=[]):
+ if fname.endswith(".tflite"):
+ from . import tflite_reader
+
+ nng = tflite_reader.read_tflite(
+ fname,
+ options.batch_size,
+ feed_dict=feed_dict,
+ output_node_names=output_node_names,
+ initialisation_nodes=initialisation_nodes,
+ )
+ else:
+ assert 0, "Unknown model format"
+ return nng
diff --git a/ethosu/vela/nn_graph.py b/ethosu/vela/nn_graph.py
new file mode 100644
index 0000000..8d335bd
--- /dev/null
+++ b/ethosu/vela/nn_graph.py
@@ -0,0 +1,548 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Neural network graph classes and enums.
+# Pass - A packed pass containing one or more Operations.
+# CascadedPass - A scheduled pass containing one or more Passes, as well as a scheduling strategy and block
+# configurations.
+# Subgraph - Holds a neural network subgraph, pointing at Tensors, Operations, Passes, and CascadedPasses.
+# Graph - A full neural network graph with one or more Subgraphs.
+
+import enum
+from .data_type import BaseType, DataType
+from .tensor import MemArea, TensorPurpose, TensorSubPurpose, TensorFormat, Tensor
+from .operation import Operation, NpuBlockType
+
+
+class PassPlacement(enum.Enum):
+ Unknown = 0
+ Cpu = 1
+ Npu = 2
+ MemoryOnly = 3
+ StartupInit = 4
+
+
+class TensorAllocator(enum.Enum):
+ LinearAlloc = 1
+ Greedy = 2
+
+ def __str__(self):
+ return self.name
+
+
+class Pass:
+ def __init__(self, name, placement, is_element_wise, npu_block_type):
+ self.inputs = []
+ self.intermediates = []
+ self.outputs = []
+ self.ops = []
+ self.primary_op = None
+ self.ifm_tensor = None
+ self.ifm2_tensor = None
+ self.ofm_tensor = None
+ self.weight_tensor = None
+ self.scale_tensor = None
+ self.name = name
+ self.cascade = None
+ self.placement = placement
+
+ # TODO: rename is_element_wise because it is not the same as an ElementWise operator. It is used by the tensor
+ # allocation and requires that the OFM and IFM has the exact same address. Essentially complete overlap.
+ self.is_element_wise = is_element_wise
+ self.npu_block_type = npu_block_type
+ self.block_config = None # will be filled in by scheduler
+ self.shared_buffer = None # will be filled in by scheduler
+
+ self.predecessors = []
+ self.successors = []
+
+ def __str__(self):
+ return "<nng.Pass '%s', %s, ops=%s>" % (self.name, self.placement, [op.type for op in self.ops])
+
+ __repr__ = __str__
+
+ def get_primary_op_ifm_weights(self):
+ if not self.primary_op:
+ return None, None
+ return self.primary_op.get_ifm_ifm2_weights_ofm()[::2]
+
+ def get_primary_op_ifm_ifm2_weights_ofm(self):
+ if not self.primary_op:
+ return None, None, None, None
+ return self.primary_op.get_ifm_ifm2_weights_ofm()
+
+ def get_primary_op_ifm_weights_biases_ofm(self):
+ if not self.primary_op:
+ return None, None, None, None
+ return self.primary_op.get_ifm_weights_biases_ofm()
+
+
+class SchedulingStrategy(enum.Enum):
+ Unknown = -1
+ IfmStream = 0
+ WeightStream = 1
+
+
+class SchedulerRewrite(enum.Enum):
+ Nop = 0
+ ChangeTensorSubPurpose = 1
+
+
+class CascadedPass:
+ def __init__(self, name, strat, inputs, intermediates, outputs, passes, placement, is_element_wise):
+ self.name = name
+ self.strategy = strat
+ self.inputs = inputs
+ self.intermediates = intermediates
+ self.outputs = outputs
+ self.passes = passes
+ self.placement = placement
+ self.is_element_wise = is_element_wise
+
+ self.predecessors = []
+ self.successors = []
+
+ def __str__(self):
+ return "<nng.CascadedPass strategy=%s x %s '%s', passes=%s, block_configs=%s>" % (
+ self.strategy,
+ len(self.passes),
+ self.name,
+ [ps.name for ps in self.passes],
+ [ps.block_config for ps in self.passes],
+ )
+
+ __repr__ = __str__
+
+
+class Subgraph:
+ def __init__(self, name="<unnamed>", placement=PassPlacement.Cpu):
+ self.output_tensors = []
+ self.input_tensors = []
+ self.original_inputs = [] # Preserve the original input order
+ self.passes = []
+ self.cascaded_passes = []
+ self.name = name
+ self.high_level_command_stream = []
+ self.placement = placement
+ self.command_stream_tensor = None
+ self.flash_tensor = None
+
+ self.memory_used = {}
+
+ def __str__(self):
+ return "<nng.Subgraph '%s', n_passes=%d, n_cascaded_passes=%d>" % (
+ self.name,
+ len(self.passes),
+ len(self.cascaded_passes),
+ )
+
+ __repr__ = __str__
+
+ def update_consumers(self):
+ visit_op_set = set()
+ visit_tensor_set = set()
+ self.input_tensors = []
+
+ print_visit = False
+
+ def visit_op(op):
+ if op in visit_op_set:
+ return
+
+ visit_op_set.add(op)
+ for inp in op.inputs:
+ if print_visit:
+ print(inp, "adding consumer", op)
+ visit_tensor(inp)
+ inp.consumer_list.append(op)
+
+ if op.type in set(("Placeholder", "SubgraphInput")):
+ assert len(op.outputs) == 1
+ self.input_tensors.append(op.outputs[0])
+
+ for out in op.outputs:
+ if out not in visit_tensor_set:
+ out.consumer_list = [] # reset unvisited output, just in case
+
+ def visit_tensor(tens):
+ if tens in visit_tensor_set:
+ return
+ visit_tensor_set.add(tens)
+ tens.consumer_list = []
+ for op in tens.ops:
+ visit_op(op)
+
+ for ps in self.passes:
+ for tens in ps.outputs + ps.inputs:
+ tens.consumer_list = [] # reset unvisited tensors to start with
+
+ for tens in self.output_tensors:
+ visit_tensor(tens)
+ tens.consumer_list.append(None) # special op to indicate that the graph consumes the result
+
+ print_visit = True
+ for ps in self.passes:
+ for op in ps.ops:
+ visit_op(op)
+ for tens in ps.inputs:
+ visit_tensor(tens)
+
+ def build_pass_links(self):
+ for idx, ps in enumerate(self.passes):
+ ps.time = 2 * idx
+ ps.predecessors = []
+ ps.successors = []
+
+ for ps in self.passes:
+ for tens in ps.inputs:
+ for op in tens.ops:
+ pred_pass = op.scheduled_pass
+ assert pred_pass.time < ps.time
+ if ps not in pred_pass.successors:
+ pred_pass.successors.append(ps)
+
+ if pred_pass not in ps.predecessors:
+ ps.predecessors.append(pred_pass)
+
+ assert tens in pred_pass.outputs
+
+ def build_pass_dag_predecessors(self):
+ for ps in self.passes:
+ ps.dag_predecessors = []
+
+ class State(enum.Enum):
+ NotVisited = 0
+ BeingVisited = 1
+ Visited = 2
+
+ pass_visit_dict = {}
+
+ def visit_pass(ps):
+ state = pass_visit_dict.get(ps, State.NotVisited)
+ if state == State.Visited:
+ return True
+ elif state == State.BeingVisited:
+ return False # this is a loop, need to remove this link
+ elif state == State.NotVisited:
+ pass_visit_dict[ps] = State.BeingVisited
+
+ ps.dag_predecessors = []
+ for pred in ps.predecessors:
+ if visit_pass(pred):
+ ps.dag_predecessors.append(pred)
+
+ pass_visit_dict[ps] = State.Visited
+ return True
+
+ for ps in self.passes:
+ if not ps.successors:
+ visit_pass(ps)
+
+ def build_cascaded_pass_links(self):
+ for cps in self.cascaded_passes:
+ cps.predecessors = []
+ cps.successors = []
+
+ for cps in self.cascaded_passes:
+ for tens in cps.inputs:
+ for op in tens.ops:
+ pred_cpass = op.scheduled_pass.cascade
+ if cps not in pred_cpass.successors:
+ pred_cpass.successors.append(cps)
+
+ if pred_cpass not in cps.predecessors:
+ cps.predecessors.append(pred_cpass)
+
+ assert tens in pred_cpass.outputs
+
+ def refresh_after_modification(self):
+ self.update_consumers()
+
+ def prune_startup_init_pass(self):
+ assert len(self.passes) >= 1
+ ps = self.passes[0]
+ assert ps.placement == PassPlacement.StartupInit
+
+ ps.outputs = [out_tens for out_tens in ps.outputs if len(out_tens.consumers()) > 0]
+ ps.ops = [op for op in ps.ops if op.outputs[0] in ps.outputs]
+
+ def get_all_ops(self):
+ all_ops = []
+ visit_op_set = set()
+ visit_tensor_set = set()
+
+ def visit_op(op):
+ if op in visit_op_set:
+ return
+ visit_op_set.add(op)
+ for inp in op.inputs:
+ visit_tensor(inp)
+
+ all_ops.append(op)
+
+ def visit_tensor(tens):
+ if tens in visit_tensor_set:
+ return
+ visit_tensor_set.add(tens)
+ for op in tens.ops:
+ visit_op(op)
+
+ for tens in self.output_tensors:
+ visit_tensor(tens)
+
+ return all_ops
+
+ def print_operators(self):
+ all_ops = self.get_all_ops()
+ unique_ops = []
+ print("print_operators")
+ for op in all_ops:
+ if op.type in set(("Const", "Identity", "Placeholder")):
+ continue
+
+ attrs = op.attrs
+ if (
+ op.type == "Conv2D"
+ or op.type == "DepthwiseConv2dNative"
+ or op.type == "Conv2DBiasAct"
+ or op.type == "DepthwiseConv2dBiasAct"
+ ):
+ kshape = op.inputs[1].shape
+ attrs["kshape"] = [kshape[0], kshape[1]]
+ attrs["type"] = op.type
+ attrs.pop("use_cudnn_on_gpu", None)
+ if attrs not in unique_ops:
+ unique_ops.append(attrs)
+ # print attributes in human readable format
+ a = attrs.copy()
+ s = a.pop("type")
+ data_format = a.pop("data_format", None)
+ if data_format and data_format != b"NHWC":
+ s += " " + str(data_format)
+ t = a.pop("T", None)
+ if t:
+ s += " " + str(t)[9:-2]
+ srct = a.pop("SrcT", None)
+ if srct:
+ s += " " + str(srct)[9:-2]
+ dstt = a.pop("DstT", None)
+ if dstt:
+ s += "->" + str(dstt)[9:-2]
+ print(s + " " + str(a))
+
+ def print_graph(self):
+ all_ops = self.get_all_ops()
+ for idx, op in enumerate(all_ops):
+ print(idx, op.type, op.name)
+
+ def print_graph_with_tensors(self):
+ all_ops = self.get_all_ops()
+ for idx, op in enumerate(all_ops):
+ print(idx, op.type, op.name)
+ for idx, tens in enumerate(op.inputs):
+ print(" Input %02d %20s %20s %s" % (idx, tens.purpose.name, tens.mem_area.name, tens))
+ for idx, tens in enumerate(op.outputs):
+ print(" Output %02d %20s %20s %s" % (idx, tens.purpose.name, tens.mem_area.name, tens))
+ print()
+
+ def print_graph_with_tensor_quantization(self):
+ all_ops = self.get_all_ops()
+ for idx, op in enumerate(all_ops):
+ print(idx, op.type, op.name)
+ for idx, tens in enumerate(op.inputs):
+ q = tens.quantization
+ if q is None:
+ print(" Input %02d %10s NO QUANTIZATION INFO %s" % (idx, tens.dtype, tens.name))
+ else:
+ print(
+ " Input %02d %10s min=%s max=%s scale=%s zero_point=%s %s"
+ % (idx, tens.dtype, q.min, q.max, q.scale_f32, q.zero_point, tens.name)
+ )
+ for idx, tens in enumerate(op.outputs):
+ q = tens.quantization
+ if q is None:
+ print(" Output %02d %10s NO QUANTIZATION INFO %s" % (idx, tens.dtype, tens.name))
+ else:
+ print(
+ " Output %02d %10s min=%s max=%s scale=%s zero_point=%s %s"
+ % (idx, tens.dtype, q.min, q.max, q.scale_f32, q.zero_point, tens.name)
+ )
+ print()
+
+ def print_passes(self):
+ for idx, ps in enumerate(self.passes):
+ print("%03d %s" % (idx * 2, ps))
+
+ def print_passes_with_tensors(self):
+ for idx, ps in enumerate(self.passes):
+ print("%3d %s" % (idx * 2, ps))
+ for idx, tens in enumerate(ps.inputs):
+ print(
+ " Input %2d %-15s %-15s %-15s %s"
+ % (idx, tens.purpose.name, tens.mem_area.name, tens.format.name, tens.name)
+ )
+ for idx, tens in enumerate(ps.intermediates):
+ print(
+ " Intermediate %2d %-15s %-15s %-15s %s"
+ % (idx, tens.purpose.name, tens.mem_area.name, tens.format.name, tens.name)
+ )
+ for idx, tens in enumerate(ps.outputs):
+ print(
+ " Output %2d %-15s %-15s %-15s %s"
+ % (idx, tens.purpose.name, tens.mem_area.name, tens.format.name, tens.name)
+ )
+ print()
+
+ def print_cascaded_passes(self):
+ for idx, ps in enumerate(self.cascaded_passes):
+ print("%3d %s SRAM used %.1f KB" % (idx * 2, ps, ps.sram_used / 1024))
+
+ def print_cascaded_passes_with_tensors(self):
+ for idx, ps in enumerate(self.cascaded_passes):
+ print("%3d %s SRAM used %.1f KB" % (idx * 2, ps, ps.sram_used / 1024))
+ for idx, tens in enumerate(ps.inputs):
+ print(
+ " Input %2d %-15s %-15s %-15s %s"
+ % (idx, tens.purpose.name, tens.mem_area.name, tens.format.name, tens.name)
+ )
+ for idx, tens in enumerate(ps.intermediates):
+ print(
+ " Intermediate %2d %-15s %-15s %-15s %s"
+ % (idx, tens.purpose.name, tens.mem_area.name, tens.format.name, tens.name)
+ )
+ for idx, tens in enumerate(ps.outputs):
+ print(
+ " Output %2d %-15s %-15s %-15s %s"
+ % (idx, tens.purpose.name, tens.mem_area.name, tens.format.name, tens.name)
+ )
+ print()
+
+ def print_cascaded_passes_with_tensor_sizes(self):
+ for idx, ps in enumerate(self.cascaded_passes):
+ print("%3d %s SRAM used %.1f KB" % (idx * 2, ps, ps.sram_used / 1024))
+ for idx, tens in enumerate(ps.inputs):
+ print(
+ " Input %2d %7.1f KB %-24s %-15s %-15s %-20s %s"
+ % (
+ idx,
+ tens.storage_size() / 1024,
+ tens.storage_shape,
+ tens.mem_area.name,
+ tens.purpose.name,
+ tens.format.name,
+ tens.name,
+ )
+ )
+ for idx, tens in enumerate(ps.intermediates):
+ print(
+ " Intermediate %2d %7.1f KB %-24s %-15s %-15s %-20s %s"
+ % (
+ idx,
+ tens.storage_size() / 1024,
+ tens.storage_shape,
+ tens.mem_area.name,
+ tens.purpose.name,
+ tens.format.name,
+ tens.name,
+ )
+ )
+ for idx, tens in enumerate(ps.outputs):
+ print(
+ " Output %2d %7.1f KB %-24s %-15s %-15s %-20s %s"
+ % (
+ idx,
+ tens.storage_size() / 1024,
+ tens.storage_shape,
+ tens.mem_area.name,
+ tens.purpose.name,
+ tens.format.name,
+ tens.name,
+ )
+ )
+ print()
+
+ def print_high_level_command_stream(self):
+ for idx, cmd in enumerate(self.high_level_command_stream):
+ print("%3d %s" % (idx, cmd))
+
+
+class Graph:
+ def __init__(self, name="<unnamed>", batch_size=1):
+ self.name = name
+ self.batch_size = batch_size
+ self.subgraphs = []
+
+ self.memory_used = {}
+ self.bits_per_element = {}
+ self.total_size = {}
+ self.total_elements = {}
+
+ def get_root_subgraph(self):
+ return self.subgraphs[0]
+
+ def prune_startup_init_pass(self):
+ for sg in self.subgraphs:
+ sg.prune_startup_init_pass()
+
+ def update_consumers(self):
+ for sg in self.subgraphs:
+ sg.update_consumers()
+
+ def refresh_after_modification(self):
+ for sg in self.subgraphs:
+ sg.refresh_after_modification()
+
+ def print_operators(self):
+ for sg in self.subgraphs:
+ sg.print_operators()
+
+ def print_graph(self):
+ for sg in self.subgraphs:
+ sg.print_graph()
+
+ def print_graph_with_tensors(self):
+ for sg in self.subgraphs:
+ sg.print_graph_with_tensors()
+
+ def print_graph_with_tensor_quantization(self):
+ for sg in self.subgraphs:
+ sg.print_graph_with_tensor_quantization()
+
+ def print_passes(self):
+ for sg in self.subgraphs:
+ sg.print_passes()
+
+ def print_passes_with_tensors(self):
+ for sg in self.subgraphs:
+ sg.print_passes_with_tensors()
+
+ def print_cascaded_passes(self):
+ for sg in self.subgraphs:
+ sg.print_cascaded_passes()
+
+ def print_cascaded_passes_with_tensors(self):
+ for sg in self.subgraphs:
+ sg.print_cascaded_passes_with_tensors()
+
+ def print_cascaded_passes_with_tensor_sizes(self):
+ for sg in self.subgraphs:
+ sg.print_cascaded_passes_with_tensor_sizes()
+
+ def print_high_level_command_stream(self):
+ for sg in self.subgraphs:
+ sg.print_high_level_command_stream()
diff --git a/ethosu/vela/npu_performance.py b/ethosu/vela/npu_performance.py
new file mode 100644
index 0000000..84cc493
--- /dev/null
+++ b/ethosu/vela/npu_performance.py
@@ -0,0 +1,516 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# NPU performance estimation functions to estimate performance of a Pass and CascadedPass. Uses a model that takes the
+# maximum of the 'cycles required for bandwidth' and 'cycles required for computing'.
+#
+# Called during scheduling to evaluate different proposals, as well as post-scheduling to provide a final performance
+# estimate.
+
+import enum
+from . import numeric_util
+import numpy as np
+from .tensor import TensorPurpose, MemArea, TensorFormat, shape_num_elements, Tensor, TensorBlockTraversal
+from .operation import Operation
+from .data_type import DataType, BaseType
+from .nn_graph import PassPlacement, NpuBlockType, SchedulerRewrite, Pass
+from .architecture_features import Block, Kernel
+
+
+def rolling_buffer_dims_from_passes(arch, ps1, block_config_ps1, ps2, block_config_ps2):
+ ps2_strides = (1, 1, 1, 1)
+ ps2_dilation = (1, 1, 1, 1)
+ for op in ps2.ops:
+ if "strides" in op.attrs:
+ ps2_strides = op.attrs["strides"]
+ if "dilation" in op.attrs:
+ ps2_dilation = op.attrs["dilation"]
+
+ ifm_idx, _, weight_idx, _, _ = op.get_ifm_ifm2_weight_bias_ofm_indices()
+
+ rolling_buffer_sizes = []
+
+ weight_tensor = op.inputs[weight_idx]
+
+ ofm_block = Block(block_config_ps2[-3], block_config_ps2[-4], block_config_ps2[-1])
+ kernel = Kernel(
+ weight_tensor.shape[1], weight_tensor.shape[0], ps2_strides[2], ps2_strides[1], ps2_dilation[2], ps2_dilation[1]
+ )
+ kernel_block = Block(weight_tensor.shape[1], weight_tensor.shape[0], 65536)
+
+ if ps2.npu_block_type in set((NpuBlockType.ConvolutionMxN, NpuBlockType.VectorProduct)):
+ ifm_block_depth = arch.calc_ifm_block_depth(
+ op.inputs[ifm_idx].shape[-1], op.inputs[ifm_idx].dtype.size_in_bits()
+ )
+ else:
+ ifm_block_depth = block_config_ps2[-1]
+
+ ifm_block = arch.get_ifm_block_size(ifm_block_depth, ofm_block, kernel, kernel_block)
+
+ # The performed height calculation is for worst case
+ height = numeric_util.round_up(ifm_block.height + block_config_ps1[0], block_config_ps1[0])
+ width = ifm_block.width
+
+ rolling_buffer_sizes.append(height)
+ rolling_buffer_sizes.append(width)
+
+ return rolling_buffer_sizes
+
+
+class PassCycles(enum.IntEnum):
+ Dpu = 0
+ ElementWise = 1
+ Cpu = 2
+ SramAccess = 3
+ TotalPerPass = 4
+ DramAccess = 5
+ OnChipFlashAccess = 6
+ OffChipFlashAccess = 7
+ Total = 8
+ Size = 9
+
+ def display_name(self):
+ return (
+ "DPU",
+ "Element wise",
+ "CPU",
+ "SRAM Access",
+ "Total per Pass",
+ "DRAM Access",
+ "On-chip Flash Access",
+ "Off-chip Flash Access",
+ "Total",
+ "Size",
+ )[self.value]
+
+ def identifier_name(self):
+ return (
+ "dpu",
+ "element_wise",
+ "cpu",
+ "sram_access",
+ "total_per_pass",
+ "dram_access",
+ "on_chip_flash_access",
+ "off_chip_flash_access",
+ "total",
+ "size",
+ )[self.value]
+
+ @staticmethod
+ def all():
+ return (
+ PassCycles.Dpu,
+ PassCycles.ElementWise,
+ PassCycles.Cpu,
+ PassCycles.SramAccess,
+ PassCycles.DramAccess,
+ PassCycles.OnChipFlashAccess,
+ PassCycles.OffChipFlashAccess,
+ PassCycles.Total,
+ )
+
+
+class MacCount(enum.IntEnum):
+ NeuralNetworkMacs = 0
+ HardwareMacs = 1
+ Size = 2
+
+ def display_name(self):
+ return ("Neural Network Macs", "Hardware Macs", "Size")[self.value]
+
+ def identifier_name(self):
+ return ("nn_macs", "hardware_macs", "size")[self.value]
+
+ @staticmethod
+ def all():
+ return (MacCount.NeuralNetworkMacs, MacCount.HardwareMacs)
+
+
+class BandwidthDirection(enum.IntEnum):
+ Read = 0
+ Write = 1
+ Size = 2
+
+ def display_name(self):
+ return self.name
+
+ def identifier_name(self):
+ return self.name.lower()
+
+ @staticmethod
+ def all():
+ return (BandwidthDirection.Read, BandwidthDirection.Write)
+
+
+def make_bandwidth_array():
+ return np.zeros((MemArea.Size, TensorPurpose.Size, BandwidthDirection.Size))
+
+
+def make_macs_array():
+ return np.zeros(MacCount.Size, np.int)
+
+
+def make_cycles_array():
+ return np.zeros(PassCycles.Size)
+
+
+def make_metrics_arrays():
+ return (make_bandwidth_array(), make_macs_array(), make_cycles_array())
+
+
+def get_n_blocks_and_area(
+ ifm_brick_size, ifm_height_width, orig_skirt, clamped_skirt, block_config, min_block_size, strides
+):
+
+ ifm_block_config = (block_config[0] * strides[1], block_config[1] * strides[2])
+
+ n_normal_blocks = []
+ remainder_size = []
+ for i in range(2):
+ non_skirt_dim = ifm_height_width[i] - orig_skirt[i] - orig_skirt[2 + i]
+ n_blocks = non_skirt_dim // ifm_block_config[i]
+ n_normal_blocks.append(n_blocks)
+ remainder_dim = numeric_util.round_up(
+ ((non_skirt_dim - n_blocks * ifm_block_config[i] - 1) // strides[i + 1]) + 1, min_block_size[i]
+ )
+ remainder_size.append(remainder_dim)
+
+ # this will actually calculate reads into the edge padding.
+
+ # there are four cases in total, handling the edges that will not fill a complete block.
+
+ # 0000000001
+ # 0000000001
+ # 0000000001
+ # 0000000001
+ # 0000000001
+ # 0000000001
+ # 2222222223
+ total_blocks = 0
+ total_area = 0
+
+ block_setup = (
+ (n_normal_blocks[0] * n_normal_blocks[1], block_config),
+ (1 * n_normal_blocks[1], (remainder_size[0], block_config[1])),
+ (n_normal_blocks[0] * 1, (block_config[0], remainder_size[1])),
+ (1 * 1, remainder_size),
+ )
+
+ for n_blocks, block_size in block_setup:
+ if block_size[0] == 0 or block_size[1] == 0:
+ continue
+ read_dims = [0, 0]
+ for i in range(2):
+ read_dims[i] = (
+ numeric_util.round_up(clamped_skirt[i], ifm_brick_size[i + 1])
+ + block_size[i] * strides[i + 1]
+ + numeric_util.round_up(clamped_skirt[2 + i], ifm_brick_size[i + 1])
+ )
+ assert n_blocks >= 0
+ total_blocks += n_blocks
+ total_area += n_blocks * read_dims[0] * read_dims[1]
+ assert total_blocks >= 1
+ return total_blocks, total_area, block_setup
+
+
+def performance_metrics_for_pass(arch, ps, block_config=None, rewrite_list=[], force_outputs_to_fast_storage=False):
+ if block_config is None:
+ block_config = ps.block_config
+ bws = make_bandwidth_array()
+ macs = make_macs_array()
+ cycles = make_cycles_array()
+ blocks = 0
+ ifm_read_multiple = 1
+ weight_read_multiple = 0
+
+ if ps.placement in set((PassPlacement.MemoryOnly, PassPlacement.StartupInit)):
+ return bws, macs, cycles, blocks, ifm_read_multiple, weight_read_multiple # nothing real happening in this pass
+
+ min_block_size = arch.min_block_sizes[ps.npu_block_type]
+
+ skirt = (0, 0, 0, 0)
+ explicit_padding = (0, 0, 0, 0)
+ primary_op = ps.primary_op
+ replacement_read_bws = {}
+ if primary_op:
+ skirt = primary_op.attrs.get("skirt", skirt)
+ explicit_padding = primary_op.attrs.get("explicit_padding", explicit_padding)
+ assert primary_op.attrs["npu_block_type"] == ps.npu_block_type
+ npu_block_type = primary_op.attrs["npu_block_type"]
+
+ ifm_tensor, _, weight_tensor, ofm_tensor = ps.get_primary_op_ifm_ifm2_weights_ofm()
+
+ npu_convolution_ops = set((NpuBlockType.ConvolutionMxN, NpuBlockType.ConvolutionDepthWise))
+ if (npu_block_type == NpuBlockType.Pooling and len(ifm_tensor.shape) == 4) or (
+ npu_block_type in npu_convolution_ops
+ ):
+
+ batch_size = ifm_tensor.shape[0]
+ ifm_tensor_shape = list(ifm_tensor.shape)
+ ifm_depth = ifm_tensor.bandwidth_shape[3]
+
+ # add in padding
+ ifm_tensor_shape[1] += explicit_padding[0] + explicit_padding[2] # height += top and bottom
+ ifm_tensor_shape[2] += explicit_padding[1] + explicit_padding[3] # width += left and right
+
+ strides = primary_op.attrs["strides"]
+ if npu_block_type != NpuBlockType.Pooling:
+ weight_tensor_shape = weight_tensor.shape
+ weight_tensor_bandwidth_shape = weight_tensor.bandwidth_shape
+ weight_tensor_element_size = weight_tensor.element_size()
+ weight_tensor_bandwidth_compression_scale = weight_tensor.bandwidth_compression_scale
+ nn_ops = (
+ int(ofm_tensor.shape[0])
+ * int(ofm_tensor.shape[1])
+ * int(ofm_tensor.shape[2])
+ * int(weight_tensor_shape[0])
+ * int(weight_tensor_shape[1])
+ * int(weight_tensor_shape[2])
+ * int(weight_tensor_shape[3])
+ / int(strides[1])
+ / int(strides[2])
+ )
+ else:
+ weight_tensor_shape = [
+ primary_op.attrs["ksize"][1],
+ primary_op.attrs["ksize"][2],
+ 1,
+ ifm_tensor_shape[3],
+ ]
+ weight_tensor_bandwidth_shape = weight_tensor_shape
+ weight_tensor_element_size = 0
+ weight_tensor_bandwidth_compression_scale = 0.0
+ nn_ops = 0 # pooling doesn't count as NN ops
+
+ kernel_dims = weight_tensor_shape[:2]
+
+ sub_kernel_limits = arch.sub_kernel_limits[npu_block_type]
+ # count the sub kernels; the IFM block needs to be refetched for each of them
+ n_sub_kernels_y = numeric_util.round_up_divide(kernel_dims[0], sub_kernel_limits[0])
+ n_sub_kernels_x = numeric_util.round_up_divide(kernel_dims[1], sub_kernel_limits[1])
+ n_sub_kernels = n_sub_kernels_y * n_sub_kernels_x
+
+ clamped_skirt = list(skirt)
+ clamped_skirt[2] = min(clamped_skirt[2], sub_kernel_limits[0] - 1 - clamped_skirt[0])
+ clamped_skirt[3] = min(clamped_skirt[3], sub_kernel_limits[1] - 1 - clamped_skirt[1])
+ n_blocks, area, block_setup = get_n_blocks_and_area(
+ ifm_tensor.brick_size,
+ ifm_tensor_shape[1:3],
+ skirt,
+ clamped_skirt,
+ block_config,
+ min_block_size,
+ strides,
+ )
+
+ blocks = n_blocks * numeric_util.round_up_divide(weight_tensor_shape[3], block_config[3])
+
+ n_weight_stages = numeric_util.round_up_divide(weight_tensor_bandwidth_shape[3], block_config[3])
+ if npu_block_type == NpuBlockType.ConvolutionDepthWise or npu_block_type == NpuBlockType.Pooling:
+ n_weight_stages = 1 # force to no reread
+
+ ifm_tensor_bw = (
+ n_sub_kernels
+ * batch_size
+ * area
+ * ifm_depth
+ * n_weight_stages
+ * ifm_tensor.element_size()
+ * ifm_tensor.bandwidth_compression_scale
+ )
+ replacement_read_bws[ifm_tensor] = ifm_tensor_bw
+ ifm_read_multiple = n_weight_stages
+
+ replacement_read_bws[weight_tensor] = (
+ batch_size
+ * shape_num_elements(weight_tensor_bandwidth_shape)
+ * weight_tensor_element_size
+ * weight_tensor_bandwidth_compression_scale
+ * n_blocks
+ ) # read once per block and batch
+ weight_read_multiple = n_blocks
+
+ n_kernel_xy = kernel_dims[0] * kernel_dims[1]
+ n_input_channels_at_a_time = block_config[2]
+
+ if npu_block_type == NpuBlockType.Pooling or weight_tensor.block_traversal in set(
+ (TensorBlockTraversal.PartKernelFirst, TensorBlockTraversal.DepthWise)
+ ):
+ n_input_channels_at_a_time = numeric_util.round_up_divide(n_input_channels_at_a_time, 4)
+ n_kernel_xy = max(
+ n_kernel_xy, 4
+ ) # need at least 4, as this is the minimum duty cycle for secondary accumulator writes
+ if weight_tensor is not None:
+ n_kernel_xy = numeric_util.round_up(
+ n_kernel_xy, 4
+ ) # weights need to be read in blocks of 4
+
+ num_mac_ops = 0
+ for n_blocks_for_size, block_size in block_setup:
+ num_mac_ops += (
+ batch_size
+ * n_blocks_for_size
+ * block_size[0]
+ * block_size[1]
+ * numeric_util.round_up(weight_tensor_shape[2], n_input_channels_at_a_time)
+ * numeric_util.round_up(weight_tensor_shape[3], block_config[3])
+ * n_kernel_xy
+ )
+
+ if npu_block_type == NpuBlockType.Pooling:
+ # TODO: improve pooling estimation
+ cycles[PassCycles.Dpu] = num_mac_ops / arch.num_macs_per_cycle / 2
+ else:
+ cycles[PassCycles.Dpu] = num_mac_ops / arch.num_macs_per_cycle
+ macs[MacCount.NeuralNetworkMacs] += nn_ops
+ macs[MacCount.HardwareMacs] += num_mac_ops
+
+ elif npu_block_type == NpuBlockType.VectorProduct:
+ nn_macs = (
+ ifm_tensor.shape[0]
+ * numeric_util.round_up(weight_tensor.shape[-2], block_config[2])
+ * numeric_util.round_up(weight_tensor.shape[-1], block_config[3])
+ )
+ num_mac_ops = nn_macs
+
+ cycles[PassCycles.Dpu] = num_mac_ops / arch.num_macs_per_cycle
+ macs[MacCount.NeuralNetworkMacs] += nn_macs
+ macs[MacCount.HardwareMacs] += num_mac_ops
+
+ blocks = 1 * numeric_util.round_up_divide(weight_tensor.shape[-1], block_config[3])
+
+ non_zero_fraction = 1.0
+ if ifm_tensor.values is not None:
+ nz_vector = np.amax(ifm_tensor.values != 0, axis=0) # max across batch axis
+ non_zero_fraction = np.average(nz_vector)
+
+ replacement_read_bws[ifm_tensor] = ifm_tensor.bandwidth()
+ replacement_read_bws[weight_tensor] = weight_tensor.bandwidth() * non_zero_fraction
+ ifm_read_multiple = 1
+ weight_read_multiple = non_zero_fraction
+ else:
+ if ps.placement == PassPlacement.Npu and len(ps.outputs):
+ # Assume element-wise operation going through the element pipelines.
+ # Work out how many elements we have and calculate performance.
+ out = ps.outputs[0]
+ elms = out.elements()
+
+ cycles[PassCycles.ElementWise] = numeric_util.round_up_divide(elms, arch.num_elem_wise_units)
+
+ if ps.placement == PassPlacement.Cpu:
+ cycles[PassCycles.Cpu] = arch.cpu_cycle_estimate(ps.ops[0])
+
+ # apply the desired rewrites
+ for rewrite_op, tens, _, _, _, ps_to_rewrite in rewrite_list:
+ if ps != ps_to_rewrite:
+ continue
+ if rewrite_op == SchedulerRewrite.Nop:
+ pass # these are fine, no bandwidth changes
+ elif rewrite_op in (SchedulerRewrite.ChangeTensorSubPurpose,):
+ bws[arch.fast_storage_mem_area][tens.purpose][BandwidthDirection.Read] += replacement_read_bws[tens]
+ replacement_read_bws[tens] = 0
+
+ for tens in ps.outputs:
+ if force_outputs_to_fast_storage:
+ bws[arch.fast_storage_mem_area][tens.purpose][BandwidthDirection.Write] += tens.bandwidth()
+ else:
+ bws[tens.mem_area][tens.purpose][BandwidthDirection.Write] += tens.bandwidth()
+
+ for tens in ps.intermediates:
+ bws[tens.mem_area][tens.purpose][BandwidthDirection.Write] += tens.bandwidth()
+
+ if tens in replacement_read_bws:
+ bw = replacement_read_bws[tens]
+ else:
+ bw = tens.bandwidth()
+
+ bws[tens.mem_area][tens.purpose][BandwidthDirection.Read] += bw
+
+ for tens in ps.inputs:
+ if tens in replacement_read_bws:
+ bw = replacement_read_bws[tens]
+ else:
+ bw = tens.bandwidth()
+
+ bws[tens.mem_area][tens.purpose][BandwidthDirection.Read] += bw
+
+ cycles[PassCycles.SramAccess] = np.sum(bws[MemArea.Sram]) / arch.memory_bandwidths_per_cycle[MemArea.Sram]
+ cycles[PassCycles.TotalPerPass] = np.max(cycles[: PassCycles.TotalPerPass])
+
+ # quick build access counts for only current pass, even though these aren't the final numbers
+ update_summary_cycles(arch, bws, macs, cycles)
+
+ return bws, macs, cycles, blocks, ifm_read_multiple, weight_read_multiple
+
+
+def update_summary_cycles(arch, bws, macs, cycles):
+ cycles[PassCycles.DramAccess] = np.sum(bws[MemArea.Dram]) / arch.memory_bandwidths_per_cycle[MemArea.Dram]
+ cycles[PassCycles.OnChipFlashAccess] = (
+ np.sum(bws[MemArea.OnChipFlash]) / arch.memory_bandwidths_per_cycle[MemArea.OnChipFlash]
+ )
+ cycles[PassCycles.OffChipFlashAccess] = (
+ np.sum(bws[MemArea.OffChipFlash]) / arch.memory_bandwidths_per_cycle[MemArea.OffChipFlash]
+ )
+
+ cycles[PassCycles.Total] = np.max(cycles[: PassCycles.Total])
+ return cycles
+
+
+def collate_stats_for_cascaded_pass(arch, bws, macs, cycles):
+ return bws, macs, cycles
+
+
+def performance_for_cascaded_pass(arch, cps):
+ total_bws = make_bandwidth_array()
+ total_macs = make_macs_array()
+ total_cycles = make_cycles_array()
+
+ for ps in cps.passes:
+ bws, macs, cycles, blocks, _, _ = performance_metrics_for_pass(arch, ps)
+ ps.bandwidths = bws
+ ps.macs = macs
+ ps.cycles = cycles
+ ps.n_blocks = blocks
+ total_bws += bws
+ total_macs += macs
+ total_cycles += cycles
+
+ bws, macs, cycles = collate_stats_for_cascaded_pass(arch, total_bws, total_macs, total_cycles)
+ cps.bandwidths = bws
+ cps.macs = macs
+ cps.cycles = cycles
+ return bws, macs, cycles
+
+
+def calc_performance_for_network(nng, arch):
+ total_bws = make_bandwidth_array()
+ total_macs = np.zeros(MacCount.Size)
+ total_cycles = np.zeros(PassCycles.Size)
+
+ for sg in nng.subgraphs:
+ for cps in sg.cascaded_passes:
+ bws, macs, cycles = performance_for_cascaded_pass(arch, cps)
+ total_bws += bws
+ total_macs += macs
+ total_cycles += cycles
+ total_cycles += arch.inter_pass_cycle_delay
+
+ nng.bandwidths = total_bws
+ nng.macs = total_macs
+ nng.cycles = total_cycles
diff --git a/ethosu/vela/npu_serialisation.py b/ethosu/vela/npu_serialisation.py
new file mode 100644
index 0000000..4542c25
--- /dev/null
+++ b/ethosu/vela/npu_serialisation.py
@@ -0,0 +1,145 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Serialises and packs an NPU subgraph into tensors.
+
+from .nn_graph import PassPlacement
+from .tensor import MemArea, Tensor, TensorPurpose, TensorFormat
+from .operation import Operation
+from .data_type import DataType
+import numpy as np
+from . import driver_actions
+import struct
+
+
+def make_memory_tensor(name, mem_area, sz, want_values, arch):
+ tens = Tensor([sz], DataType.uint8, name)
+ tens.mem_area = mem_area
+ tens.purpose = TensorPurpose.FeatureMap
+ tens.set_format(TensorFormat.NHWC, arch)
+ if want_values:
+ tens.values = np.zeros(tens.shape, np.uint8)
+ return tens
+
+
+def copy_compressed_values_to_memory_tensor(memory_tensor, src_tensor):
+ start_addr = src_tensor.address
+ for compressed_values in src_tensor.compressed_values:
+ end_addr = start_addr + len(compressed_values)
+ memory_tensor.values[start_addr:end_addr] = compressed_values
+ start_addr = end_addr
+
+
+def serialise_npu_subgraph_into_tensors(nng, sg, arch, scratch_tens, flash_tens):
+ if sg.placement != PassPlacement.Npu:
+ return scratch_tens, flash_tens
+
+ flash_area = arch.permanent_storage_mem_area
+ scratch_area = MemArea.Sram
+
+ flash_size = sg.memory_used.get(flash_area, 0)
+ scratch_size = sg.memory_used.get(scratch_area, 0)
+
+ # Prepare driver actions for this command tensor
+ da_list = []
+ driver_actions.emit_fourcc(da_list, "COP1")
+ driver_actions.emit_config(da_list, 0, 1, arch)
+ driver_actions.emit_cmd_stream_header(da_list, len(sg.register_command_stream))
+
+ # Append command stream words
+ da_list.extend(sg.register_command_stream)
+
+ # Convert to bytes
+ payload_bytes = struct.pack("<{0}I".format(len(da_list)), *da_list)
+
+ command_stream_size_bytes = len(payload_bytes)
+
+ # Adjust the bits per element calculation to exclude metadata generated by Vela
+ nng.total_size[flash_area] = nng.total_size.get(flash_area, 0) - flash_size - command_stream_size_bytes
+ nng.total_elements[flash_area] = nng.total_elements.get(flash_area, 0) - flash_size - command_stream_size_bytes
+ nng.total_size[scratch_area] = nng.total_size.get(scratch_area, 0) - scratch_size
+ nng.total_elements[scratch_area] = nng.total_elements.get(scratch_area, 0) - scratch_size
+
+ if flash_tens == scratch_tens == None:
+ # First Npu subgraph, create scratch and flash tensors
+ sg.scratch_tensor = make_memory_tensor(sg.name + "_scratch", scratch_area, scratch_size, False, arch)
+ sg.scratch_tensor.purpose = TensorPurpose.Scratch
+ sg.flash_tensor = make_memory_tensor(sg.name + "_flash", flash_area, flash_size, True, arch)
+ else:
+ sg.scratch_tensor = scratch_tens
+ sg.scratch_tensor.shape[0] += scratch_size
+ sg.flash_tensor = flash_tens
+ sg.flash_tensor.shape[0] += flash_size
+
+ for cps in sg.cascaded_passes:
+ for ps in cps.passes:
+ if ps.placement == PassPlacement.Npu and ps.weight_tensor != None:
+ # For DMA ops, ps.weight_tensor is referring to the SRAM weight tensor and therefore the address
+ # is pointing at the destination address of where the weights should be placed in SRAM.
+ # This ensures that the Flash weight tensor is used instead and thus gets the correct address.
+ if ps.weight_tensor.ops[0].type == "DMA":
+ copy_compressed_values_to_memory_tensor(sg.flash_tensor, ps.weight_tensor.ops[0].inputs[0])
+ else:
+ copy_compressed_values_to_memory_tensor(sg.flash_tensor, ps.weight_tensor)
+
+ copy_compressed_values_to_memory_tensor(sg.flash_tensor, ps.scale_tensor)
+
+ sg.command_stream_tensor = make_memory_tensor(
+ sg.name + "_command_stream", flash_area, command_stream_size_bytes, True, arch
+ )
+ sg.command_stream_tensor.values = np.frombuffer(payload_bytes, dtype=np.uint8)
+
+ return sg.scratch_tensor, sg.flash_tensor
+
+
+def add_const_tens_to_startup_cascaded_pass(startup_cps, tens):
+ op = Operation("Const", tens.name + "_const")
+ op.outputs = [tens]
+ tens.ops = [op]
+ startup_cps.passes[0].ops.insert(0, op)
+ startup_cps.passes[0].outputs.insert(0, tens)
+ startup_cps.outputs.insert(0, tens)
+
+
+def rewrite_npu_call_ops(nng, sg, arch):
+ if sg.placement != PassPlacement.Cpu:
+ return
+
+ startup_cps = sg.cascaded_passes[0]
+
+ for idx, cps in enumerate(sg.cascaded_passes):
+ for ps in cps.passes:
+ for op in ps.ops:
+ if op.type == "NpuOp":
+ callee = op.attrs["subgraph"]
+ op.attrs["custom_options"] = {"type": op.type}
+
+ sz = 0
+ for tens in [callee.scratch_tensor, callee.flash_tensor, callee.command_stream_tensor]:
+ op.inputs.insert(0, tens)
+ ps.inputs.insert(0, tens)
+ cps.inputs.insert(0, tens)
+ if tens != callee.scratch_tensor:
+ add_const_tens_to_startup_cascaded_pass(startup_cps, tens)
+ sz += tens.storage_size()
+
+ for prev_cps in sg.cascaded_passes[: idx + 1]:
+ prev_cps.sram_used += sz
+
+ if callee.scratch_tensor is not None:
+ cps.sram_used += callee.scratch_tensor.storage_size()
diff --git a/ethosu/vela/numeric_util.py b/ethosu/vela/numeric_util.py
new file mode 100644
index 0000000..e5bc88b
--- /dev/null
+++ b/ethosu/vela/numeric_util.py
@@ -0,0 +1,89 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Numerical utilities for various types of rounding etc.
+
+import math
+import numpy as np
+
+
+def round_up(a, b):
+ return ((a + b - 1) // b) * b
+
+
+def round_up_divide(a, b):
+ return (a + b - 1) // b
+
+
+def round_up_to_int(v):
+ return int(math.ceil(v))
+
+
+def round_down_to_power_of_two(v):
+ assert v > 0
+ while v & (v - 1):
+ v &= v - 1
+
+ return v
+
+
+def round_up_to_power_of_two(v):
+ return round_down_to_power_of_two(2 * v - 1)
+
+
+def round_down_log2(v):
+ return int(math.floor(np.log2(v)))
+
+
+def round_up_log2(v):
+ return int(math.ceil(np.log2(v)))
+
+
+def round_to_int(v):
+ return np.rint(v).astype(np.int64)
+
+
+# Performs rounding away from zero.
+# n.b. This is identical to C++11 std::round()
+def round_away_zero(f):
+ r = -0.5 if (f < 0) else 0.5
+ return np.trunc(f + r)
+
+
+def quantise_float32(f, scale=1.0, zero_point=0):
+ return zero_point + int(round_away_zero(np.float32(f) / np.float32(scale)))
+
+
+def clamp_tanh(x):
+ if x <= -4:
+ y = -1.0
+ elif x >= 4:
+ y = 1.0
+ else:
+ y = math.tanh(x)
+ return y
+
+
+def clamp_sigmoid(x):
+ if x <= -8:
+ y = 0.0
+ elif x >= 8:
+ y = 1.0
+ else:
+ y = 1 / (1 + math.exp(-x))
+ return y
diff --git a/ethosu/vela/operation.py b/ethosu/vela/operation.py
new file mode 100644
index 0000000..d2f2806
--- /dev/null
+++ b/ethosu/vela/operation.py
@@ -0,0 +1,285 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Internal representation of a Neural Network Operation.
+
+import enum
+
+
+class NpuBlockType(enum.Enum):
+ Default = 0
+ ConvolutionMxN = 1
+ VectorProduct = 2
+ Pooling = 3
+ ConvolutionDepthWise = 4
+ ElementWise = 5
+
+
+class Operation:
+ """Class representing a Neural Network operation. Has a name, a type,
+input and output tensors, as well as an attribute dictionary."""
+
+ __slots__ = "type", "name", "attrs", "inputs", "outputs", "flops", "scheduled_pass", "run_on_npu"
+
+ def __init__(self, op_type, name):
+ self.type = op_type
+ self.name = name
+ self.attrs = {}
+ self.inputs = []
+ self.outputs = []
+ self.flops = 0
+ self.run_on_npu = True
+ self.scheduled_pass = None
+
+ def clone(self, suffix="_clone"):
+ res = Operation(self.type, self.name + suffix)
+
+ res.attrs = dict(self.attrs)
+ res.inputs = list(self.inputs)
+ res.outputs = list(self.outputs)
+ res.flops = self.flops
+ res.scheduled_pass = self.scheduled_pass
+
+ return res
+
+ def __str__(self):
+ return "<nng.Operation '%s' type=%s>" % (self.name, self.type)
+
+ __repr__ = __str__
+
+ def get_ifm_ifm2_weight_bias_ofm_indices(self):
+ ifm_idx = -1
+ ifm2_idx = -1
+ weight_idx = -1
+ bias_idx = -1
+ ofm_idx = -1
+ npu_block_type = self.attrs.get("npu_block_type", NpuBlockType.Default)
+ if npu_block_type in set((NpuBlockType.ConvolutionMxN, NpuBlockType.ConvolutionDepthWise)):
+ ifm_idx = 0
+ weight_idx = 1
+ ofm_idx = 0
+
+ if self.type in set(("Conv2DBiasAct", "DepthwiseConv2dBiasAct", "TransposeConvAct")):
+ if len(self.inputs) >= 3:
+ bias_idx = 2
+
+ elif npu_block_type == NpuBlockType.Pooling:
+ ifm_idx = 0
+ ofm_idx = 0
+ elif npu_block_type == NpuBlockType.VectorProduct:
+ ifm_idx = 0
+ weight_idx = 1
+ ofm_idx = 0
+
+ if self.type in set(("FullyConnectedAct",)):
+ if len(self.inputs) >= 3:
+ bias_idx = 2
+
+ if self.type == "BlockLSTM":
+ ifm_idx = 3
+ weight_idx = 4
+ ofm_idx = 6
+
+ elif npu_block_type == NpuBlockType.ElementWise:
+ ifm_idx = 0
+ ifm2_idx = 1
+ ofm_idx = 0
+
+ # LeakyRelu and Abs have a single IFM
+ if self.type in set(("LeakyRelu", "Abs")):
+ ifm2_idx = -1
+
+ elif self.type == "Conv2DBackpropInput":
+ ifm_idx = 2
+ weight_idx = 1
+ ofm_idx = 0
+
+ elif self.type in set(("Squeeze", "Reshape", "QuantizedReshape", "ExpandDims")):
+ ifm_idx = 0
+ ofm_idx = 0
+
+ elif self.is_split_op():
+ ifm_idx = 0
+ ofm_idx = 0
+ if self.type == "Split":
+ ifm_idx = 1
+
+ elif self.is_concat_op():
+ ifms, _ = self.get_concat_inputs_axis()
+ ifm_idx = self.inputs.index(ifms[0])
+ if len(ifms) > 1:
+ ifm2_idx = self.inputs.index(ifms[1])
+ ofm_idx = 0
+
+ return ifm_idx, ifm2_idx, weight_idx, bias_idx, ofm_idx
+
+ def get_ifm_ifm2_weights_ofm(self):
+ ifm_tensor = None
+ ifm2_tensor = None
+ weight_tensor = None
+ ofm_tensor = None
+
+ ifm_idx, ifm2_idx, weight_idx, bias_idx, ofm_idx = self.get_ifm_ifm2_weight_bias_ofm_indices()
+ if ifm_idx != -1:
+ ifm_tensor = self.inputs[ifm_idx]
+ if ifm2_idx != -1:
+ ifm2_tensor = self.inputs[ifm2_idx]
+ if weight_idx != -1:
+ weight_tensor = self.inputs[weight_idx]
+ if ofm_idx != -1:
+ ofm_tensor = self.outputs[ofm_idx]
+
+ return ifm_tensor, ifm2_tensor, weight_tensor, ofm_tensor
+
+ def get_ifm_weights_biases_ofm(self):
+ ifm_tensor = None
+ weight_tensor = None
+ bias_tensor = None
+ ofm_tensor = None
+
+ ifm_idx, _, weight_idx, bias_idx, ofm_idx = self.get_ifm_ifm2_weight_bias_ofm_indices()
+ if ifm_idx != -1:
+ ifm_tensor = self.inputs[ifm_idx]
+ if weight_idx != -1:
+ weight_tensor = self.inputs[weight_idx]
+ if bias_idx != -1:
+ bias_tensor = self.inputs[bias_idx]
+ if ofm_idx != -1:
+ ofm_tensor = self.outputs[ofm_idx]
+
+ return ifm_tensor, weight_tensor, bias_tensor, ofm_tensor
+
+ concat_ops = set(("Concat", "ConcatV2", "QuantizedConcat", "ConcatTFLite", "PackReshaped"))
+
+ def is_concat_op(self):
+ return self.type in Operation.concat_ops
+
+ def get_concat_inputs_axis(self):
+ assert self.is_concat_op()
+
+ if self.type == "ConcatV2":
+ axis_tensor = self.inputs[-1]
+ inputs = self.inputs[:-1]
+ elif self.type == "Concat":
+ axis_tensor = self.inputs[0]
+ inputs = self.inputs[1:]
+ elif self.type == "QuantizedConcat":
+ axis_tensor = self.inputs[0]
+ inputs = self.inputs[1:]
+ inputs = inputs[: len(inputs) // 3] # Skip min/max
+
+ if self.type == "ConcatTFLite":
+ inputs = self.inputs
+ axis = self.attrs["axis"]
+ elif self.type == "PackReshaped":
+ # Requires fixup_pack_input to be called before this point
+ inputs = self.inputs
+ axis = self.attrs["axis"]
+ assert len(self.inputs) == self.attrs["values_count"]
+ else:
+ assert len(axis_tensor.ops) == 1 and axis_tensor.ops[0].type == "Const"
+ axis = int(axis_tensor.values)
+
+ return inputs, axis
+
+ split_ops = set(("Split", "StridedSlice", "Slice", "UnpackReshaped"))
+
+ def is_split_op(self):
+ return self.type in Operation.split_ops
+
+ def get_split_inputs_axis(self):
+ assert self.is_split_op()
+
+ offset_start = None
+ offset_end = None
+ axis = None
+ if self.type == "Split":
+ # TODO: Extend split capabilities
+ # If num_or_size_splits is an integer, then value is split along dimension axis into num_split smaller
+ # tensors. This requires that num_split evenly divides value.shape[axis].
+ # If num_or_size_splits is a 1-D Tensor (or list), we call it size_splits and value is split into
+ # len(size_splits) elements. The shape of the i-th element has the same size as the value except along
+ # dimension axis where the size is size_splits[i].
+ num_splits = self.attrs.get("num_splits")
+ axis_tens = self.inputs[0]
+ assert len(axis_tens.ops) == 1 and axis_tens.ops[0].type == "Const"
+ axis = int(axis_tens.values)
+ input_tens = self.inputs[1]
+ outputs = self.outputs
+ assert num_splits == len(outputs)
+
+ elif self.type == "Slice":
+ input_tens, begin_tens, size_tens = self.inputs
+ outputs = self.outputs
+ offset_start = [0] * len(input_tens.shape)
+ offset_end = [0] * len(input_tens.shape)
+
+ for idx in range(len(begin_tens.values)):
+ # Check if the op should slice in dimension idx
+ if size_tens.values[idx] != input_tens.shape[idx]:
+ offset_start[idx] = begin_tens.values[idx]
+ offset_end[idx] = size_tens.values[idx] + offset_start[idx]
+
+ elif self.type == "StridedSlice":
+ input_tens, begin_tens, end_tens, strides_tens = self.inputs
+ outputs = self.outputs
+ out_tens = outputs[0]
+ offset_start = [0] * len(outputs[0].shape)
+ offset_end = [0] * len(outputs[0].shape)
+
+ # Extract masks
+ begin_mask = self.attrs["begin_mask"]
+ ellipsis_mask = self.attrs["ellipsis_mask"]
+ end_mask = self.attrs["end_mask"]
+ new_axis_mask = self.attrs["new_axis_mask"]
+ shrink_axis_mask = self.attrs["shrink_axis_mask"]
+ # TODO: Either extend this to support these different masks or check
+ # for this at an earlier stage and place the op on Cpu if needed
+ assert begin_mask == end_mask
+ assert new_axis_mask == ellipsis_mask == 0
+ # shrink_axis_mask is not supported by the Operation class but the operation
+ # may have the attribute modified and handled in the graph optimization phase.
+ assert shrink_axis_mask == 0
+ assert len(input_tens.shape) == len(out_tens.shape)
+
+ for idx in range(len(input_tens.shape)):
+ # If the i:th bit in begin_mask is set then the value on begin[i] should be ignored
+ if (begin_mask & (1 << idx)) == 0:
+ # Check if the op should slice in dimension idx
+ if end_tens.values[idx] != input_tens.shape[idx] or (
+ end_tens.values[idx] == input_tens.shape[idx] and begin_tens.values[idx] != 0
+ ):
+ offset_start[idx] = begin_tens.values[idx]
+ offset_end[idx] = end_tens.values[idx]
+
+ else:
+ # Don't slice in this axis, instead use fullest possible range
+ continue
+
+ elif self.type == "UnpackReshaped":
+ # Requires fixup_unpack_output to be called before this point
+ input_tens = self.inputs[0]
+ outputs = self.outputs
+ axis = self.attrs["axis"]
+ num_splits = self.attrs["num"]
+ # Number of outputs have to equal the value of the dimension to unpack
+ assert num_splits == len(outputs) == input_tens.shape[axis]
+ else:
+ assert False
+
+ return input_tens, outputs, axis, offset_start, offset_end
diff --git a/ethosu/vela/pass_packing.py b/ethosu/vela/pass_packing.py
new file mode 100644
index 0000000..663520f
--- /dev/null
+++ b/ethosu/vela/pass_packing.py
@@ -0,0 +1,489 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Packs a subgraph with Neural Network Operations into Passes. Each Pass has one or more Operations.
+
+from .nn_graph import Operation, Pass, PassPlacement, TensorPurpose, NpuBlockType, Tensor
+import collections
+import enum
+from .data_type import BaseType, DataType
+
+
+class PassFlags(enum.Flag):
+ Empty = 0
+ Pre = 1
+ Main = 2
+ Post = 4
+ Mac = 8
+ Dma = 32
+ ElementWise = 256
+ Npu = 512
+ Cpu = 1024
+ StartupInit = 2048
+ MemoryOnly = 4096
+ PostFusingLimited = 8192
+
+
+npu_pre_ops = set(("QuantizedResizeBilinear", "SplitSliceRead",))
+
+mac_main_ops = set(
+ (
+ # convolutions
+ "Conv2DBiasAct",
+ "Conv2D",
+ "QuantizedConv2D",
+ "Conv2DBackpropInputSwitched",
+ # depth-wise convolutions
+ "DepthwiseConv2dBiasAct",
+ "DepthwiseConv2dNative",
+ "QuantizedDepthwiseConv2D",
+ # FC layers
+ "QuantizedMatMul",
+ "MatMul",
+ "FullyConnectedAct",
+ # RNN/LSTM/GRU
+ "BlockLSTM",
+ # pooling
+ "QuantizedMaxPool",
+ "QuantizedAvgPool",
+ "AvgPool",
+ "MaxPool",
+ "AvgPoolAct",
+ "MaxPoolAct",
+ )
+)
+
+binary_elem_wise_main_ops = set(
+ (
+ # binary element-wise
+ "AddAct",
+ "MulAct",
+ "SubAct",
+ "QuantizedAdd",
+ "QuantizedSub",
+ "QuantizedMul",
+ "Mul",
+ "Add",
+ "Sub",
+ "Minimum",
+ "Maximum",
+ )
+)
+
+unary_elem_wise_main_ops = set(("LeakyRelu", "Abs")) # Unary element-wise operations
+
+elem_wise_main_ops = binary_elem_wise_main_ops | unary_elem_wise_main_ops
+
+activation_ops = set(("QuantizedRelu", "QuantizedRelu1", "QuantizedRelu6", "Relu", "Relu6", "ReluN1To1"))
+npu_post_ops = activation_ops | set(
+ # Bias-add operations: Get rid of these once we have rewrites from Conv2D + BiasAdd + Activation to Conv2DBiasAct.
+ ("Mul", "Add", "QuantizedBiasAdd", "Requantize", "QuantizedBatchNorm", "BiasAdd", "FusedBatchNorm")
+)
+
+npu_post_fuse_limited_ops = set(
+ # Set of post operators that should not be fused with main/elementwise ops
+ ("ConcatSliceWrite", "Sigmoid", "Tanh")
+)
+
+elem_wise_ops = elem_wise_main_ops | activation_ops | set(("Sigmoid", "Tanh"))
+
+
+quantization_ops = set(("Dequantize", "QuantizeV2", "Max", "Min"))
+cpu_ops = (
+ set(("Softmax", "QuantizedSoftmax", "LRN", "Shape", "QuantizedPad", "Pad", "AddN"))
+ | quantization_ops
+)
+
+npu_dma_ops = set(("DMA",))
+startup_init_ops = set(("Const", "VariableV2", "Placeholder", "SubgraphInput"))
+memory_only_ops = set(("Squeeze", "Reshape", "QuantizedReshape", "ExpandDims",))
+
+
+test_sequence = [
+ (
+ # ops_set
+ npu_post_ops,
+ # incompatible_pack_flags
+ PassFlags.Cpu | PassFlags.MemoryOnly | PassFlags.Pre | PassFlags.Main,
+ # flags_to_set
+ PassFlags.Npu | PassFlags.Post,
+ # flags_to_clear
+ PassFlags.Empty,
+ ),
+ (
+ # ops_set
+ npu_post_fuse_limited_ops,
+ # incompatible_pack_flags
+ PassFlags.Cpu | PassFlags.MemoryOnly | PassFlags.Pre | PassFlags.Main,
+ # flags_to_set
+ PassFlags.Npu | PassFlags.PostFusingLimited,
+ # flags_to_clear
+ PassFlags.Empty,
+ ),
+ (
+ # ops_set
+ mac_main_ops,
+ # incompatible_pack_flags
+ PassFlags.Cpu
+ | PassFlags.MemoryOnly
+ | PassFlags.ElementWise
+ | PassFlags.Pre
+ | PassFlags.Main
+ | PassFlags.PostFusingLimited,
+ # flags_to_set
+ PassFlags.Npu | PassFlags.Mac | PassFlags.Main,
+ # flags_to_clear
+ PassFlags.Empty,
+ ),
+ (
+ # ops_set
+ elem_wise_main_ops,
+ # incompatible_pack_flags
+ PassFlags.Cpu
+ | PassFlags.MemoryOnly
+ | PassFlags.Mac
+ | PassFlags.Pre
+ | PassFlags.Main
+ | PassFlags.PostFusingLimited,
+ # flags_to_set
+ PassFlags.Npu | PassFlags.ElementWise | PassFlags.Main,
+ # flags_to_clear
+ PassFlags.Empty,
+ ),
+ (
+ # ops_set
+ npu_pre_ops,
+ # incompatible_pack_flags
+ PassFlags.Cpu | PassFlags.MemoryOnly,
+ # flags_to_set
+ PassFlags.Npu | PassFlags.Mac | PassFlags.Pre | PassFlags.ElementWise,
+ # flags_to_clear
+ PassFlags.Empty,
+ ),
+ (
+ # ops_set
+ npu_dma_ops,
+ # incompatible_pack_flags
+ PassFlags.Cpu | PassFlags.MemoryOnly,
+ # flags_to_set
+ PassFlags.Npu | PassFlags.Dma,
+ # flags_to_clear
+ PassFlags.Empty
+ ),
+ (
+ # ops_set
+ startup_init_ops,
+ # incompatible_pack_flags
+ PassFlags.Npu | PassFlags.Cpu | PassFlags.MemoryOnly,
+ # flags_to_set
+ PassFlags.StartupInit | PassFlags.Main,
+ # flags_to_clear
+ PassFlags.Empty,
+ ),
+ (
+ # ops_set
+ memory_only_ops,
+ # incompatible_pack_flags
+ PassFlags.Npu | PassFlags.Cpu,
+ # flags_to_set
+ PassFlags.MemoryOnly | PassFlags.Main,
+ # flags_to_clear
+ PassFlags.Empty
+ ),
+ (
+ # ops_set
+ cpu_ops,
+ # incompatible_pack_flags
+ PassFlags.Npu | PassFlags.MemoryOnly | PassFlags.Main,
+ # flags_to_set
+ PassFlags.Cpu | PassFlags.Main,
+ # flags_to_clear
+ PassFlags.Empty
+ ),
+ ( # This last one is a fallback for unrecognised operations
+ # ops_set
+ None,
+ # incompatible_pack_flags
+ PassFlags.Npu | PassFlags.MemoryOnly | PassFlags.Main,
+ # flags_to_set
+ PassFlags.Cpu | PassFlags.Main,
+ # flags_to_clear
+ PassFlags.Empty
+ ),
+]
+
+# Some sanity checking
+for (operation_set, incompatible_pack_flags, flags_to_set, flags_to_clear) in test_sequence:
+ assert not flags_to_clear & flags_to_set
+
+ if operation_set is not None:
+ for op in operation_set:
+ assert len(op) > 1 # This is to avoid string literals being decomposed
+
+
+def pack_into_passes(nng, arch, verbose_packing=False):
+ def visit_op(op, ignored):
+ visit_op_refcount[op] += 1
+
+ if visit_op_refcount[op] == 1: # First-time visit, go and fix up unused output tensors
+ for tens in op.outputs:
+ if len(tens.consumers()) == 0:
+ visit_op_refcount[op] += 1
+
+ assert visit_op_refcount[op] <= len(op.outputs)
+ if visit_op_refcount[op] == len(op.outputs):
+
+ if op.type in startup_init_ops:
+ startup_list.append(op)
+ else:
+ _, _, _, ofm_tensor = op.get_ifm_ifm2_weights_ofm()
+ if ofm_tensor is None:
+ ofm_tensor = op.outputs[0]
+ build_pass((op,), ofm_tensor)
+
+ def build_pass(start_ops_to_process, ofm_tensor=None):
+ reverse_ops_list = []
+ curr_flags = PassFlags.Empty
+ npu_block_type = NpuBlockType.Default
+
+ reverse_intermediates = []
+ input_set = set()
+ ifm_tensor = None
+ primary_op = None
+
+ to_process = collections.deque()
+ for start_op in start_ops_to_process:
+ to_process.append((start_op, None))
+
+ while to_process:
+ curr_op, tens = to_process.popleft()
+
+ if curr_op in reverse_ops_list:
+ continue
+
+ for operation_set, incompatible_pack_flags, flags_to_set, flags_to_clear in test_sequence:
+ if operation_set is None or curr_op.type in operation_set:
+ if not (curr_flags & incompatible_pack_flags):
+ if flags_to_set & PassFlags.Npu:
+ if not curr_op.run_on_npu:
+ continue
+
+ reverse_ops_list.append(curr_op)
+ new_block_type = curr_op.attrs.get("npu_block_type", NpuBlockType.Default)
+ if new_block_type != NpuBlockType.Default:
+ assert npu_block_type == NpuBlockType.Default
+ npu_block_type = new_block_type # Only one major block type per pass
+ assert primary_op is None
+ primary_op = curr_op
+
+ curr_flags &= ~flags_to_clear
+ curr_flags |= flags_to_set
+
+ if flags_to_set & PassFlags.Npu:
+ if flags_to_set & (
+ PassFlags.Mac | PassFlags.ElementWise | PassFlags.Post | PassFlags.PostFusingLimited
+ ):
+ assert len(curr_op.inputs) >= 1
+ if curr_op.type == "BlockLSTM":
+ ifm_tensor = curr_op.inputs[3]
+ else:
+ ifm_tensor = curr_op.inputs[0]
+ assert ifm_tensor.purpose == TensorPurpose.FeatureMap
+
+ if flags_to_set & PassFlags.Dma:
+ # DMAs are special - Output buffers need to be preserved as intermediates,
+ # if the pass consumes the results
+ if tens is not None:
+ reverse_intermediates.append(tens)
+
+ if operation_set is None:
+ print("Warning:", curr_op.type, "operation is unknown or unsupported, placing on CPU")
+
+ for inp in curr_op.inputs:
+ can_pack = True
+ if len(inp.ops) == 1:
+ next_op = inp.ops[0]
+ for outp in next_op.outputs:
+ consumers = outp.consumers()
+ if len(consumers) > 1 or (len(consumers) == 1 and consumers[0] != curr_op):
+ can_pack = False
+ break
+ else:
+ can_pack = False
+
+ if can_pack:
+ to_process.append((next_op, inp))
+ else:
+ assert inp is not None
+ input_set.add(inp)
+
+ break
+
+ else:
+ # This operation is not compatible with already packed operations, just register the tensor as an input
+ assert tens is not None
+ input_set.add(tens)
+
+ if curr_flags & PassFlags.Npu and not curr_flags & (PassFlags.ElementWise | PassFlags.Mac):
+ # Make the choice that if we don't have a mac operation, the ambidextrous operations go on the
+ # element wise unit
+ curr_flags |= PassFlags.ElementWise
+
+ is_element_wise = True
+ for op in reverse_ops_list:
+ if not op.type in elem_wise_ops and not op.type in npu_dma_ops:
+ is_element_wise = False
+ break
+
+ placement = PassPlacement.Unknown
+ if curr_flags & PassFlags.Npu:
+ assert placement == PassPlacement.Unknown
+ placement = PassPlacement.Npu
+ if curr_flags & PassFlags.Cpu:
+ assert placement == PassPlacement.Unknown
+ placement = PassPlacement.Cpu
+ if curr_flags & PassFlags.MemoryOnly:
+ assert placement == PassPlacement.Unknown
+ placement = PassPlacement.MemoryOnly
+ if curr_flags & PassFlags.StartupInit:
+ assert placement == PassPlacement.Unknown
+ placement = PassPlacement.StartupInit
+ assert placement != PassPlacement.Unknown
+
+ ops_list = list(reversed(reverse_ops_list))
+ intermediates = list(reversed(reverse_intermediates))
+
+ if primary_op == None:
+ primary_op = create_primary_op(ops_list)
+ if primary_op != None:
+ visit_tensor_refcount[primary_op.inputs[0]] += 1
+ npu_block_type = primary_op.attrs["npu_block_type"]
+ for input_tens in primary_op.inputs:
+ if input_tens not in input_set:
+ input_set.add(input_tens)
+
+ ordered_input_list = []
+ input_refcounts = collections.defaultdict(int)
+ for op in ops_list:
+ for inp in op.inputs:
+ if inp in input_set:
+ if input_refcounts[inp] == 0:
+ ordered_input_list.append(inp)
+ input_refcounts[inp] += 1
+
+ name = ops_list[0].name
+ non_dma_ops = [op for op in ops_list if op.type != "DMA"]
+ if non_dma_ops:
+ name = non_dma_ops[0].name
+ ps = Pass(name, placement, is_element_wise, npu_block_type)
+ ps.ops = ops_list
+ ps.primary_op = primary_op
+ ps.inputs = ordered_input_list
+ ps.intermediates = intermediates
+ ps.outputs = list(ops_list[-1].outputs)
+ ps.ifm_tensor = ifm_tensor
+
+ # ElementWise operation, 2 IFMs
+ if ps.primary_op and ps.primary_op.type in binary_elem_wise_main_ops:
+ ps.ifm_tensor = ps.inputs[0]
+
+ if len(ps.inputs) == 1:
+ # Only 1 input, IFM and IFM2 are the same tensor
+ ps.ifm2_tensor = ps.inputs[0]
+ else:
+ ps.ifm2_tensor = ps.inputs[1]
+ else:
+ ps.ifm_tensor = ifm_tensor
+ ps.ifm2_tensor = None
+
+ ps.ofm_tensor = ofm_tensor
+ assert ps.placement != PassPlacement.Npu or ps.ofm_tensor is not None
+ ps.weight_tensor = ps.get_primary_op_ifm_weights()[1]
+ ps.scale_tensor = ps.get_primary_op_ifm_weights_biases_ofm()[2]
+
+ for op in ps.ops:
+ op.scheduled_pass = ps
+
+ reverse_pass_list.append(ps)
+
+ for inp, refcount in input_refcounts.items():
+ for _ in range(refcount):
+ visit_tensor(inp)
+
+ return ps
+
+ def visit_tensor(tens):
+ visit_tensor_refcount[tens] += 1
+ assert visit_tensor_refcount[tens] <= len(tens.consumers())
+ if visit_tensor_refcount[tens] == len(tens.consumers()):
+ for op in reversed(tens.ops):
+ visit_op(op, tens)
+
+ def create_primary_op(ops_list):
+ if any(op.type in (npu_pre_ops | npu_post_ops | npu_post_fuse_limited_ops) for op in ops_list):
+ # Configure a 1x1 AvgPool and attach the op onto it
+ op = ops_list[0]
+ inp = op.inputs[0]
+ avgpool_name = op.name + "_avgpool"
+ avgpool_op = Operation("AvgPool", avgpool_name)
+ avgpool_op.inputs = [inp]
+ avgpool_op.inputs[0].consumer_list.append(avgpool_op)
+ avgpool_op.attrs["padding"] = b"VALID"
+ avgpool_op.attrs["npu_block_type"] = NpuBlockType.Pooling
+ avgpool_op.attrs["stride_w"] = 1
+ avgpool_op.attrs["stride_h"] = 1
+ avgpool_op.attrs["filter_width"] = 1
+ avgpool_op.attrs["filter_height"] = 1
+ avgpool_op.attrs["strides"] = [1, 1, 1, 1]
+ avgpool_op.attrs["ksize"] = [1, 1, 1, 1]
+ avgpool_op.attrs["skirt"] = [0, 0, 0, 0]
+ avgpool_op.attrs["explicit_padding"] = [0, 0, 0, 0]
+ avgpool_out = inp.clone("_avgpooled")
+ avgpool_out.consumer_list.append(op)
+ avgpool_out.ops = [avgpool_op]
+ avgpool_op.outputs = [avgpool_out]
+
+ op.inputs[0] = avgpool_out
+ ops_list.insert(0, avgpool_op)
+
+ return avgpool_op
+
+ return None
+
+ for sg in nng.subgraphs:
+ reverse_pass_list = []
+ visit_op_refcount = collections.defaultdict(int)
+ visit_tensor_refcount = collections.defaultdict(int)
+
+ startup_list = []
+
+ for tens in sg.output_tensors:
+ visit_tensor(tens)
+
+ if startup_list:
+ startup_ps = build_pass(startup_list)
+ startup_ps.outputs = [op.outputs[0] for op in startup_list] # Need to fixup the outputs
+ startup_ps.name = "startup_weight_initialisation"
+
+ sg.passes = list(reversed(reverse_pass_list))
+ sg.build_pass_links()
+
+ if verbose_packing:
+ nng.print_passes()
+
+ return nng
diff --git a/ethosu/vela/range_set.py b/ethosu/vela/range_set.py
new file mode 100644
index 0000000..64de970
--- /dev/null
+++ b/ethosu/vela/range_set.py
@@ -0,0 +1,154 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Helper classes to track memory accesses for calculating dependencies between Commands.
+
+from enum import IntEnum
+from collections import defaultdict
+from functools import lru_cache
+
+
+class RangeSet:
+ """A Range set class to track ranges and whether they intersect.
+Intended for e.g. tracking sets of memory ranges and whether two commands use the same memory areas."""
+
+ def __init__(self, start=None, end=None, ranges=None):
+ if ranges is None:
+ ranges = []
+
+ self.ranges = ranges # track a list of (start, end) tuples, always in ascending order sorted by start.
+
+ if start is not None and start != end:
+ assert start < end
+ self.ranges.append((start, end))
+
+ def __or__(self, other):
+ combined_ranges = list(sorted(self.ranges + other.ranges))
+ return RangeSet(ranges=combined_ranges)
+
+ def __ior__(self, other):
+ self.ranges = list(sorted(self.ranges + other.ranges))
+ return self
+
+ def intersects(self, other):
+ a_ranges = self.ranges
+ b_ranges = other.ranges
+
+ a_idx = 0
+ b_idx = 0
+
+ while a_idx < len(a_ranges) and b_idx < len(b_ranges):
+ ar = a_ranges[a_idx]
+ br = b_ranges[b_idx]
+ if max(ar[0], br[0]) < min(ar[1], br[1]):
+ return True # intersection
+
+ # advance one of the two upwards
+ if ar[0] < br[0]:
+ a_idx += 1
+ else:
+ assert ar[0] != br[0]
+ # note ar[0] == br[0] cannot happen, then we'd have an intersection
+ b_idx += 1
+
+ return False
+
+ def __str__(self):
+ return "<RangeSet %s>" % (["%#x:%#x" % (int(start), int(end)) for start, end in self.ranges],)
+
+ __repr__ = __str__
+
+
+class MemoryRangeSet:
+ """Extended version of the RangeSet class that handles having different memory areas"""
+
+ def __init__(self, mem_area=None, start=None, end=None, regions=None):
+
+ if regions is None:
+ regions = {}
+ self.regions = regions
+
+ if mem_area is not None:
+ self.regions[mem_area] = RangeSet(start, end)
+
+ def __or__(self, other):
+ combined_regions = {
+ mem_area: (self.regions.get(mem_area, RangeSet()) | other.regions.get(mem_area, RangeSet()))
+ for mem_area in (self.regions.keys() | other.regions.keys())
+ }
+ return MemoryRangeSet(regions=combined_regions)
+
+ def __ior__(self, other):
+ self.regions = {
+ mem_area: (self.regions.get(mem_area, RangeSet()) | other.regions.get(mem_area, RangeSet()))
+ for mem_area in (self.regions.keys() | other.regions.keys())
+ }
+ return self
+
+ def intersects(self, other):
+ for mem_area in self.regions.keys() & other.regions.keys():
+ if self.regions[mem_area].intersects(other.regions[mem_area]):
+ return True
+ return False
+
+ def __str__(self):
+ s = "<MemoryRangeSet>"
+ for mem_area, rng in self.regions.items():
+ s += "%s: %s\t" % (mem_area, rng)
+ return s
+
+ __repr__ = __str__
+
+
+class AccessDirection(IntEnum):
+ Read = 0
+ Write = 1
+ Size = 2
+
+
+class MemoryAccessSet:
+ """Tracks memory ranges, but also access patterns to know which accesses actually are in conflict"""
+
+ def __init__(self):
+ self.accesses = [MemoryRangeSet() for i in range(AccessDirection.Size)]
+
+ def add(self, memory_range_set, access):
+ self.accesses[access] |= memory_range_set
+
+ @lru_cache(maxsize=None)
+ def conflicts(self, other):
+
+ # True dependencies, or write -> read
+ if self.accesses[AccessDirection.Write].intersects(other.accesses[AccessDirection.Read]):
+ return True
+
+ # Anti-dependencies, or read -> write
+ if self.accesses[AccessDirection.Read].intersects(other.accesses[AccessDirection.Write]):
+ return True
+
+ # Output dependencies, or write -> write
+ if self.accesses[AccessDirection.Write].intersects(other.accesses[AccessDirection.Write]):
+ return True
+
+ # read -> read does not cause a conflict
+ return False
+
+ def __str__(self):
+ return "Read: %s\nWrite: %s\n\n" % (self.accesses[AccessDirection.Read], self.accesses[AccessDirection.Write])
+
+ __repr__ = __str__
diff --git a/ethosu/vela/register_command_stream_generator.py b/ethosu/vela/register_command_stream_generator.py
new file mode 100644
index 0000000..5563b96
--- /dev/null
+++ b/ethosu/vela/register_command_stream_generator.py
@@ -0,0 +1,945 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Register level (low-level) command stream generation for Ethos-U55. Takes a high-level command stream and generates
+# all the register settings. Calculates dependencies between commands and inserts wait operations. And generates a bit
+# stream suitable for interpretation by the Ethos-U55 processor.
+
+from collections import defaultdict
+from enum import Enum, IntEnum
+from .high_level_command_stream import CommandType
+from .ethos_u55_regs.ethos_u55_regs import *
+from .tensor import MemArea, TensorBlockTraversal
+from .operation import NpuBlockType
+from .numeric_util import quantise_float32, round_up, round_away_zero, round_up_to_int, clamp_sigmoid, clamp_tanh
+from .data_type import BaseType
+import numpy as np
+from .shared_buffer_allocation import SharedBufferAllocation
+from .architecture_features import SharedBufferArea, SHRAMElements, ArchitectureFeatures
+from .nn_graph import TensorFormat, SchedulingStrategy
+from .range_set import (
+ MemoryAccessSet,
+ AccessDirection,
+)
+from .mark_tensors import (
+ reshape_operations,
+)
+from .architecture_features import Block, Kernel, Rect
+from . import scaling
+
+
+class RegisterMachine:
+ def __init__(self):
+ self.n_banks = 1
+ self.registers = [defaultdict(lambda: None) for _ in range(self.n_banks)]
+ self.bank_idx = 0
+
+ def set_register(self, reg, value):
+ is_changed = self.registers[self.bank_idx][reg] != value
+ self.registers[self.bank_idx][reg] = value
+ # is_changed = True # force command
+ return is_changed
+
+ def switch_bank(self):
+ self.bank_idx = (self.bank_idx + 1) % self.n_banks
+
+
+class CmdMode(IntEnum):
+ NoPayload = 0x0000
+ Payload32 = 0x4000
+ Mask = 0xC000
+ CmdOpMask = 0x03FF
+
+
+class BasePointerIndex(IntEnum):
+ ReadOnly = 0 # base address slot index for weights and scaling
+ Scratch = 1 # base address slot index for scratch memory area
+
+
+# TODO: Replace with definitions from ethos_u55_regs
+class IFM2Broadcast(IntEnum):
+ BroadcastHdim = 1 << 0
+ BroadcastWdim = 1 << 1
+ BroadcastCdim = 1 << 2
+ ReverseOperandOrder = 1 << 6
+ UseIFM2Scalar = 1 << 7
+
+
+class CommandStreamEmitter:
+ def __init__(self):
+ self.cmd_stream = []
+ self.reg_machine = [RegisterMachine(), RegisterMachine()]
+ self.last_absolute_wait = defaultdict(int)
+
+ def get_reg_machine(self, cmd):
+ if "DMA" in cmd.name:
+ return self.reg_machine[1]
+ else:
+ return self.reg_machine[0]
+
+ def size_in_bytes(self):
+ sz = 0
+ for cmd in self.cmd_stream:
+ sz += len(cmd) * 4
+ return sz
+
+ def to_list(self):
+ return [elem for cmd in self.cmd_stream for elem in cmd]
+
+ def print_cmds(self):
+ print("Code: Command: Param: Payload:")
+ for words_for_one_command in self.cmd_stream:
+ code = words_for_one_command[0] & 0x0000FFFF # lower 16 bits
+ param = words_for_one_command[0] >> 16 # higher 16 bits
+
+ payload_mode = CmdMode(code & CmdMode.Mask)
+
+ # code and command
+ s = " 0x%04x " % code
+ if payload_mode == CmdMode.NoPayload:
+ s += str(cmd0(code & CmdMode.CmdOpMask))
+ else:
+ s += str(cmd1(code & CmdMode.CmdOpMask))
+
+ s = s.ljust(40)
+ s += "%5d" % param
+
+ # payload
+ if payload_mode == CmdMode.Payload32:
+ s += " 0x%08x (%d)" % (words_for_one_command[1], words_for_one_command[1])
+ else:
+ s += " -"
+
+ print(s)
+
+ def cmd0_with_param(self, cmd, param):
+ if isinstance(param, Enum):
+ param = int(param.value)
+ else:
+ param = int(param)
+ param = param & 0xFFFF
+ command = cmd.value | (param << 16)
+ if not self.get_reg_machine(cmd).set_register(cmd, (command, param)):
+ return
+
+ # This is not a redundant command, actually write it
+ self.cmd_stream.append((command,))
+
+ def cmd1_with_offset(self, cmd, offset, param=0x0):
+ offset = int(offset) & 0xFFFFFFFFF
+ command = cmd.value | CmdMode.Payload32.value | (param << 16)
+
+ if not self.get_reg_machine(cmd).set_register(cmd, (command, offset)):
+ return
+
+ # This is not a redundant command, actually write it
+ self.cmd_stream.append((command, offset))
+
+ def cmd_wait(self, cmd, param, absolute_wait_time):
+ if absolute_wait_time <= self.last_absolute_wait[cmd]:
+ return
+
+ self.last_absolute_wait[cmd] = absolute_wait_time
+ param = int(param)
+ command = ((param & 0xFFFF) << 16) | cmd.value
+ self.cmd_stream.append((command,))
+
+ def cmd_do_operation(self, cmd, param=0):
+ param = int(param)
+ command = ((param & 0xFFFF) << 16) | cmd.value
+
+ self.cmd_stream.append((command,))
+ self.get_reg_machine(cmd).switch_bank()
+
+
+def calc_command_dependencies(cmd_stream, arch):
+ cmd_starts = {}
+ cmd_ends = {}
+ memory_accesses = {}
+
+ # Keep track of accumulated number of commands in command stream.
+ # First element kernel ops: (# of blocks, # of commands)
+ # Second element DMA ops: (# of commands)
+ pos = np.array((np.array((0, 0)), np.array([0])))
+
+ dependencies = {}
+
+ for cmd in cmd_stream:
+ cmd_starts[cmd] = pos
+ op_count = cmd.get_operation_count()
+ # Keep track of both num blocks and commands
+ cmd_add = 0 if (op_count[0] == 0) else 1
+ pos = np.array((pos[0] + np.array((op_count[0], cmd_add)), pos[1] + np.array([op_count[1]])))
+ cmd_ends[cmd] = np.array((pos[0], pos[1]))
+ memory_accesses[cmd] = cmd.get_memory_accesses()
+
+ for idx, cmd in enumerate(cmd_stream):
+ curr_accesses = memory_accesses[cmd]
+ # Keep track of command dependency.
+ # First element kernel ops: (# of blocks, # of commands)
+ # Second element DMA ops: (# of commands)
+ dep_offsets = np.array((np.array((-1, -1)), np.array([-1])))
+ dep_cmds = [None] * CommandType.Size.value
+ if idx > 0:
+ # Look at the previous commands in backwards order
+ for prev_cmd in cmd_stream[idx - 1 :: -1]:
+ assert prev_cmd is not cmd
+ if dep_cmds[prev_cmd.cmdtype] is None:
+ is_dependency = False
+ if cmd.cmdtype == CommandType.NpuStripe and prev_cmd.cmdtype == CommandType.NpuStripe:
+ # Special handling here, as dpu -> dpu operations require additional care
+ if not SharedBufferAllocation.is_compatible(prev_cmd.ps.shared_buffer, cmd.ps.shared_buffer):
+ is_dependency = True
+ elif memory_accesses[prev_cmd].conflicts(curr_accesses):
+ is_dependency = True
+ else:
+ if memory_accesses[prev_cmd].conflicts(curr_accesses):
+ is_dependency = True
+
+ if is_dependency:
+ new_offset = cmd_ends[prev_cmd][prev_cmd.cmdtype]
+ if new_offset[0] > dep_offsets[prev_cmd.cmdtype][0]:
+ dep_cmds[prev_cmd.cmdtype] = prev_cmd
+ dep_offsets[prev_cmd.cmdtype] = new_offset
+
+ # Check if we've got dependencies for all commands, in which case we can early out
+ for dep in dep_cmds:
+ if dep is None:
+ break
+ else:
+ break # all handled
+
+ # Convert absolute to relative dependencies, using None to signal the special case of no
+ # dependency of this kind
+ res = [None] * CommandType.Size.value
+ for i in range(CommandType.Size.value):
+ if dep_cmds[i] is not None:
+ res[i] = cmd_starts[cmd][i] - dep_offsets[i]
+
+ dependencies[cmd] = cmd_starts[cmd], res
+
+ return dependencies
+
+
+def get_op_kernel(ps):
+ if ps.primary_op is None:
+ return None
+
+ strides = ps.primary_op.attrs.get("strides", (1, 1, 1, 1))
+ dilation = ps.primary_op.attrs.get("dilation", (1, 1, 1, 1))
+ if ps.weight_tensor:
+ if ps.npu_block_type in set((NpuBlockType.VectorProduct, NpuBlockType.ElementWise)):
+ k_h = 1
+ k_w = 1
+ else:
+ k_h = ps.weight_tensor.shape[0]
+ k_w = ps.weight_tensor.shape[1]
+ else:
+ k_h = ps.primary_op.attrs.get("filter_height", 1)
+ k_w = ps.primary_op.attrs.get("filter_width", 1)
+
+ return Kernel(k_w, k_h, strides[2], strides[1], dilation[2], dilation[1])
+
+
+def full_shape(shape, fill):
+ return ([fill] * (4 - len(shape))) + shape
+
+
+def has_prev_op_dependency(prev_cmd, cmd):
+ if prev_cmd is None:
+ return False
+ if (prev_cmd.cmdtype == cmd.cmdtype == CommandType.NpuStripe) and (prev_cmd.ps != cmd.ps):
+ if prev_cmd.ofm_tensor == cmd.ifm_tensor:
+ return True
+ else:
+ return prev_cmd.ofm_tensor.equivalence_id == cmd.ifm_tensor.equivalence_id
+ return False
+
+
+def get_op_ofm_rect(cmd):
+ start = full_shape(cmd.ofm_box.start_coord, 0)
+ end = full_shape(cmd.ofm_box.end_coord, 1)
+ return Rect(start[-2], start[-3], start[-1], end[-2] - 1, end[-3] - 1, end[-1] - 1)
+
+
+def get_op_ifm_rect(cmd):
+ start = full_shape(cmd.ifm_box.start_coord, 0)
+ end = full_shape(cmd.ifm_box.end_coord, 1)
+ return Rect(start[-2], start[-3], start[-1], end[-2] - 1, end[-3] - 1, end[-1] - 1)
+
+
+def get_op_ifmofm_block_depth(arch, cmd):
+ # Note: NOT equivalent to the normal ifm block depth calculation since
+ # it takes into account 'depthless' block operations by returning full
+ # depth
+ if cmd.ps.npu_block_type in (NpuBlockType.ConvolutionDepthWise, NpuBlockType.Pooling, NpuBlockType.ElementWise):
+ return cmd.ofm_box.get_size_shape()[-1]
+
+ return arch.calc_ifm_block_depth(cmd.ifm_box.get_size_shape()[-1], cmd.ifm_tensor.dtype.bits)
+
+
+def get_op_padding_lt(cmd):
+ if cmd.ps.npu_block_type not in (
+ NpuBlockType.ConvolutionDepthWise,
+ NpuBlockType.Pooling,
+ NpuBlockType.ConvolutionMxN,
+ ):
+ return (0, 0)
+
+ explicit_padding = list(cmd.ps.primary_op.attrs["explicit_padding"]) # (top, left, bottom, right)
+
+ # Check if this is for horizontal ifm streaming
+ if not (cmd.is_first_h_stripe and cmd.is_last_h_stripe):
+ explicit_padding[0] = cmd.pad_top
+ explicit_padding[2] = cmd.pad_bottom
+
+ return (explicit_padding[1], explicit_padding[0])
+
+
+def generate_register_command_stream(nng, sg, arch, verbose=False):
+ emit = CommandStreamEmitter()
+
+ base_ptr_idx_map = {
+ MemArea.Sram: BasePointerIndex.Scratch,
+ MemArea.OnChipFlash: BasePointerIndex.ReadOnly,
+ MemArea.OffChipFlash: BasePointerIndex.ReadOnly,
+ MemArea.Dram: BasePointerIndex.ReadOnly,
+ }
+
+ # Maps an AccumulatorType enum to the corresponding acc_format value
+ acc_format_map = {
+ SHRAMElements.Acc16: acc_format.FP_S5_10.value,
+ SHRAMElements.Acc32: acc_format.INT_32BIT.value,
+ SHRAMElements.Acc40: acc_format.INT_40BIT.value,
+ }
+
+ # Maps an elementwise op type to an elementwise_mode enum value used by NPU_OP_ELEMENTWISE
+ elementwise_mode_map = {
+ "MulAct": elementwise_mode.MUL.value,
+ "AddAct": elementwise_mode.ADD.value,
+ "SubAct": elementwise_mode.SUB.value,
+ "Minimum": elementwise_mode.MIN.value,
+ "Maximum": elementwise_mode.MAX.value,
+ "LeakyRelu": elementwise_mode.LRELU.value,
+ "Abs": elementwise_mode.ABS.value,
+ }
+
+ cmd_stream = []
+ for cmd in sg.high_level_command_stream:
+ if cmd.cmdtype == CommandType.NpuStripe and cmd.ps.npu_block_type == NpuBlockType.Default:
+ print("Warning: Skipping register command stream generation for", cmd.ps)
+ else:
+ cmd_stream.append(cmd)
+
+ dependencies = calc_command_dependencies(cmd_stream, arch)
+
+ # Initialise operator dependency state
+ prev_ifm_rect = cur_ifm_rect = None
+ prev_ifm_block_depth = cur_ifm_block_depth = None
+ prev_ofm_rect = cur_ofm_rect = None
+ prev_ofm_block = cur_ofm_block = None
+ prev_kernel = cur_kernel = None
+ prev_cmd = None
+
+ def emit_wait_commands(cmd):
+ # The command is fully set up, emit whatever wait commands we need
+ absolute_dep, relative_dep = dependencies[cmd]
+ if relative_dep[CommandType.NpuStripe] is not None:
+ if cmd.cmdtype == CommandType.DMA:
+ param = relative_dep[CommandType.NpuStripe][1]
+ if param <= 3:
+ emit.cmd_wait(cmd0.NPU_OP_KERNEL_WAIT, param, absolute_dep[CommandType.NpuStripe][1])
+ else:
+ param = relative_dep[CommandType.NpuStripe][0]
+ param = min(param, 0xFFFF) # Clamp to allowable wait amount
+
+ if relative_dep[CommandType.DMA] is not None:
+ param = relative_dep[CommandType.DMA][0]
+ param = min(param, 0xF) # Clamp to allowable wait amount
+ emit.cmd_wait(cmd0.NPU_OP_DMA_WAIT, param, absolute_dep[CommandType.DMA][0])
+ prev_cmd = None # Clear any dependency
+
+ # Start by issuing REGION commands since they remain the same
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_REGION, BasePointerIndex.Scratch)
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM2_REGION, BasePointerIndex.Scratch)
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_REGION, BasePointerIndex.Scratch)
+ for cmd in cmd_stream:
+ if cmd.cmdtype == CommandType.DMA:
+ start_coord = cmd.box.start_coord
+
+ src_addr = cmd.in_tensor.address_for_coordinate(start_coord)
+ dst_addr = cmd.out_tensor.address_for_coordinate(start_coord)
+
+ if cmd.in_tensor.compressed_values is not None:
+ stream_index = cmd.in_tensor.compressed_stream_index_from_coord(start_coord)
+ sz = cmd.in_tensor.size_of_compressed_stream(stream_index)
+ else:
+ sz = cmd.in_tensor.address_for_coordinate(cmd.box.end_coord, is_top_box=True) - src_addr
+
+ # TODO: Yoda support needs to use feature_maps_not_in_fast_storage and force_outputs_to_fast_storage
+ emit.cmd0_with_param(cmd0.NPU_SET_DMA0_SRC_REGION, base_ptr_idx_map[cmd.in_tensor.mem_area])
+ emit.cmd1_with_offset(cmd1.NPU_SET_DMA0_SRC, src_addr)
+ emit.cmd0_with_param(cmd0.NPU_SET_DMA0_DST_REGION, base_ptr_idx_map[cmd.out_tensor.mem_area])
+ emit.cmd1_with_offset(cmd1.NPU_SET_DMA0_DST, dst_addr)
+ emit.cmd1_with_offset(cmd1.NPU_SET_DMA0_LEN, sz)
+ dma_channel = 0
+ mode = 0 # From external to external
+
+ emit_wait_commands(cmd)
+ emit.cmd_do_operation(cmd0.NPU_OP_DMA_START, dma_channel * 16 + mode)
+
+ elif cmd.cmdtype == CommandType.NpuStripe:
+
+ ps = cmd.ps
+ primary_op = ps.primary_op
+ npu_block_type = ps.npu_block_type
+ # Specifies if global scale from the NPU_SET_OFM_SCALE register should be used instead of per-channel scale
+ use_global_scale = False
+ # Specifies type of rounding to be used.
+ rounding_mode = rounding.TFL
+ fmf = primary_op.attrs.get("fused_memory_function", None)
+ faf = primary_op.attrs.get("fused_activation_function", None)
+
+ # Specifies which operand to apply scaling to in bitexact elementwise ADD/SUB
+ op_to_scale = 0
+
+ # Update state history
+ prev_ifm_rect = cur_ifm_rect
+ prev_ifm_block_depth = cur_ifm_block_depth
+ prev_ofm_rect = cur_ofm_rect
+ prev_ofm_block = cur_ofm_block
+ prev_kernel = cur_kernel
+
+ block_config = ps.block_config
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_BLK_HEIGHT_M1, block_config[0] - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_BLK_WIDTH_M1, block_config[1] - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_BLK_DEPTH_M1, block_config[3] - 1)
+
+ shared_buffer = ps.shared_buffer
+
+ if npu_block_type == NpuBlockType.ElementWise:
+ ifm2_broadcast = 0
+
+ if cmd.ifm_tensor.shape == []:
+ # The scalar has to be the ifm2 tensor so switch the ifms
+ cmd.ifm_tensor, cmd.ifm2_tensor = cmd.ifm2_tensor, cmd.ifm_tensor
+ cmd.ifm_box, cmd.ifm2_box = cmd.ifm2_box, cmd.ifm_box
+
+ # Set ReverseOperandOrder bit to IFM2_BROADCAST
+ ifm2_broadcast |= IFM2Broadcast.ReverseOperandOrder
+
+ # Calculate scales needed for arithmetic elementwise operators
+ if primary_op.type in set(("AddAct", "MulAct", "SubAct",)):
+ input_scale = cmd.ifm_tensor.quantization.scale_f32
+ input2_scale = cmd.ifm2_tensor.quantization.scale_f32
+ output_scale = cmd.ofm_tensor.quantization.scale_f32
+ use_global_scale = True
+
+ if primary_op.type == "MulAct":
+ if (faf == "Sigmoid") or (faf == "Tanh"):
+ output_scale = 1 / 0x3000
+
+ ofm_scale, shift = scaling.elementwise_mul_scale(input_scale, input2_scale, output_scale)
+ emit.cmd1_with_offset(cmd1.NPU_SET_OFM_SCALE, ofm_scale, shift)
+ else: # AddAct/SubAct
+ if (faf == "Sigmoid") or (faf == "Tanh"):
+ output_scale = 1 / 0x3000
+
+ if input_scale == input2_scale:
+ opa_scale, opb_scale, ofm_scale, shift = scaling.simplified_elementwise_add_sub_scale(
+ input_scale, input2_scale, output_scale
+ )
+ opa_shift = 0 # Unused for this case
+ else:
+ # Use advanced implementation only when input scales differ
+ bitdepth = cmd.ifm_tensor.dtype.bits
+ (
+ opa_scale,
+ opa_shift,
+ ofm_scale,
+ shift,
+ op_to_scale,
+ ) = scaling.advanced_elementwise_add_sub_scale(
+ input_scale, input2_scale, output_scale, bitdepth
+ )
+ opb_scale = 0 # Unused for this case
+ if ifm2_broadcast & IFM2Broadcast.ReverseOperandOrder:
+ # If the operand order is reversed we also have to swap which operand is scaled
+ if op_to_scale == scaling.OperandToScale.OPa:
+ op_to_scale = scaling.OperandToScale.OPb
+ else:
+ op_to_scale = scaling.OperandToScale.OPa
+
+ emit.cmd1_with_offset(cmd1.NPU_SET_OPA_SCALE, opa_scale, opa_shift)
+ emit.cmd1_with_offset(cmd1.NPU_SET_OPB_SCALE, opb_scale)
+ emit.cmd1_with_offset(cmd1.NPU_SET_OFM_SCALE, ofm_scale, shift)
+
+ if primary_op.type in set(("LeakyRelu", "Abs",)):
+ output_scale = cmd.ofm_tensor.quantization.scale_f32
+ use_global_scale = True
+
+ if primary_op.type == "LeakyRelu":
+ output_scale *= primary_op.attrs["alpha"]
+
+ ofm_scale, shift = scaling.quantise_scale(output_scale)
+ emit.cmd1_with_offset(cmd1.NPU_SET_OFM_SCALE, ofm_scale, shift)
+
+ # For elementwise set the required SHRAM to be equal to the total size of SHRAM
+ shram_required = arch.shram_total_banks
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_IB_END, shram_required)
+
+ # Acc buffers not needed so set AB_START to size of SHRAM
+ emit.cmd0_with_param(cmd0.NPU_SET_AB_START, arch.shram_total_banks)
+
+ # Is not a unary operator
+ if cmd.ifm2_tensor is not None:
+ if cmd.ifm2_tensor.shape == []:
+ # IFM2 is a constant, set UseIFM2Scalar bit to IFM2_BROADCAST
+ ifm2_broadcast |= IFM2Broadcast.UseIFM2Scalar
+ else:
+ ifm_box_shape = cmd.ifm_box.get_size_shape()
+ ifm2_box_shape = cmd.ifm2_box.get_size_shape()
+
+ if len(cmd.ifm_tensor.shape) > 1 and ifm_box_shape[1] != ifm2_box_shape[1]:
+ # Broadcast in 'H' dimension
+ assert cmd.ifm2_tensor.shape[1] == 1
+ ifm2_broadcast |= IFM2Broadcast.BroadcastHdim
+
+ if len(cmd.ifm_tensor.shape) > 2 and ifm_box_shape[2] != ifm2_box_shape[2]:
+ # Broadcast in 'W' dimension
+ assert cmd.ifm2_tensor.shape[2] == 1
+ ifm2_broadcast |= IFM2Broadcast.BroadcastWdim
+
+ if len(cmd.ifm_tensor.shape) > 3 and ifm_box_shape[3] != ifm2_box_shape[3]:
+ # Broadcast in 'C' dimension
+ assert cmd.ifm2_tensor.shape[3] == 1
+ ifm2_broadcast |= IFM2Broadcast.BroadcastCdim
+
+ # Set IFM2_IB_START to the latter half of the IB space
+ ifm_ib_start = shared_buffer.bank_locations[SharedBufferArea.IFM]
+ emit.cmd0_with_param(
+ cmd0.NPU_SET_IFM2_IB_START, (shram_required - ifm_ib_start) / 2 + ifm_ib_start
+ )
+
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM2_BROADCAST, ifm2_broadcast)
+
+ else:
+ emit.cmd0_with_param(
+ cmd0.NPU_SET_IFM_IB_END,
+ shared_buffer.bank_locations[SharedBufferArea.IFM]
+ + shared_buffer.banks_required[SharedBufferArea.IFM],
+ )
+ emit.cmd0_with_param(cmd0.NPU_SET_AB_START, shared_buffer.bank_locations[SharedBufferArea.Accumulators])
+
+ emit.cmd0_with_param(cmd0.NPU_SET_ACC_FORMAT, acc_format_map[shared_buffer.use_accumulator_element])
+
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_UPSCALE, 0)
+
+ if npu_block_type in set(
+ (NpuBlockType.ConvolutionMxN, NpuBlockType.ConvolutionDepthWise, NpuBlockType.Pooling)
+ ):
+ # Set up padding
+ explicit_padding = list(primary_op.attrs["explicit_padding"]) # (top, left, bottom, right)
+
+ # Check if this is for horizontal ifm streaming
+ if not (cmd.is_first_h_stripe and cmd.is_last_h_stripe):
+ explicit_padding[0] = cmd.pad_top
+ explicit_padding[2] = cmd.pad_bottom
+
+ # Indexing from end since a 1x1 Avgpool might have been added with non 4-dimensional input/output,
+ # because of activation function needed to be fused.
+ if cmd.ifm_box.start_coord[-2] > 0:
+ explicit_padding[1] = 0
+ if cmd.ifm_box.end_coord[-2] < cmd.ifm_tensor.shape[-2]:
+ explicit_padding[3] = 0
+
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_PAD_TOP, explicit_padding[0])
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_PAD_LEFT, explicit_padding[1])
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_PAD_BOTTOM, explicit_padding[2])
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_PAD_RIGHT, explicit_padding[3])
+
+ stride = primary_op.attrs["strides"][2] - 1
+ stride |= (primary_op.attrs["strides"][1] - 1) << 1
+
+ if npu_block_type == NpuBlockType.Pooling:
+ k_height, k_width = primary_op.attrs["ksize"][1:3]
+ emit.cmd0_with_param(cmd0.NPU_SET_KERNEL_HEIGHT_M1, k_height - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_KERNEL_WIDTH_M1, k_width - 1)
+
+ valid_padding = sum(explicit_padding) == 0
+
+ if primary_op.type in set(("AvgPool", "AvgPoolAct")) and valid_padding:
+ # For valid padding vela has to output scaling values
+ if faf == "Sigmoid" or faf == "Tanh":
+ rescale = 0x3000 * cmd.ifm_tensor.quantization.scale_f32
+ rescale_bits = len(bin(round_up_to_int(rescale))) - 2 + 1
+
+ scale, shift = scaling.quantise_pooling_scale(k_height * k_width, rescale_bits)
+ scale = int(round_away_zero(scale * rescale))
+ else:
+ # In case avg pool fused with concat or other memory operation, rescaling might be needed.
+ # k_height == k_width == 1 is allways true in this case
+ # Normally the scale is maximised, to get maximum precision, which means that
+ # if rescale != 1, scale need to consider the number of bits needed for rescaling
+ rescale = cmd.ifm_tensor.quantization.scale_f32 / cmd.ofm_tensor.quantization.scale_f32
+ rescale_bits = 0
+ if k_height == k_width == 1:
+ if fmf == "ConcatSliceWrite":
+ rounding_mode = rounding.NATURAL
+ if rescale > 1:
+ rescale_bits = len(bin(round_up_to_int(rescale))) - 2 + 1
+ elif rescale < 1:
+ rescale_bits = -(len(bin(round_up_to_int(1 / rescale))) - 2 - 1)
+ scale, shift = scaling.quantise_pooling_scale(k_height * k_width, rescale_bits)
+ scale = int(round_away_zero(scale * rescale))
+
+ emit.cmd1_with_offset(cmd1.NPU_SET_OFM_SCALE, scale, shift)
+ # Valid-padded average pool should use the global scale from
+ # NPU_SET_OFM_SCALE register, which is set above.
+ use_global_scale = True
+
+ else: # Convolution
+ assert cmd.weight_tensor.block_traversal != TensorBlockTraversal.Default
+ emit.cmd0_with_param(cmd0.NPU_SET_KERNEL_HEIGHT_M1, cmd.weight_tensor.shape[0] - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_KERNEL_WIDTH_M1, cmd.weight_tensor.shape[1] - 1)
+ if cmd.weight_tensor.block_traversal == TensorBlockTraversal.PartKernelFirst:
+ # Part-kernel-first weight ordering
+ assert npu_block_type == NpuBlockType.ConvolutionMxN
+ stride |= 1 << 2
+
+ emit.cmd0_with_param(cmd0.NPU_SET_KERNEL_STRIDE, stride)
+
+ elif npu_block_type in set((NpuBlockType.VectorProduct,)):
+ # Vector product is implemented using a 1x1 convolution so need
+ # to setup the appropriate padding and kernel info
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_PAD_TOP, 0)
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_PAD_LEFT, 0)
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_PAD_BOTTOM, 0)
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_PAD_RIGHT, 0)
+
+ # kernel stride reg = 0 means stride(1,1) + depth first weight
+ # order + dilation(0,0) + kernel_split_size=8
+ emit.cmd0_with_param(cmd0.NPU_SET_KERNEL_STRIDE, 0)
+
+ emit.cmd0_with_param(cmd0.NPU_SET_KERNEL_HEIGHT_M1, 0)
+ emit.cmd0_with_param(cmd0.NPU_SET_KERNEL_WIDTH_M1, 0)
+
+ if npu_block_type in set(
+ (NpuBlockType.ConvolutionMxN, NpuBlockType.ConvolutionDepthWise, NpuBlockType.VectorProduct)
+ ):
+ # Emit Weight base address commands, only maps the area required for
+ # this command's weights from the larger tensor.
+ stream_index = cmd.weight_tensor.compressed_stream_index_from_coord(cmd.weight_box.start_coord)
+ weight_addr = cmd.weight_tensor.address_for_coordinate(cmd.weight_box.start_coord)
+ weight_len = cmd.weight_tensor.size_of_compressed_stream(stream_index)
+ # Select weight/scale region depending on where permanent storage was defined
+ weight_region = base_ptr_idx_map[cmd.weight_tensor.mem_area]
+ if arch.permanent_storage_mem_area == MemArea.Sram:
+ weight_region = BasePointerIndex.ReadOnly
+ emit.cmd0_with_param(cmd0.NPU_SET_WEIGHT_REGION, weight_region)
+ emit.cmd1_with_offset(cmd1.NPU_SET_WEIGHT_BASE, weight_addr)
+ emit.cmd1_with_offset(cmd1.NPU_SET_WEIGHT_LENGTH, weight_len)
+
+ # Emit Scale & Bias base address commands, with length matching the amount required by
+ # the weight tensors.
+ if cmd.scale_tensor is not None:
+ # Get address and size of the scale/bias data area
+ scale_addr = cmd.scale_tensor.address_for_coordinate(cmd.weight_box.start_coord[-1:])
+ scale_len = (
+ cmd.scale_tensor.address_for_coordinate(cmd.weight_box.end_coord[-1:], True) - scale_addr
+ )
+ # Emit base address for NPU to access scale & bias data
+ scale_region = base_ptr_idx_map[cmd.scale_tensor.mem_area]
+ if arch.permanent_storage_mem_area == MemArea.Sram:
+ scale_region = BasePointerIndex.ReadOnly
+ emit.cmd0_with_param(cmd0.NPU_SET_SCALE_REGION, scale_region)
+ emit.cmd1_with_offset(cmd1.NPU_SET_SCALE_BASE, scale_addr)
+ emit.cmd1_with_offset(cmd1.NPU_SET_SCALE_LENGTH, round_up(scale_len, 16))
+
+ ofm_quant = cmd.ofm_tensor.quantization
+ ofm_quant_qmin = cmd.ofm_tensor.quantization.quant_min
+ ofm_quant_qmax = cmd.ofm_tensor.quantization.quant_max
+ ifm_min = cmd.ifm_tensor.quantization.min
+ ifm_max = cmd.ifm_tensor.quantization.max
+
+ # Emit commands for any fused activation function
+ if faf == None:
+ emit.cmd0_with_param(cmd0.NPU_SET_ACTIVATION, activation.NONE)
+ # Even if no activation function, values need to be set to override previous values
+ faf_min = ofm_quant_qmin
+ faf_max = ofm_quant_qmax
+ elif faf == "Relu":
+ emit.cmd0_with_param(cmd0.NPU_SET_ACTIVATION, activation.NONE)
+ faf_min = quantise_float32(0.0, ofm_quant.scale_f32, ofm_quant.zero_point)
+ faf_max = ofm_quant_qmax
+ elif faf == "Relu6":
+ emit.cmd0_with_param(cmd0.NPU_SET_ACTIVATION, activation.NONE)
+ faf_min = quantise_float32(0.0, ofm_quant.scale_f32, ofm_quant.zero_point)
+ faf_max = quantise_float32(6.0, ofm_quant.scale_f32, ofm_quant.zero_point)
+ elif faf == "ReluN1To1":
+ emit.cmd0_with_param(cmd0.NPU_SET_ACTIVATION, activation.NONE)
+ faf_min = quantise_float32(-1.0, ofm_quant.scale_f32, ofm_quant.zero_point)
+ faf_max = quantise_float32(1.0, ofm_quant.scale_f32, ofm_quant.zero_point)
+ elif faf == "Tanh":
+ emit.cmd0_with_param(cmd0.NPU_SET_ACTIVATION, activation.TANH)
+ faf_min = quantise_float32(clamp_tanh(ifm_min), ofm_quant.scale_f32, ofm_quant.zero_point)
+ faf_max = quantise_float32(clamp_tanh(ifm_max), ofm_quant.scale_f32, ofm_quant.zero_point)
+ elif faf == "Sigmoid":
+ emit.cmd0_with_param(cmd0.NPU_SET_ACTIVATION, activation.SIGMOID)
+ faf_min = quantise_float32(clamp_sigmoid(ifm_min), ofm_quant.scale_f32, ofm_quant.zero_point)
+ faf_max = quantise_float32(clamp_sigmoid(ifm_max), ofm_quant.scale_f32, ofm_quant.zero_point)
+ else:
+ raise Exception("Unsupported fused_activation_function = " + faf)
+
+ # Activation range needs to be set based upon the quantisation range and the fused activation range
+ emit.cmd0_with_param(cmd0.NPU_SET_ACTIVATION_MIN, max(ofm_quant_qmin, faf_min))
+ emit.cmd0_with_param(cmd0.NPU_SET_ACTIVATION_MAX, min(ofm_quant_qmax, faf_max))
+
+ out_shape = cmd.ofm_box.get_size_shape()
+ if len(out_shape) >= 4:
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_HEIGHT_M1, out_shape[-3] - 1)
+ else:
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_HEIGHT_M1, 0)
+ if len(out_shape) >= 2:
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_WIDTH_M1, out_shape[-2] - 1)
+ else:
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_WIDTH_M1, 0)
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_DEPTH_M1, out_shape[-1] - 1)
+
+ if npu_block_type in set((NpuBlockType.ConvolutionMxN, NpuBlockType.VectorProduct)):
+ in_shape = cmd.ifm_box.get_size_shape()
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_DEPTH_M1, in_shape[-1] - 1)
+ else:
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_DEPTH_M1, out_shape[-1] - 1)
+
+ for tens, box, ptr_ops, stride_ops, zero_point_op in (
+ (
+ cmd.ifm_tensor,
+ cmd.ifm_box,
+ (cmd1.NPU_SET_IFM_BASE0, cmd1.NPU_SET_IFM_BASE1, cmd1.NPU_SET_IFM_BASE2, cmd1.NPU_SET_IFM_BASE3),
+ (cmd1.NPU_SET_IFM_STRIDE_C, cmd1.NPU_SET_IFM_STRIDE_Y, cmd1.NPU_SET_IFM_STRIDE_X),
+ cmd0.NPU_SET_IFM_ZERO_POINT,
+ ),
+ (
+ cmd.ifm2_tensor,
+ cmd.ifm2_box,
+ (
+ cmd1.NPU_SET_IFM2_BASE0,
+ cmd1.NPU_SET_IFM2_BASE1,
+ cmd1.NPU_SET_IFM2_BASE2,
+ cmd1.NPU_SET_IFM2_BASE3,
+ ),
+ (cmd1.NPU_SET_IFM2_STRIDE_C, cmd1.NPU_SET_IFM2_STRIDE_Y, cmd1.NPU_SET_IFM2_STRIDE_X),
+ cmd0.NPU_SET_IFM2_ZERO_POINT,
+ ),
+ (
+ cmd.ofm_tensor,
+ cmd.ofm_box,
+ (cmd1.NPU_SET_OFM_BASE0, cmd1.NPU_SET_OFM_BASE1, cmd1.NPU_SET_OFM_BASE2, cmd1.NPU_SET_OFM_BASE3),
+ (cmd1.NPU_SET_OFM_STRIDE_C, cmd1.NPU_SET_OFM_STRIDE_Y, cmd1.NPU_SET_OFM_STRIDE_X),
+ cmd0.NPU_SET_OFM_ZERO_POINT,
+ ),
+ ):
+
+ if tens == None:
+ continue
+
+ need_zero_point = (faf != None) or (fmf == "ConcatSliceWrite")
+ if (
+ primary_op.type in set(("AvgPool", "AvgPoolAct")) and not need_zero_point
+ ) or tens.quantization == None:
+ # Actual integer operation, just set scale to 1 and zero point to 0
+ emit.cmd0_with_param(zero_point_op, 0)
+ else:
+ assert tens.quantization.zero_point is not None, "need an actual zero point set"
+ emit.cmd0_with_param(zero_point_op, int(tens.quantization.zero_point))
+
+ if tens.shape == []:
+ # Empty shape, elementwise constant
+ ifm2_scalar = tens.quant_values.astype(np.uint8)
+ assert ifm2_scalar.size == 1
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM2_SCALAR, ifm2_scalar.item(0))
+ continue
+
+ height_0, height_1, width_0, addresses = tens.addresses_for_rolling_buffer(
+ box.start_coord, box.end_coord
+ )
+ if npu_block_type != NpuBlockType.VectorProduct:
+ if tens == cmd.ifm_tensor:
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_HEIGHT0_M1, height_0 - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_HEIGHT1_M1, height_1 - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_WIDTH0_M1, width_0 - 1)
+ elif tens == cmd.ofm_tensor:
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_HEIGHT0_M1, height_0 - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_HEIGHT1_M1, height_1 - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_WIDTH0_M1, width_0 - 1)
+ elif tens == cmd.ifm2_tensor:
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM2_HEIGHT0_M1, height_0 - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM2_HEIGHT1_M1, height_1 - 1)
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM2_WIDTH0_M1, width_0 - 1)
+ else:
+ if len(out_shape) == 2:
+ # TODO: N is put in W-dimension for now
+ # Should be spread over H and W, but then block size selectetion,
+ # and stride calculation should be changed
+ if tens == cmd.ifm_tensor:
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_WIDTH0_M1, out_shape[-2] - 1)
+ elif tens == cmd.ofm_tensor:
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_WIDTH0_M1, out_shape[-2] - 1)
+ else:
+ assert False
+
+ for idx, addr in enumerate(addresses):
+ if addr is None:
+ addresses[idx] = 0
+
+ emit.cmd1_with_offset(ptr_ops[0], addresses[0])
+ emit.cmd1_with_offset(ptr_ops[1], addresses[1])
+ emit.cmd1_with_offset(ptr_ops[2], addresses[2])
+ emit.cmd1_with_offset(ptr_ops[3], addresses[3])
+
+ strides = tens.get_strides()
+ emit.cmd1_with_offset(stride_ops[0], strides[1]) # stride between 16-byte channel blocks (C)
+ emit.cmd1_with_offset(stride_ops[2], strides[3]) # stride between horisontal values (W)
+ emit.cmd1_with_offset(stride_ops[1], strides[2]) # stride between vertical values (H)
+
+ if tens.format == TensorFormat.NHCWB16:
+ # Check that all BasePointer addresses are aligned to 16 bytes
+ assert (int(addresses[0]) % 16) == 0
+ assert (int(addresses[1]) % 16) == 0
+ assert (int(addresses[2]) % 16) == 0
+ assert (int(addresses[3]) % 16) == 0
+
+ ofm_dtype = cmd.ofm_tensor.dtype
+ assert ofm_dtype.type & BaseType.Int
+ prec = 0
+ if ofm_dtype.size_in_bits() == 8:
+ prec = 0
+ elif ofm_dtype.size_in_bits() == 16:
+ prec = 2
+ else:
+ assert 0
+
+ if ofm_dtype.type & BaseType.Signed:
+ prec += 1
+
+ if use_global_scale:
+ # Set global scale bit, as opposed to using per channel scale
+ prec |= 1 << 8
+
+ if cmd.ofm_tensor.format == TensorFormat.NHCWB16:
+ prec |= 1 << 6
+
+ prec |= rounding_mode.value << 14
+
+ emit.cmd0_with_param(cmd0.NPU_SET_OFM_PRECISION, prec)
+
+ prec = None
+ weight_bits = 8
+ if cmd.weight_tensor is not None:
+ weight_bits = cmd.weight_tensor.dtype.size_in_bits()
+
+ ifm_dtype = cmd.ifm_tensor.dtype
+
+ assert weight_bits == 8, "Unsupported weight bit depth"
+ assert ifm_dtype.size_in_bits() in {8, 16}
+
+ if ifm_dtype.size_in_bits() == 8:
+ if ifm_dtype.type & BaseType.Signed:
+ prec = ifm_precision.W8_S8
+ else:
+ prec = ifm_precision.W8_U8
+ elif ifm_dtype.size_in_bits() == 16:
+ if ifm_dtype.type & BaseType.Signed:
+ prec = ifm_precision.W8_S16
+ else:
+ prec = ifm_precision.W8_U16
+
+ ifm_prec = prec.value
+ ifm2_prec = ifm_prec
+
+ if cmd.ifm_tensor.format == TensorFormat.NHCWB16:
+ ifm_prec |= 1 << 6
+
+ ifm_prec |= op_to_scale << 8
+
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM_PRECISION, ifm_prec)
+
+ if cmd.ifm2_tensor is not None:
+ if cmd.ifm2_tensor.format == TensorFormat.NHCWB16:
+ ifm2_prec |= 1 << 6
+ emit.cmd0_with_param(cmd0.NPU_SET_IFM2_PRECISION, ifm2_prec)
+
+ emit_wait_commands(cmd)
+
+ # Get op parameters
+ cur_ifm_block_depth = get_op_ifmofm_block_depth(arch, cmd)
+ cur_ofm_block = Block(ps.block_config[1], ps.block_config[0], ps.block_config[3])
+ cur_ofm_rect = get_op_ofm_rect(cmd)
+ cur_ifm_rect = get_op_ifm_rect(cmd)
+ cur_kernel = get_op_kernel(cmd.ps)
+ cur_padLT = get_op_padding_lt(cmd)
+ if (prev_kernel is not None) and (cur_kernel is not None) and has_prev_op_dependency(prev_cmd, cmd):
+ if cmd.ifm_tensor.shape == prev_cmd.ofm_tensor.shape:
+ blockdep = arch.calc_block_dep(
+ prev_ifm_rect,
+ prev_ofm_rect,
+ prev_ifm_block_depth,
+ prev_ofm_block,
+ prev_kernel,
+ cur_ifm_rect,
+ cur_ofm_rect,
+ cur_ifm_block_depth,
+ cur_ofm_block,
+ cur_kernel,
+ cur_padLT,
+ )
+ else:
+ blockdep = 0
+ else:
+ blockdep = ArchitectureFeatures.MAX_BLOCKDEP
+
+ # Set between every op (dependent or not)
+ blockdep = min(blockdep, arch.max_blockdep)
+ emit.cmd0_with_param(cmd0.NPU_SET_BLOCKDEP, blockdep)
+ prev_cmd = cmd
+
+ if npu_block_type == NpuBlockType.ConvolutionMxN:
+ emit.cmd_do_operation(cmd0.NPU_OP_CONV)
+ elif npu_block_type == NpuBlockType.ConvolutionDepthWise:
+ emit.cmd_do_operation(cmd0.NPU_OP_DEPTHWISE)
+ elif npu_block_type == NpuBlockType.VectorProduct:
+ # Vector product is implemented using a 1x1 convolution
+ emit.cmd_do_operation(cmd0.NPU_OP_CONV)
+ elif npu_block_type == NpuBlockType.Pooling:
+ param = "Max" not in primary_op.type
+ emit.cmd_do_operation(cmd0.NPU_OP_POOL, param=param)
+ elif npu_block_type == NpuBlockType.ElementWise:
+ param = elementwise_mode_map[primary_op.type]
+ emit.cmd_do_operation(cmd0.NPU_OP_ELEMENTWISE, param)
+ else:
+ print("Warning: Skipping register command stream generation for", ps)
+
+ # Fill in final part of command stream:
+ emit.cmd_do_operation(cmd0.NPU_OP_STOP, param=0xFFFF)
+
+ sg.register_command_stream = emit.to_list()
+ if verbose:
+ emit.print_cmds()
+ print("number of commands", len(emit.cmd_stream))
+ print("command stream length in words", len(sg.register_command_stream))
diff --git a/ethosu/vela/rewrite_graph.py b/ethosu/vela/rewrite_graph.py
new file mode 100644
index 0000000..e6e24e6
--- /dev/null
+++ b/ethosu/vela/rewrite_graph.py
@@ -0,0 +1,171 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Functions for abstracting out the traversal and rewriting of graphs so that the optimisation passes can focus on the
+# correct operation.
+#
+# Requires two lists, one of functions that rewrite Tensors, and one of functions that rewrite Operations.
+#
+# Pre-order traversal, this supports rewrites. Therefore, functions can return something other than the original value.
+#
+# Post-order traversal, this does not support rewrites. Therefore, functions must return the original value.
+
+
+def rewrite_graph_pre_order(sg, arch, tensor_rewrite_list, op_rewrite_list, rewrite_unsupported=True):
+
+ op_visit_dict = dict()
+ tens_visit_dict = dict()
+
+ def visit_op(op):
+ if op in op_visit_dict:
+ return op_visit_dict[op]
+ res = op
+ prev_res = None
+ while prev_res != res:
+ prev_res = res
+ for rewrite in op_rewrite_list:
+ if res.run_on_npu or rewrite_unsupported:
+ res = rewrite(res, arch)
+
+ op_visit_dict[op] = res
+ op_visit_dict[res] = res
+
+ inputs = res.inputs
+ res.inputs = []
+ for tens in inputs:
+ res.inputs.append(visit_tens(tens))
+
+ outputs = res.outputs
+ res.outputs = []
+ for tens in outputs:
+ res.outputs.append(visit_tens(tens))
+
+ return res
+
+ def visit_tens(tens):
+ if tens in tens_visit_dict:
+ return tens_visit_dict[tens]
+
+ res = tens
+ prev_res = None
+ while prev_res != res:
+ prev_res = res
+ for rewrite in tensor_rewrite_list:
+ res = rewrite(res, arch)
+
+ tens_visit_dict[tens] = res
+ tens_visit_dict[res] = res
+
+ ops = res.ops
+ res.ops = []
+ for op in ops:
+ res.ops.append(visit_op(op))
+ return res
+
+ sg.output_tensors = [visit_tens(tens) for tens in sg.output_tensors]
+ sg.refresh_after_modification()
+
+ return sg
+
+
+def visit_graph_post_order(sg, arch, tensor_visit_list, op_visit_list):
+
+ op_visit_dict = dict()
+ tens_visit_dict = dict()
+
+ def visit_op(op):
+ if op in op_visit_dict:
+ return op_visit_dict[op]
+ op_visit_dict[op] = op
+
+ for tens in op.inputs:
+ visit_tens(tens)
+
+ for visit in op_visit_list:
+ visit(op, arch)
+
+ for tens in op.outputs:
+ visit_tens(tens)
+
+ return op
+
+ def visit_tens(tens):
+ if tens in tens_visit_dict:
+ return tens_visit_dict[tens]
+
+ tens_visit_dict[tens] = tens
+
+ for op in tens.ops:
+ visit_op(op)
+
+ for visit in tensor_visit_list:
+ visit(tens, arch)
+
+ return tens
+
+ for tens in sg.output_tensors:
+ visit_tens(tens)
+
+ sg.refresh_after_modification()
+
+ return sg
+
+
+def verify_graph_health(nng):
+
+ for sg in nng.subgraphs:
+ verify_subgraph_health(sg)
+
+ return True
+
+
+def verify_subgraph_health(sg):
+ op_visit_dict = dict()
+ tens_visit_dict = dict()
+
+ def visit_op(op):
+ if op in op_visit_dict:
+ return op_visit_dict[op]
+ op_visit_dict[op] = op
+
+ for tens in op.inputs:
+ assert op in tens.consumers()
+ visit_tens(tens)
+
+ for tens in op.outputs:
+ assert op in tens.ops
+ visit_tens(tens)
+
+ return op
+
+ def visit_tens(tens):
+ if tens in tens_visit_dict:
+ return tens_visit_dict[tens]
+
+ tens_visit_dict[tens] = tens
+
+ for op in tens.ops:
+ assert tens in op.outputs
+ visit_op(op)
+
+ return tens
+
+ for tens in sg.output_tensors:
+ visit_tens(tens)
+
+ return True
diff --git a/ethosu/vela/scaling.py b/ethosu/vela/scaling.py
new file mode 100644
index 0000000..b255f93
--- /dev/null
+++ b/ethosu/vela/scaling.py
@@ -0,0 +1,91 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Contains various scaling calculations for weights, elementwise operations, pooling etc.
+
+import math
+from .numeric_util import round_away_zero
+from enum import IntEnum
+
+
+class OperandToScale(IntEnum):
+ OPa = 1
+ OPb = 2
+
+
+# Quantise floating point scale value into 32-bit int scale and 6-bit shift
+def quantise_scale(scale):
+ significand, exponent = math.frexp(scale)
+ significand_q31 = int(round_away_zero(significand * (1 << 31)))
+ exponent_q31 = exponent - 31
+ shift = exponent_q31 * -1
+
+ if shift >= (1 << 6):
+ # Shift outside of valid range, set scale to 0
+ return 0, 16
+
+ return significand_q31, shift
+
+
+# Calculate global OFM scale for Average Pooling
+def quantise_pooling_scale(nr_kernel_elements, rescale_bits=0):
+ _, k = math.frexp(nr_kernel_elements - 1)
+ N = 31 - rescale_bits
+ scale = ((1 << (N + k)) + (1 << k)) // nr_kernel_elements
+ shift = N + k
+
+ assert shift < (1 << 6)
+
+ return scale, shift
+
+
+# Calculate elementwise Mul OFM scale+shift
+def elementwise_mul_scale(input_scale, input2_scale, output_scale):
+ output_rescale = (input_scale * input2_scale) / output_scale
+ out_scale, out_shift = quantise_scale(output_rescale)
+ return out_scale, out_shift
+
+
+# Simplified version of calculating elementwise Add/Sub scales
+def simplified_elementwise_add_sub_scale(input1_scale, input2_scale, output_scale, input_shift=16):
+ max_input_scale = max(input1_scale, input2_scale)
+
+ input1_rescale = input1_scale * (1 << input_shift) / (2 * max_input_scale)
+ input2_rescale = input2_scale * (1 << input_shift) / (2 * max_input_scale)
+ output_rescale = (2 * max_input_scale) / (output_scale * (1 << input_shift))
+
+ out_scale, out_shift = quantise_scale(output_rescale)
+
+ return input1_rescale, input2_rescale, out_scale, out_shift
+
+
+# Advanced version of calculating elementwise Add/Sub scales
+def advanced_elementwise_add_sub_scale(input1_scale, input2_scale, output_scale, bitdepth):
+ # Always scale the smaller of the input scales
+ max_input_scale = max(input1_scale, input2_scale)
+ min_input_scale = min(input1_scale, input2_scale)
+ input_shift = 20 if bitdepth == 8 else 14
+ op_to_scale = OperandToScale.OPa if input1_scale < input2_scale else OperandToScale.OPb
+
+ input1_rescale, _, out_scale, out_shift = simplified_elementwise_add_sub_scale(
+ min_input_scale, max_input_scale, output_scale, input_shift
+ )
+
+ in_scale, in_shift = quantise_scale(input1_rescale)
+
+ return in_scale, in_shift, out_scale, out_shift, op_to_scale
diff --git a/ethosu/vela/scheduler.py b/ethosu/vela/scheduler.py
new file mode 100644
index 0000000..c35c156
--- /dev/null
+++ b/ethosu/vela/scheduler.py
@@ -0,0 +1,949 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# The scheduler costs various strategies for scheduling the network in order to select the block configuration.
+
+import enum
+from .nn_graph import (
+ TensorPurpose,
+ TensorSubPurpose,
+ TensorFormat,
+ MemArea,
+ SchedulingStrategy,
+ CascadedPass,
+ PassPlacement,
+ SchedulerRewrite,
+ Operation,
+ NpuBlockType,
+)
+from . import live_range
+import numpy as np
+from . import npu_performance
+from . import stats_writer
+from .npu_performance import make_bandwidth_array, make_macs_array, make_cycles_array, make_metrics_arrays, PassCycles
+import time, copy
+from .high_level_command_stream_generator import calc_allowed_ofm_ifm_overlap_for_pass_list
+from .shared_buffer_allocation import (
+ find_block_configs_suitable_for_pass_and_shared_buffer,
+ shared_buffer_allocation_for_pass_and_block_config,
+)
+from functools import lru_cache
+
+
+class ParetoMetric(enum.Enum):
+ BwCycMem = 1
+ BwCycMemBlkH = 2
+
+ def __str__(self):
+ return self.name
+
+
+class SchedulerOptions:
+ def __init__(
+ self,
+ use_cascading=True,
+ use_ifm_ofm_overlap=True,
+ verbose_schedule=False,
+ verbose_pareto_frontier_schedules=False,
+ use_ifm_streaming=True,
+ pareto_metric=ParetoMetric.BwCycMem,
+ ):
+ self.use_cascading = use_cascading
+ self.use_ifm_ofm_overlap = use_ifm_ofm_overlap
+ self.verbose_schedule = verbose_schedule
+ self.verbose_pareto_frontier_schedules = verbose_pareto_frontier_schedules
+ self.use_ifm_streaming = use_ifm_streaming
+ self.pareto_metric = pareto_metric
+
+ def __str__(self):
+ return type(self).__name__ + ": " + str(self.__dict__)
+
+ __repr__ = __str__
+
+
+class Strategy:
+ __slots__ = "strat", "param", "passes", "block_configs", "rewrite_list", "bws", "macs", "cycles", "sram_used"
+
+ def __init__(self, strat, param, passes, block_configs, rewrite_list, bws, macs, cycles, sram_used):
+ self.strat = strat
+ self.param = param
+ self.passes = passes
+ self.block_configs = block_configs
+ self.rewrite_list = (
+ rewrite_list # list of (SchedulerRewrite, Tensor, new sub purpose, purpose param a, purpose param b, pass)
+ )
+ self.bws = bws
+ self.macs = macs
+ self.cycles = cycles
+ self.sram_used = sram_used
+
+ def __eq__(self, other):
+ if self.strat != other.strat:
+ return False
+ if self.param != other.param:
+ return False
+ if self.block_configs != other.block_configs:
+ return False
+ if self.passes != other.passes:
+ return False
+ if (self.bws != other.bws).any():
+ return False
+ if (self.macs != other.macs).any():
+ return False
+ if (self.cycles != other.cycles).any():
+ return False
+ if self.sram_used != other.sram_used:
+ return False
+ return True
+
+ def empty(self):
+ return not self.passes
+
+ def key(self):
+ return self.passes[-1]
+
+ def clone(self):
+ return Strategy(
+ self.strat,
+ self.param,
+ self.passes,
+ self.block_configs,
+ self.rewrite_list,
+ self.bws,
+ self.macs,
+ self.cycles,
+ self.sram_used,
+ )
+
+ def __str__(self):
+ return "<scheduler.Strategy: %s %s %s %s %s %s %s>" % (
+ self.strat,
+ self.passes,
+ self.rewrite_list,
+ self.bws,
+ self.macs,
+ self.cycles,
+ self.sram_used,
+ )
+
+ __repr__ = __str__
+
+
+class StrategySet:
+ __slots__ = "strats", "bws", "macs", "cycles", "max_sram_used", "total_sram_used"
+
+ def __init__(self, strats=None):
+ if strats is None:
+ strats = dict()
+ self.strats = strats # final pass in packed pass -> Strategy
+ self.bws, self.macs, self.cycles = make_metrics_arrays()
+ self.max_sram_used = 0
+ self.total_sram_used = 0
+
+ def update_statistics(self):
+ self.bws = make_bandwidth_array()
+ self.max_sram_used = 0
+ for ps, strat in self.strats.items():
+ self.bws += strat.bws
+ self.macs += strat.macs
+ self.cycles += strat.cycles
+ self.max_sram_used = max(self.max_sram_used, strat.sram_used)
+ self.total_sram_used += strat.sram_used
+
+ def clone_add_strategy(self, new_strat):
+ key = new_strat.key()
+ if key in self.strats:
+ assert new_strat == self.strats[key]
+ return self
+ else:
+ new_strats = dict(self.strats)
+ new_strats[key] = new_strat
+ new_set = StrategySet(new_strats)
+ new_set.bws = self.bws + new_strat.bws
+ new_set.macs = self.macs + new_strat.macs
+ new_set.cycles = self.cycles + new_strat.cycles
+ new_set.max_sram_used = max(self.max_sram_used, new_strat.sram_used)
+ new_set.total_sram_used = self.total_sram_used + new_strat.sram_used
+ return new_set
+
+ def __eq__(self, other):
+ if (self.bws != other.bws).any():
+ return False
+ if (self.macs != other.macs).any():
+ return False
+ if (self.cycles != other.cycles).any():
+ return False
+ if self.max_sram_used != other.max_sram_used:
+ return False
+ if self.total_sram_used != other.total_sram_used:
+ return False
+ if self.strats != other.strats:
+ return False
+ return True
+
+ def __str__(self):
+ return "<scheduler.StrategySet: max_sram_used=%s passes_covered=%s>" % (
+ self.max_sram_used,
+ list(ps.name for ps in self.strats),
+ )
+
+ __repr__ = __str__
+
+
+empty_strategy = Strategy(
+ SchedulingStrategy.Unknown, None, [], [], [], make_bandwidth_array(), make_macs_array(), make_cycles_array(), 0
+)
+INFINITY = 1e30
+
+ABORT_SEARCH = []
+
+
+def flatten_list_of_lists(lstlst):
+ lst = []
+ for v in lstlst:
+ lst.extend(v)
+ return lst
+
+
+class DynamicProgrammingScheduler:
+ def __init__(self, nng, sg, arch, sram_limit, options: SchedulerOptions):
+ self.nng = nng
+ self.sg = sg
+ self.arch = arch
+ self.sram_limit = sram_limit
+ self.options = copy.copy(options)
+ self.use_cascading = options.use_cascading
+
+ if self.arch.feature_map_storage_mem_area != MemArea.Sram:
+ self.use_ifm_ofm_overlap = False # force off IFM/OFM overlap if IFMs and OFMs are not in the SRAM
+ self.use_ifm_ofm_overlap = options.use_ifm_ofm_overlap
+
+ self.verbose_schedule = options.verbose_schedule
+ self.verbose_pareto_frontier_schedules = options.verbose_pareto_frontier_schedules
+ self.mem_area = MemArea.Sram
+
+ self.bandwidth_weights = arch.bandwidth_weights
+ self.cycles_weight = arch.cycles_weight
+ self.max_sram_used_weight = arch.max_sram_used_weight
+
+ self.n_combinations_searched = 0
+
+ self.feature_maps_not_in_fast_storage = (
+ arch.tensor_storage_mem_area[TensorPurpose.FeatureMap] != arch.fast_storage_mem_area
+ )
+
+ self.pareto_max_candidates = 16
+
+ self.ifm_stream_npu_blocks = set(
+ (NpuBlockType.ConvolutionMxN, NpuBlockType.ConvolutionDepthWise, NpuBlockType.Pooling,)
+ )
+
+ num_pareto_metrics = 4
+ view_values = ",".join(["d"] * num_pareto_metrics)
+ order_values = ["f%d" % (idx,) for idx in range(num_pareto_metrics)]
+
+ def pareto_metric(self, candidate):
+ strat, strat_set = candidate
+ total_cycles = strat.cycles[PassCycles.Total] + strat_set.cycles[PassCycles.Total]
+ bws = strat.bws + strat_set.bws
+ last_block_height = 0
+ if self.options.pareto_metric == ParetoMetric.BwCycMemBlkH and len(strat.block_configs) > 0:
+ last_block_height = strat.block_configs[-1][0]
+
+ return (
+ np.tensordot(bws, self.bandwidth_weights, axes=3) + total_cycles * self.cycles_weight,
+ strat_set.max_sram_used,
+ strat.sram_used,
+ last_block_height,
+ )
+
+ def filter_pareto_frontier(self, candidates, remove_equally_good_candidates):
+
+ candidates = [cand for cand in candidates if max(cand[0].sram_used, cand[1].max_sram_used) <= self.sram_limit]
+
+ if len(candidates) <= 1:
+ return candidates
+ assert remove_equally_good_candidates
+ start = time.time()
+ pareto_vals = np.zeros((len(candidates), DynamicProgrammingScheduler.num_pareto_metrics))
+ ids = np.arange(len(candidates), dtype=np.int32)
+ for idx, cand in enumerate(candidates):
+ pareto_vals[idx] = self.pareto_metric(cand)
+
+ sort_order = np.argsort(
+ pareto_vals.view(DynamicProgrammingScheduler.view_values),
+ order=DynamicProgrammingScheduler.order_values,
+ axis=0,
+ kind="stable",
+ ).flatten()
+ pareto_vals = pareto_vals[sort_order]
+ ids = ids[sort_order]
+
+ pareto_frontier = []
+ while len(ids) > 0:
+ pareto_frontier.append(candidates[ids[0]])
+ not_dominated_by_first = (pareto_vals < pareto_vals[0]).any(axis=1)
+ ids = ids[not_dominated_by_first]
+ pareto_vals = pareto_vals[not_dominated_by_first]
+
+ if len(pareto_frontier) > self.pareto_max_candidates:
+ pareto_frontier = self.sort_by_candidate_metric(pareto_frontier)
+ pareto_frontier = pareto_frontier[: self.pareto_max_candidates]
+
+ return pareto_frontier
+
+ def candidate_metric(self, candidate):
+ strat, strat_set = candidate
+ max_sram_used = max(strat_set.max_sram_used, strat.sram_used)
+ bws = strat.bws + strat_set.bws
+ total_cycles = strat.cycles[PassCycles.Total] + strat_set.cycles[PassCycles.Total]
+
+ return (
+ max_sram_used * self.max_sram_used_weight
+ + np.tensordot(bws, self.bandwidth_weights, axes=3)
+ + total_cycles * self.cycles_weight
+ )
+
+ def sort_by_candidate_metric(self, candidate_list):
+ sorted_list = list(sorted(candidate_list, key=self.candidate_metric))
+ return sorted_list
+
+ def best_candidate(self, candidate_list):
+ if len(candidate_list) == 0:
+ return ABORT_SEARCH
+ if len(candidate_list) == 1:
+ return candidate_list[0]
+ sorted_list = self.sort_by_candidate_metric(candidate_list)
+ return sorted_list[0]
+
+ def graduate_strat(self, strat_type, sram_used, old_strat_data):
+ res = []
+ for old_strat, old_strat_set in old_strat_data:
+ if old_strat.sram_used + sram_used > self.sram_limit:
+ continue # This strategy is bad, drop it
+ if old_strat_set.max_sram_used > self.sram_limit:
+ continue # This strategy is bad, drop it
+ assert old_strat.strat == SchedulingStrategy.Unknown
+
+ new_strat = old_strat.clone()
+ new_strat.strat = strat_type
+ new_strat.sram_used = old_strat.sram_used + sram_used
+
+ if self.use_ifm_ofm_overlap:
+ overlap = calc_allowed_ofm_ifm_overlap_for_pass_list(
+ new_strat.strat, new_strat.passes, new_strat.block_configs
+ )
+ new_strat.sram_used -= overlap
+
+ new_strat_set = old_strat_set.clone_add_strategy(new_strat)
+ res.append((empty_strategy, new_strat_set))
+ return self.filter_pareto_frontier(res, remove_equally_good_candidates=True)
+
+ def append_sram(self, sram_used, old_strat_data):
+ res = []
+ for old_strat, strat_set in old_strat_data:
+ assert old_strat.strat == SchedulingStrategy.Unknown
+ assert old_strat.sram_used == 0
+ new_strat = old_strat.clone()
+ new_strat.sram_used = old_strat.sram_used + sram_used
+
+ res.append((new_strat, strat_set))
+ return res
+
+ def append_sram_block_config_performance_metrics(self, sram_used, block_config, metrics, old_strat_data):
+ res = []
+ for old_strat, strat_set in old_strat_data:
+ assert old_strat.strat == SchedulingStrategy.Unknown
+ new_strat = old_strat.clone()
+ bws, macs, cycles = metrics[:3]
+
+ new_strat.sram_used = old_strat.sram_used + sram_used
+ new_strat.block_configs = old_strat.block_configs + [block_config]
+ new_strat.bws = old_strat.bws + bws
+ new_strat.macs = old_strat.macs + macs
+ new_strat.cycles = old_strat.cycles + cycles
+ new_strat.bws, new_strat.macs, new_strat.cycles = npu_performance.collate_stats_for_cascaded_pass(
+ self.arch, new_strat.bws, new_strat.macs, new_strat.cycles
+ )
+
+ res.append((new_strat, strat_set))
+ return res
+
+ def append_sram_pass_block_config_performance_metrics_rewrite_list(
+ self, sram_used, new_pass, block_config, metrics, rewrite_list, old_strat_data
+ ):
+ res = []
+ for old_strat, strat_set in old_strat_data:
+ assert old_strat.strat == SchedulingStrategy.Unknown
+ new_strat = old_strat.clone()
+ bws, macs, cycles = metrics[:3]
+ new_strat.sram_used = old_strat.sram_used + sram_used
+ new_strat.block_configs = old_strat.block_configs + [block_config]
+ new_strat.bws = old_strat.bws + bws
+ new_strat.macs = old_strat.macs + macs
+ new_strat.cycles = old_strat.cycles + cycles
+ new_strat.passes = old_strat.passes + [new_pass]
+ new_strat.bws, new_strat.macs, new_strat.cycles = npu_performance.collate_stats_for_cascaded_pass(
+ self.arch, new_strat.bws, new_strat.macs, new_strat.cycles
+ )
+ new_strat.rewrite_list = old_strat.rewrite_list + rewrite_list
+ res.append((new_strat, strat_set))
+ return res
+
+ def append_sram_rewrite_list(self, sram_used, rewrite_list, old_strat_data):
+ res = []
+ for old_strat, strat_set in old_strat_data:
+ assert old_strat.strat == SchedulingStrategy.Unknown
+ new_strat = old_strat.clone()
+ new_strat.sram_used = old_strat.sram_used + sram_used
+ new_strat.rewrite_list = old_strat.rewrite_list + rewrite_list
+ res.append((new_strat, strat_set))
+ return res
+
+ def pass_to_strat(self, strat_data):
+ res = {}
+ for strat in strat_data[1].strats.values():
+ for ps in strat.passes:
+ res[ps] = strat
+ return res
+
+ def compatible_strats(self, a, b):
+ intersection = a.keys() & b.keys()
+ for k in intersection:
+ if a[k] != b[k]:
+ return False
+ return True
+
+ def collate_strats_for_passes(self, all_passes):
+ if len(all_passes) == 0:
+ return [(empty_strategy, StrategySet(dict()))]
+ if len(all_passes) == 1:
+ return all_passes[0] # save some space in the common case
+ all_strands = [[self.pass_to_strat(strat_data) for strat_data in strand] for strand in all_passes]
+ prev_combos = [dict()]
+ for j, strand in enumerate(all_strands):
+ new_combos = []
+ for i, alt in enumerate(strand):
+ for prev in prev_combos:
+ if self.compatible_strats(prev, alt):
+ cmb = dict(prev)
+ cmb.update(all_passes[j][i][1].strats)
+ new_combos.append(cmb)
+ prev_combos = new_combos
+
+ res = []
+ for d in prev_combos:
+ s = StrategySet(d)
+ s.update_statistics()
+ res.append((empty_strategy, s))
+ return res
+
+ def search_all_but_one_predecessor(self, ps, pred_pass, pred_pass_data):
+ # get the rest of the predecessors
+ other_predecessors = [pred for pred in ps.dag_predecessors if pred != pred_pass]
+ other_predecessor_data = self.search_pass_list(other_predecessors)
+
+ # pred strat data has an incomplete strategy, which we need
+ # to continue on, whereas the other ones have completed strategies.
+ # we need to merge these, but keep the incomplete strategy too.
+
+ res = []
+ for pred_pass_strat, pred_pass_strat_set in pred_pass_data:
+ all_strats = [
+ [(empty_strategy, pred_pass_strat_set)], # pred strat data but with a dummy empty strategy
+ other_predecessor_data, # this one is fine to use as-is
+ ]
+ collated_strat_data = self.collate_strats_for_passes(all_strats)
+ strat_data = [(pred_pass_strat, strat_set) for _, strat_set in collated_strat_data]
+ res.extend(strat_data)
+ return res
+
+ def calc_non_local_mem_usage(self):
+ ignore_subgraph_input_output_tensors = self.sg.placement == PassPlacement.Cpu
+ range_set = live_range.extract_live_ranges_from_passes(
+ self.sg,
+ self.mem_area,
+ mark_output_tensors_overlapping_with_input_tensors=True,
+ ignore_subgraph_input_output_tensors=ignore_subgraph_input_output_tensors,
+ )
+ range_dict = range_set.ranges
+
+ # find which ranges overlap passes but aren't input/outputs of the passes.
+ # these won't be counted by the dynamic programming search and must be counted in manually.
+ end_pos = max(ps.time for ps in self.sg.passes) + 2
+ mem_usage = np.zeros(end_pos) + self.sg.base_sram_used
+ non_local_mem_usage = np.zeros(end_pos, dtype=np.int64)
+
+ for tens, rng in range_dict.items():
+ storage_size = tens.storage_size()
+ assert tens.mem_area == self.mem_area
+ mem_usage[rng.start_time : rng.end_time] += storage_size
+
+ for ps in self.sg.passes:
+ local_mem_usage = 0
+ for tens in ps.inputs + ps.outputs + ps.intermediates:
+ if tens.mem_area != self.mem_area:
+ continue
+
+ local_mem_usage += tens.storage_size()
+
+ non_local_mem_usage[ps.time] = mem_usage[ps.time] - local_mem_usage
+
+ self.non_local_mem_usage = non_local_mem_usage
+
+ def search(self):
+ self.calc_non_local_mem_usage()
+ starting_passes = [ps for ps in self.sg.passes if not ps.successors]
+ strat_data = self.search_pass_list(starting_passes)
+
+ _, best_set = self.best_candidate(strat_data)
+
+ if self.verbose_pareto_frontier_schedules:
+ print(
+ "Scheduler searched %d combinations and found %d candidate schedules along the pareto frontier"
+ % (self.n_combinations_searched, len(strat_data,))
+ )
+ for idx, (_, strat_set) in enumerate(strat_data):
+ extra = ""
+ if strat_set == best_set:
+ extra = "(Best candidate)"
+ print("Candidate", idx, extra)
+ memory_used = {MemArea.Sram: strat_set.max_sram_used}
+ stats_writer.print_performance_metrics_for_strat(
+ self.arch,
+ "",
+ strat_set.cycles,
+ strat_set.macs,
+ strat_set.bws,
+ self.nng.batch_size,
+ memory_used,
+ len(self.sg.passes),
+ len(strat_set.strats),
+ )
+
+ return best_set
+
+ def search_pass_list(self, pass_list):
+ all_strats = []
+ for ps in pass_list:
+ strat = self.search_output(ps)
+ all_strats.append(strat)
+ strat_data = self.collate_strats_for_passes(all_strats)
+ for strd in strat_data:
+ for ps in pass_list:
+ assert ps in strd[1].strats # should have strategies for everything we asked to search
+ return strat_data
+
+ def search_predecessors(self, ps):
+
+ # protect against graphs with loops. collate_strats_for_passes will sort this out later so that
+ # we have strats for all passes
+
+ pass_list = ps.dag_predecessors
+ strat_data = self.search_pass_list(pass_list)
+
+ return strat_data
+
+ @lru_cache(maxsize=None)
+ def search_output(self, ps):
+
+ assert ps in self.sg.passes
+ candidate_list = []
+
+ candidate_list.extend(self.search_weight_streaming_output(ps))
+
+ if self.options.use_ifm_streaming:
+ candidate_list.extend(self.search_ifm_streaming_output(ps))
+
+ best = self.filter_pareto_frontier(candidate_list, remove_equally_good_candidates=True)
+
+ if not best:
+ print(
+ "Warning: Dynamic search programming algorithm failed for pass %s, invoking fallback strategy"
+ % (ps.name,)
+ )
+ return self.search_predecessors(ps)
+
+ return best
+
+ def search_ifm_streaming_output(self, ps):
+ if ps.placement != PassPlacement.Npu:
+ return ABORT_SEARCH
+ if ps.npu_block_type not in self.ifm_stream_npu_blocks:
+ return ABORT_SEARCH
+ strat_data = self.search_ifm_streaming_body(ps, False)
+
+ sram_used = self.non_local_mem_usage[ps.time]
+ for tens in ps.outputs:
+ if tens.mem_area == self.mem_area:
+ sram_used += tens.storage_size()
+
+ return self.graduate_strat(SchedulingStrategy.IfmStream, sram_used, strat_data)
+
+ @lru_cache(maxsize=None)
+ def search_ifm_streaming_body(self, ps, force_outputs_to_fast_storage):
+ if ps.placement != PassPlacement.Npu:
+ return ABORT_SEARCH
+ if ps.npu_block_type not in self.ifm_stream_npu_blocks:
+ return ABORT_SEARCH
+ ifm_input_search_resuls = self.search_ifm_streaming_input(ps)
+ res = []
+
+ base_sram_used = 0
+ for tens in ps.intermediates:
+ if tens.mem_area == self.mem_area:
+ base_sram_used += tens.storage_size()
+
+ all_block_configs = self.get_block_configs(ps)
+ for block_config in all_block_configs:
+ all_strats = []
+
+ if self.use_cascading:
+ all_strats.extend(self.search_ifm_streaming_partial(ps, block_config))
+
+ all_strats.extend(ifm_input_search_resuls)
+
+ rewrite_list = []
+ sram_used = base_sram_used
+
+ metrics = npu_performance.performance_metrics_for_pass(
+ self.arch,
+ ps,
+ block_config,
+ rewrite_list=rewrite_list,
+ force_outputs_to_fast_storage=force_outputs_to_fast_storage,
+ )
+
+ res.extend(
+ self.append_sram_pass_block_config_performance_metrics_rewrite_list(
+ sram_used, ps, block_config, metrics, rewrite_list, all_strats
+ )
+ )
+
+ self.n_combinations_searched += len(res)
+ res = self.filter_pareto_frontier(res, remove_equally_good_candidates=True)
+ return res
+
+ def search_ifm_streaming_partial(self, ps, block_config):
+ if ps.placement != PassPlacement.Npu:
+ return ABORT_SEARCH
+
+ if len(ps.inputs) < 1:
+ return ABORT_SEARCH
+
+ ifm_tensor = ps.ifm_tensor
+
+ if ifm_tensor is None:
+ return ABORT_SEARCH
+ if ifm_tensor.purpose != TensorPurpose.FeatureMap:
+ return ABORT_SEARCH
+ if not ifm_tensor.storage_shape or len(ifm_tensor.storage_shape) != 4:
+ return ABORT_SEARCH
+
+ pred_pass_list = []
+ for pred_candidate in ps.dag_predecessors:
+ if len(pred_candidate.outputs) == 1 and pred_candidate.outputs[0] == ifm_tensor:
+ # we found a predecessor that produces this IFM tensor
+ if len(pred_candidate.successors) == 1 and pred_candidate.successors[0] == ps:
+ # and it only has one successor, namely us
+ if pred_candidate.placement == PassPlacement.Npu:
+ if pred_candidate.npu_block_type in self.ifm_stream_npu_blocks:
+ # and it is on the Npu and fusable - it's a candidate
+ pred_pass_list.append(pred_candidate)
+
+ if not pred_pass_list:
+ return ABORT_SEARCH
+
+ all_candidates = []
+ for pred_pass in pred_pass_list:
+ # recurse into the next pass
+ ifm_strat_data = self.search_ifm_streaming_body(pred_pass, self.feature_maps_not_in_fast_storage)
+
+ strat_data = self.search_all_but_one_predecessor(ps, pred_pass, ifm_strat_data)
+ for strat_opt in strat_data:
+
+ pred_pass_block_config = strat_opt[0].block_configs[-1]
+ rolling_buffer_dims = npu_performance.rolling_buffer_dims_from_passes(
+ self.arch, pred_pass, pred_pass_block_config, ps, block_config
+ )
+ if rolling_buffer_dims is None:
+ continue # this does not pack properly, skip it.
+
+ sram_used = 0
+ for tens in ps.inputs:
+ if tens != ifm_tensor:
+ if tens.mem_area == self.mem_area:
+ sram_used += tens.storage_size()
+
+ rolling_buffer_y, rolling_buffer_x = rolling_buffer_dims
+
+ rewrite_list = [
+ (
+ SchedulerRewrite.ChangeTensorSubPurpose,
+ ifm_tensor,
+ TensorSubPurpose.RollingBufferY,
+ rolling_buffer_y,
+ None,
+ ps,
+ )
+ ]
+ sram_used += ifm_tensor.storage_size_for_sub_purpose(
+ TensorSubPurpose.RollingBufferY, rolling_buffer_y, None
+ )
+
+ all_candidates.extend(self.append_sram_rewrite_list(sram_used, rewrite_list, [strat_opt]))
+
+ self.n_combinations_searched += len(all_candidates)
+ return all_candidates
+
+ def get_block_configs(self, ps):
+ if ps.placement != PassPlacement.Npu:
+ return [(1, 1, 1, 1)] # default
+
+ block_configs = find_block_configs_suitable_for_pass_and_shared_buffer(self.arch, ps)
+
+ # Take a limited number of the largest blocks
+ if self.arch.block_config_limit > 0:
+ # Sort by block area, followed by depth
+ block_configs.sort(key=lambda cfg: (cfg[0] * cfg[1]) << 8 | cfg[3], reverse=True)
+ bound = min(len(block_configs), self.arch.block_config_limit)
+ # We take 'n' from the fat end of the list, and 'n' from the thin end of the list.
+ tmp = block_configs[:bound]
+ tmp.extend(block_configs[max(bound, len(block_configs) - bound) :])
+ block_configs = tmp
+
+ return block_configs
+
+ def search_ifm_streaming_input(self, ps):
+ sram_used = 0
+ for tens in ps.inputs:
+ if tens.mem_area == self.mem_area:
+ sram_used += tens.storage_size()
+
+ return self.append_sram(sram_used, self.search_predecessors(ps))
+
+ def search_weight_streaming_output(self, ps):
+ strat_data = self.search_weight_streaming_body(ps)
+
+ sram_used = self.non_local_mem_usage[ps.time]
+ for tens in ps.outputs:
+ if tens.mem_area == self.mem_area:
+ sram_used += tens.storage_size()
+
+ return self.graduate_strat(SchedulingStrategy.WeightStream, sram_used, strat_data)
+
+ @lru_cache(maxsize=None)
+ def search_weight_streaming_body(self, ps):
+
+ strat_data = self.search_weight_streaming_input(ps)
+
+ res = []
+
+ all_block_configs = self.get_block_configs(ps)
+
+ for block_config in all_block_configs:
+
+ sram_used = 0
+ rewrite_list = []
+
+ for tens in ps.intermediates:
+ if tens.mem_area == self.mem_area:
+ if tens.purpose == TensorPurpose.Weights:
+ sram_used += tens.storage_size_for_sub_purpose(
+ TensorSubPurpose.DoubleBuffer, block_config[3]
+ )
+ rewrite_list.append(
+ (
+ SchedulerRewrite.ChangeTensorSubPurpose,
+ tens,
+ TensorSubPurpose.DoubleBuffer,
+ block_config[3],
+ None,
+ ps,
+ )
+ )
+ else:
+ sram_used += tens.storage_size()
+
+ metrics = npu_performance.performance_metrics_for_pass(
+ self.arch, ps, block_config, rewrite_list=rewrite_list
+ )
+
+ res.extend(
+ self.append_sram_pass_block_config_performance_metrics_rewrite_list(
+ sram_used, ps, block_config, metrics, rewrite_list, strat_data
+ )
+ )
+
+ self.n_combinations_searched += len(res)
+ res = self.filter_pareto_frontier(res, remove_equally_good_candidates=True)
+ return res
+
+ def search_weight_streaming_input(self, ps):
+ sram_used = 0
+ for tens in ps.inputs:
+ if tens.mem_area == self.mem_area:
+ sram_used += tens.storage_size()
+
+ return self.append_sram(sram_used, self.search_predecessors(ps))
+
+ def apply_result(self, strat_set, arch):
+ pass_to_cascaded_pass = dict()
+ for _, strat in strat_set.strats.items():
+ # rewrite the tensors that need this first. e.g. make rolling buffers
+ inputs = []
+ intermediates = []
+ outputs = []
+
+ for ps in strat.passes:
+ inputs += ps.inputs
+ intermediates += ps.intermediates
+ outputs += ps.outputs
+
+ for tens in set(inputs) & set(outputs):
+ # tensors that are in both sets are intermediates
+
+ # find pass with input/output tensor, and check if they are both placed on NPU
+ input_placement = None
+ output_placement = None
+ for ps in strat.passes:
+ if tens in ps.inputs:
+ input_placement = ps.placement
+ if tens in ps.outputs:
+ output_placement = ps.placement
+ if input_placement == output_placement == PassPlacement.Npu:
+ tens.set_format(TensorFormat.NHCWB16, arch)
+
+ intermediates.append(tens)
+ inputs.remove(tens)
+ outputs.remove(tens)
+
+ for rewrite_op, tens, sub_purpose, param_a, param_b, ps in strat.rewrite_list:
+ if rewrite_op == SchedulerRewrite.ChangeTensorSubPurpose:
+ tens.mem_area = self.arch.fast_storage_mem_area
+ tens.set_new_sub_purpose(sub_purpose, param_a, param_b)
+ else:
+ assert 0, "unknown rewrite_op " + str(rewrite_op)
+
+ is_element_wise = True
+ for ps in strat.passes:
+ assert ps.placement == strat.passes[0].placement
+ if not ps.is_element_wise:
+ is_element_wise = False
+ break
+
+ cascaded_pass = CascadedPass(
+ strat.passes[0].name,
+ strat.strat,
+ inputs,
+ intermediates,
+ outputs,
+ strat.passes,
+ strat.passes[0].placement,
+ is_element_wise,
+ )
+ assert strat.sram_used >= 0
+ cascaded_pass.sram_used = strat.sram_used
+
+ for idx, ps in enumerate(strat.passes):
+ assert ps not in pass_to_cascaded_pass
+ pass_to_cascaded_pass[ps] = cascaded_pass
+ ps.cascade = cascaded_pass
+ ps.block_config = strat.block_configs[idx]
+
+ if ps.placement == PassPlacement.Npu:
+ ps.shared_buffer = shared_buffer_allocation_for_pass_and_block_config(
+ self.arch, ps, ps.block_config
+ )
+ assert ps.shared_buffer is not None
+
+ for op in ps.ops:
+ subgraph = op.attrs.get("subgraph")
+ if subgraph:
+ subgraph.base_sram_used = cascaded_pass.sram_used
+
+ # all passes should have a cascaded pass now
+ if len(pass_to_cascaded_pass) != len(self.sg.passes):
+ print(
+ "mismatch: we have %d passes, but only %d have cascaded passes associated"
+ % (len(self.sg.passes), len(pass_to_cascaded_pass))
+ )
+ for ps in self.sg.passes:
+ if not ps in pass_to_cascaded_pass:
+ print("%3d pass missing cascaded pass %s" % (ps.time, ps))
+
+ assert len(pass_to_cascaded_pass) == len(self.sg.passes)
+ # we have all the passes, but we need to put them in order and build predecessor/successor links.
+
+ visit_pass_set = set()
+ cascaded_passes = []
+
+ def visit_pass(ps):
+ if ps in visit_pass_set:
+ return
+ visit_pass_set.add(ps)
+
+ cps = ps.cascade
+ dont_traverse = set(cps.passes)
+
+ for ps in cps.passes:
+ for pred in ps.predecessors:
+ if pred in dont_traverse:
+ continue
+ visit_pass(pred)
+
+ cascaded_passes.append(cps)
+
+ starting_passes = [ps for ps in self.sg.passes if not ps.successors]
+ for ps in starting_passes:
+ visit_pass(ps)
+
+ # reorder so startup init cascaded passes come first
+ def is_startup_cascaded_pass(cps):
+ if not cps.passes:
+ return False
+ return cps.placement == PassPlacement.StartupInit
+
+ cascaded_passes = [cps for cps in cascaded_passes if is_startup_cascaded_pass(cps)] + [
+ cps for cps in cascaded_passes if not is_startup_cascaded_pass(cps)
+ ]
+
+ self.sg.cascaded_passes = cascaded_passes
+ self.sg.build_cascaded_pass_links()
+
+
+def schedule_passes(nng, arch, options: SchedulerOptions):
+
+ for sg in nng.subgraphs:
+ sg.base_sram_used = 0
+
+ for sg in nng.subgraphs:
+ # re-entering the same nodes from different contexts requires us to
+ # build a simplified directed acyclic (DAG) version of the graph to
+ # use for traversal, rather than using a visit dictionary. this avoids
+ # recursing infinitely due to loops.
+ sg.build_pass_dag_predecessors()
+
+ dps = DynamicProgrammingScheduler(nng, sg, arch, arch.sram_size, options)
+
+ strat_set = dps.search()
+
+ dps.apply_result(strat_set, arch)
+
+ if options.verbose_schedule:
+ sg.print_cascaded_passes()
diff --git a/ethosu/vela/shared_buffer_allocation.py b/ethosu/vela/shared_buffer_allocation.py
new file mode 100644
index 0000000..b5408d1
--- /dev/null
+++ b/ethosu/vela/shared_buffer_allocation.py
@@ -0,0 +1,199 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Shared buffer allocation works out how to allocate the Ethos-U55 shared buffer for a given pass.
+
+import numpy as np
+from .nn_graph import NpuBlockType
+from .numeric_util import round_up_divide, round_up
+from .architecture_features import Block, Kernel, SHRAMElements, SharedBufferArea, ArchitectureFeatures
+from . import pass_packing
+
+
+class SharedBufferAllocation:
+ def __init__(self, arch, ps):
+ self.arch = arch
+
+ self.bank_locations = np.zeros(SharedBufferArea.Size)
+ self.banks_required = np.zeros(SharedBufferArea.Size)
+
+ ifm_tensor, ifm2_tensor, weight_tensor, ofm_tensor = ps.get_primary_op_ifm_ifm2_weights_ofm()
+
+ strides = (1, 1, 1, 1)
+ dilation = (1, 1, 1, 1)
+ self.kernel = Kernel(1, 1)
+ is_elementwise = ps.npu_block_type == NpuBlockType.ElementWise
+
+ if ps.primary_op:
+ strides = ps.primary_op.attrs.get("strides", strides)
+ dilation = ps.primary_op.attrs.get("dilation", dilation)
+ k_h = 1
+ k_w = 1
+ if weight_tensor:
+ if ps.primary_op.type != "FullyConnectedAct":
+ k_h = weight_tensor.shape[0]
+ k_w = weight_tensor.shape[1]
+ else:
+ k_h = ps.primary_op.attrs.get("filter_height", 1)
+ k_w = ps.primary_op.attrs.get("filter_width", 1)
+
+ self.kernel = Kernel(k_w, k_h, strides[2], strides[1], dilation[2], dilation[1])
+
+ self.is_equal_depth_op = is_elementwise or ps.npu_block_type in (
+ NpuBlockType.ConvolutionDepthWise,
+ NpuBlockType.Pooling,
+ )
+ self.strides = strides
+
+ self.use_accumulator_element = SHRAMElements.Acc32
+ if is_elementwise:
+ self.use_ifm_element = SHRAMElements.IFM8_Elementwise
+ else:
+ self.use_ifm_element = SHRAMElements.IFM8
+
+ self.ifm_bits = 0
+ self.ifm_depth = 0
+ if ifm_tensor:
+ self.ifm_bits = ifm_tensor.dtype.size_in_bits()
+ if ifm_tensor.shape == [] and is_elementwise:
+ # Elementwise operator with scalar in ifm, use ifm2 depth
+ self.ifm_depth = ifm2_tensor.shape[-1]
+ else:
+ self.ifm_depth = ifm_tensor.shape[-1]
+ if self.ifm_bits == 16:
+ self.use_accumulator_element = SHRAMElements.Acc40
+ self.use_ifm_element = self.use_ifm_element + 1
+ assert (self.use_ifm_element == SHRAMElements.IFM16) or (
+ self.use_ifm_element == SHRAMElements.IFM16_Elementwise
+ )
+ else:
+ assert self.ifm_bits == 8, "Unexpected IFM bitdepth"
+
+ self.ifm_block_depth = arch.calc_ifm_block_depth(self.ifm_depth, self.ifm_bits)
+ self.ofm_tensor = ofm_tensor
+
+ self.banks_required[SharedBufferArea.Weights] = arch.shram_reserved_weight_banks
+ self.banks_required[SharedBufferArea.OFM] = arch.shram_reserved_output_banks
+
+ def is_valid(self):
+ # Assign zero-based bank starts (first element remains zero)
+ self.bank_locations[1:] = np.cumsum(self.banks_required)[:-1]
+
+ # Accumulator area is measured from the end of the buffer
+ self.bank_locations[SharedBufferArea.Accumulators] = (
+ self.arch.shram_total_banks - self.banks_required[SharedBufferArea.Accumulators]
+ )
+ ifm_end = self.bank_locations[SharedBufferArea.IFM] + self.banks_required[SharedBufferArea.IFM]
+ return ifm_end <= self.bank_locations[SharedBufferArea.Accumulators]
+
+ def try_block(self, ofm_block: Block):
+ # Get IFM block configuration
+ ifm_block_depth = ofm_block.depth if self.is_equal_depth_op else self.ifm_block_depth
+ ifm_block = self.arch.get_ifm_block_size(ifm_block_depth, ofm_block, self.kernel)
+ ifm_config = self.arch.get_block_config(ifm_block.width, ifm_block.height, ifm_block.depth)
+ if ifm_config is None:
+ return None
+
+ # Get OFM block configuration
+ ofm_config = self.arch.get_block_config(ofm_block.width, ofm_block.height, ofm_block.depth)
+ if ofm_config is None:
+ return None
+
+ # Update bank counts for IFM and Accumulator
+ self.banks_required[SharedBufferArea.IFM] = ifm_config.banks[self.use_ifm_element]
+ self.banks_required[SharedBufferArea.Accumulators] = ofm_config.banks[self.use_accumulator_element]
+
+ # Validating calculates bank layout and returns validity
+ if not self.is_valid():
+ return None
+
+ return (ofm_block.height, ofm_block.width, ifm_block.depth, ofm_block.depth)
+
+ def generate_used_mask(self, active_set):
+ res = np.zeros(self.arch.shram_total_banks, dtype=np.int64)
+ for kind in active_set:
+ start = int(self.bank_locations[kind])
+ end = start + int(self.banks_required[kind])
+ res[start:end] = 1
+ return res
+
+ def is_compatible(first, second):
+ """See if the bank allocations of two convolutions are compatible,
+ so that they can run back-to-back without a fence in between"""
+
+ first_set = set((SharedBufferArea.OFM, SharedBufferArea.Accumulators))
+ second_set = set((SharedBufferArea.IFM, SharedBufferArea.Weights))
+
+ first_mask = first.generate_used_mask(first_set)
+ second_mask = second.generate_used_mask(second_set)
+
+ if np.sum(first_mask & second_mask):
+ # overlap
+ return False
+
+ return True
+
+
+def shared_buffer_allocation_for_pass_and_block_config(arch, ps, block_config):
+ alloc = SharedBufferAllocation(arch, ps)
+ assert (alloc.ifm_block_depth == block_config[2]) or alloc.is_equal_depth_op
+ if alloc.try_block(Block(block_config[1], block_config[0], block_config[3])):
+ return alloc
+
+ return None
+
+
+def find_block_configs_suitable_for_pass_and_shared_buffer(arch, ps):
+ alloc = SharedBufferAllocation(arch, ps)
+
+ if arch.override_block_config:
+ config = alloc.try_block(arch.override_block_config)
+ assert config, "Block config override cannot be used"
+ return [config]
+
+ # Constrain the search space if the OFM is smaller than the max block size
+ # - Add other block search constraints here if required
+ if len(alloc.ofm_tensor.shape) == 2:
+ max_block_height = max_block_width = alloc.ofm_tensor.shape[0]
+ else:
+ max_block_width = alloc.ofm_tensor.shape[-2]
+ max_block_height = alloc.ofm_tensor.shape[-3]
+
+ # Common block depth
+ max_block_depth = alloc.ofm_tensor.shape[-1]
+
+ # Constrain to valid ranges before search
+ max_block_width = min(arch.ofm_block_max.width, max_block_width)
+ max_block_height = min(arch.ofm_block_max.height, max_block_height)
+ max_block_depth = min(arch.ofm_block_max.depth, max_block_depth)
+
+ valid_block_configs = []
+ # Try a range of block shapes against this pass
+ for w in range(arch.ofm_ublock.width, max_block_width + arch.ofm_ublock.width, arch.ofm_ublock.width):
+ for h in range(arch.ofm_ublock.height, max_block_height + arch.ofm_ublock.height, arch.ofm_ublock.height):
+ # Try valid OFM block depths
+ for c in range(arch.ofm_ublock.depth, max_block_depth + arch.ofm_ublock.depth, arch.ofm_ublock.depth):
+ # OFM block depth has the constraint that if it causes the OFM to be
+ # split, it must be a multiple of the OFM split size
+ if (c >= max_block_depth) or (c < max_block_depth and (c % ArchitectureFeatures.OFMSplitDepth) == 0):
+ config = alloc.try_block(Block(w, h, c))
+ if config:
+ valid_block_configs.append(config)
+
+ assert len(valid_block_configs) > 0
+ return valid_block_configs
diff --git a/ethosu/vela/stats_writer.py b/ethosu/vela/stats_writer.py
new file mode 100644
index 0000000..c4b4cd9
--- /dev/null
+++ b/ethosu/vela/stats_writer.py
@@ -0,0 +1,367 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Writes out per-pass and summary performance statistics to CSV files.
+
+import numpy as np
+from .nn_graph import MemArea, TensorPurpose, PassPlacement
+from .npu_performance import PassCycles, MacCount, BandwidthDirection
+import csv
+from .numeric_util import round_up_to_int
+import sys
+
+
+def write_summary_metrics_csv(nng, summary_filename, arch):
+ with open(summary_filename, "w") as f:
+ writer = csv.writer(f)
+
+ labels = [
+ "experiment",
+ "network",
+ ]
+
+ labels += (
+ ["accelerator_configuration", "system_config", "npu_clock", "sram_size"]
+ + [area.identifier_name() + "_bandwidth" for area in MemArea.all()]
+ + ["weights_storage_area", "feature_map_storage_area"]
+ )
+
+ labels += [
+ "inferences_per_second",
+ "batch_size",
+ "inference_time",
+ "passes_before_fusing",
+ "passes_after_fusing",
+ ]
+ labels += [area.identifier_name() + "_memory_used" for area in MemArea.all()]
+ labels += ["on_chip_flash_bits_per_element", "off_chip_flash_bits_per_element"]
+
+ for mem_area in MemArea.all():
+ labels += [
+ mem_area.identifier_name() + "_feature_map_read_bytes",
+ mem_area.identifier_name() + "_feature_map_write_bytes",
+ mem_area.identifier_name() + "_weight_read_bytes",
+ mem_area.identifier_name() + "_weight_write_bytes",
+ mem_area.identifier_name() + "_total_bytes",
+ ]
+
+ labels += ["nn_macs", "hardware_macs", "nn_tops", "hardware_tops"]
+
+ labels += ["cycles_" + kind.identifier_name() for kind in PassCycles.all()]
+
+ writer.writerow(labels)
+
+ data_items = [
+ "default",
+ nng.name,
+ ]
+
+ if arch:
+ data_items += (
+ [arch.accelerator_config, arch.system_config, arch.npu_clock, arch.sram_size / 1024]
+ + [arch.memory_bandwidths_per_second[mem_area] / 1000.0 / 1000 / 1000 for mem_area in MemArea.all()]
+ + [
+ arch.tensor_storage_mem_area[TensorPurpose.Weights].display_name(),
+ arch.tensor_storage_mem_area[TensorPurpose.FeatureMap].display_name(),
+ ]
+ )
+
+ midpoint_inference_time = nng.cycles[PassCycles.Total] / arch.npu_clock
+ midpoint_fps = 1 / midpoint_inference_time
+
+ n_passes = sum(len(sg.passes) for sg in nng.subgraphs)
+ n_cascaded_passes = sum(len(sg.cascaded_passes) for sg in nng.subgraphs)
+
+ data_items += [midpoint_fps, nng.batch_size, midpoint_inference_time, n_passes, n_cascaded_passes]
+ data_items += [nng.memory_used.get(mem_area, 0) / 1024.0 for mem_area in MemArea.all()]
+
+ data_items += [
+ nng.bits_per_element.get(MemArea.OnChipFlash, 0.0),
+ nng.bits_per_element.get(MemArea.OffChipFlash, 0.0),
+ ]
+
+ for mem_area in MemArea.all():
+ bws = nng.bandwidths[mem_area]
+ total_bw = np.sum(bws)
+ weight_bws = bws[TensorPurpose.Weights]
+ fm_bws = bws[TensorPurpose.FeatureMap]
+ data_items += [
+ fm_bws[BandwidthDirection.Read],
+ fm_bws[BandwidthDirection.Write],
+ weight_bws[BandwidthDirection.Read],
+ weight_bws[BandwidthDirection.Write],
+ total_bw,
+ ]
+
+ data_items += [
+ nng.macs[MacCount.NeuralNetworkMacs],
+ nng.macs[MacCount.HardwareMacs],
+ nng.macs[MacCount.NeuralNetworkMacs] * 2 * midpoint_fps / 1e12,
+ nng.macs[MacCount.HardwareMacs] * 2 * midpoint_fps / 1e12,
+ ]
+
+ data_items += [nng.cycles[kind] for kind in PassCycles.all()]
+
+ writer.writerow(data_items)
+
+
+def write_pass_metrics_csv(nng, pass_filename):
+
+ with open(pass_filename, "w") as f:
+ writer = csv.writer(f)
+
+ purpose_list = (
+ ("total", (TensorPurpose.Weights, TensorPurpose.FeatureMap)),
+ ("weights", (TensorPurpose.Weights,)),
+ ("feature_map", (TensorPurpose.FeatureMap,)),
+ )
+
+ direction_list = (
+ ("total", (BandwidthDirection.Read, BandwidthDirection.Write)),
+ ("read", (BandwidthDirection.Read,)),
+ ("write", (BandwidthDirection.Write,)),
+ )
+ bandwidth_names = []
+ bandwidth_indices = []
+ for mem_area in MemArea.all():
+ for purpose, purpose_candidates in purpose_list:
+ for direction, direction_candidates in direction_list:
+ label = "bytes_%s_%s_%s" % (mem_area.identifier_name(), purpose, direction)
+ bandwidth_names.append(label)
+ bandwidth_indices.append((mem_area, purpose_candidates, direction_candidates))
+
+ all_macs = MacCount.all()
+ all_cycles = (
+ PassCycles.Total,
+ PassCycles.Dpu,
+ PassCycles.ElementWise,
+ PassCycles.Cpu,
+ PassCycles.SramAccess,
+ PassCycles.DramAccess,
+ PassCycles.OnChipFlashAccess,
+ PassCycles.OffChipFlashAccess,
+ )
+ writer.writerow(
+ [
+ "name",
+ "operators",
+ "placement",
+ "streaming_strategy",
+ "block_config_height",
+ "block_config_width",
+ "block_config_input_channels",
+ "block_config_output_channels",
+ "n_blocks_in_pass",
+ ]
+ + ["cycles_" + v.identifier_name() for v in all_cycles]
+ + [v.identifier_name() for v in all_macs]
+ + bandwidth_names
+ + ["sram_used"]
+ )
+
+ def write_subgraph(sg):
+ for cps in sg.cascaded_passes:
+ if cps.placement == PassPlacement.StartupInit:
+ continue # skip the dummy init pass
+
+ for ps in cps.passes:
+ if len(ps.ops) == 1 and ps.ops[0].type == "NpuOp":
+ # just treat this as a call, unroll it
+ write_subgraph(ps.ops[0].attrs["subgraph"])
+ continue
+ stats = [ps.name, " ".join(op.type for op in ps.ops)]
+ stats += [ps.placement.name]
+ stats += [cps.strategy.name]
+ stats += list(ps.block_config)
+ stats += [ps.n_blocks]
+ stats += [round_up_to_int(ps.cycles[v]) for v in all_cycles]
+ stats += [round_up_to_int(ps.macs[v]) for v in all_macs]
+ for indices in bandwidth_indices:
+ res = 0
+ i = indices[0]
+ for j in indices[1]:
+ for k in indices[2]:
+ res += round_up_to_int(ps.bandwidths[i, j, k])
+ stats.append(res)
+ stats += [ps.sram_used]
+
+ writer.writerow(stats)
+
+ write_subgraph(nng.get_root_subgraph())
+
+
+def print_performance_metrics_for_strat(
+ arch,
+ name,
+ cycles,
+ macs,
+ bandwidths,
+ batch_size,
+ memory_used,
+ num_passes,
+ num_cascaded_passes,
+ n_operations=0,
+ cpu_operations=[],
+ bits_per_element=None,
+ show_cpu_operations=False,
+ f=sys.stdout,
+):
+
+ orig_mem_areas_labels = [(v, v.display_name()) for v in MemArea.all()]
+
+ midpoint_inference_time = cycles[PassCycles.Total] / arch.npu_clock
+ midpoint_fps = 1 / midpoint_inference_time
+
+ mem_area_labels = [
+ (mem_area, label) for mem_area, label in orig_mem_areas_labels if np.sum(bandwidths[mem_area]) > 0
+ ]
+
+ if name:
+ print("", file=f)
+ print("Network summary for", name, file=f)
+ print("Accelerator configuration %20s" % (arch.accelerator_config,), file=f)
+ print("System configuration %20s" % (arch.system_config,), file=f)
+ print("Accelerator clock %12d MHz" % (arch.npu_clock / 1e6,), file=f)
+ for mem_area, label in mem_area_labels:
+ print(
+ "Design peak %-25s %12.2f GB/s"
+ % (label + " bandwidth", arch.memory_bandwidths_per_second[mem_area] / 1000.0 / 1000 / 1000,),
+ file=f,
+ )
+
+ print(file=f)
+ for mem_area, label in mem_area_labels:
+ if not mem_area in memory_used:
+ continue
+
+ aug_label = label + " used"
+
+ extra = ""
+ if (mem_area == MemArea.OnChipFlash or mem_area == MemArea.OffChipFlash) and bits_per_element is not None:
+ extra = " (%.2f bits per element)" % (bits_per_element[mem_area],)
+
+ print("Total %-25s %12.2f KiB%s" % (aug_label, memory_used[mem_area] / 1024.0, extra), file=f)
+
+ print(file=f)
+ print("%d passes fused into %d" % (num_passes, num_cascaded_passes), file=f)
+
+ n_cpu_operations = len(cpu_operations)
+ if n_operations > 0:
+ print(
+ "%d/%d (%4.1f %%) operations falling back to the CPU"
+ % (n_cpu_operations, n_operations, n_cpu_operations / n_operations * 100),
+ file=f,
+ )
+
+ if show_cpu_operations:
+ for op in cpu_operations:
+
+ def format_tens_list(lst):
+ return " ".join(str(list(tens.shape)) for tens in lst)
+
+ print(
+ "CPU operation: %s, inputs %s, outputs %s"
+ % (op.type, format_tens_list(op.inputs), format_tens_list(op.outputs)),
+ file=f,
+ )
+
+ print("", file=f)
+
+ for mem_area, label in mem_area_labels:
+ bws = bandwidths[mem_area]
+ total_bw = np.sum(bws)
+ weight_bws = bws[TensorPurpose.Weights]
+ fm_bws = bws[TensorPurpose.FeatureMap]
+ aug_label = label + " bandwidth"
+ print(
+ "Average %-25s %12.2f GB/s" % (aug_label, total_bw * midpoint_fps / 1000.0 / 1000.0 / 1000.0,),
+ file=f,
+ )
+ print(
+ "Input %-25s %12.2f MB/batch"
+ % (aug_label, np.sum(fm_bws[BandwidthDirection.Read]) / 1000.0 / 1000.0,),
+ file=f,
+ )
+ print("Weight %-25s %12.2f MB/batch" % (aug_label, np.sum(weight_bws) / 1000.0 / 1000.0,), file=f)
+ print(
+ "Output %-25s %12.2f MB/batch"
+ % (aug_label, np.sum(fm_bws[BandwidthDirection.Write]) / 1000.0 / 1000.0,),
+ file=f,
+ )
+ print("Total %-25s %12.2f MB/batch" % (aug_label, total_bw / 1000.0 / 1000.0,), file=f)
+ print(
+ "Total %-25s per input %9.2f MB/inference (batch size %d)"
+ % (aug_label, total_bw / 1000.0 / 1000.0 / batch_size, batch_size),
+ file=f,
+ )
+ print(file=f)
+
+ print("Neural network macs %12d MACs/batch" % (macs[MacCount.NeuralNetworkMacs],), file=f)
+ print("Hardware macs %12d MACs/batch" % (macs[MacCount.HardwareMacs],), file=f)
+ print(
+ "Network Tops/s %12.2f Tops/s"
+ % (macs[MacCount.NeuralNetworkMacs] * 2 * midpoint_fps / 1e12),
+ file=f,
+ )
+ print(
+ "Hardware Tops/s %12.2f Tops/s"
+ % (macs[MacCount.HardwareMacs] * 2 * midpoint_fps / 1e12),
+ file=f,
+ )
+ print(file=f)
+
+ for kind in PassCycles.all():
+ aug_label = kind.display_name() + " cycles"
+ cyc = cycles[kind]
+ print("%-30s %12d cycles/batch" % (aug_label, cyc,), file=f)
+ print(file=f)
+
+ print(
+ "Batch Inference time %7.2f ms, %7.2f inferences/s (batch size %d)"
+ % (midpoint_inference_time * 1000, midpoint_fps, batch_size),
+ file=f,
+ )
+ print(file=f)
+
+
+def print_performance_metrics(nng, arch, show_cpu_operations=False, f=sys.stdout):
+ n_passes = sum(len(sg.passes) for sg in nng.subgraphs)
+ n_cascaded_passes = sum(len(sg.cascaded_passes) for sg in nng.subgraphs)
+ n_operations = sum(len(ps.ops) for sg in nng.subgraphs for ps in sg.passes)
+ cpu_operations = sum((ps.ops for sg in nng.subgraphs for ps in sg.passes if ps.placement == PassPlacement.Cpu), [])
+ return print_performance_metrics_for_strat(
+ arch,
+ nng.name,
+ nng.cycles,
+ nng.macs,
+ nng.bandwidths,
+ nng.batch_size,
+ nng.memory_used,
+ n_passes,
+ n_cascaded_passes,
+ n_operations,
+ cpu_operations,
+ nng.bits_per_element,
+ show_cpu_operations,
+ f,
+ )
+
+
+def write_human_friendly_metrics(nng, arch, filename):
+ f = open(filename, "w")
+ print_performance_metrics(nng, arch, f=f)
diff --git a/ethosu/vela/supported_operators.py b/ethosu/vela/supported_operators.py
new file mode 100644
index 0000000..23135f8
--- /dev/null
+++ b/ethosu/vela/supported_operators.py
@@ -0,0 +1,243 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# The SupportedOperators class which is a collection of all supported operators and parameter checks.
+
+from .data_type import BaseType
+
+
+class SupportedOperators:
+ def __init__(self):
+ # Categorised lists of supported operators
+ self.npu_pre_ops = set(("QuantizedResizeBilinear", "SplitSliceRead"))
+ self.convolution_ops = set(("Conv2DBiasAct", "Conv2D", "QuantizedConv2D", "Conv2DBackpropInputSwitched"))
+ self.depthwise_convolution_ops = set(
+ ("DepthwiseConv2dBiasAct", "DepthwiseConv2dNative", "QuantizedDepthwiseConv2D")
+ )
+ self.max_pooling_ops = set(("QuantizedMaxPool", "MaxPool", "MaxPoolAct"))
+ self.avg_pooling_ops = set(("QuantizedAvgPool", "AvgPool", "AvgPoolAct"))
+ self.pooling_ops = self.max_pooling_ops | self.avg_pooling_ops
+ self.fc_vector_products = set(("QuantizedMatMul", "MatMul", "FullyConnectedAct"))
+ self.mac_main_ops = (
+ # convolutions
+ self.convolution_ops
+ # depth-wise convolutions
+ | self.depthwise_convolution_ops
+ # pooling
+ | self.pooling_ops
+ # FC layers
+ | self.fc_vector_products
+ # RNN/LSTM/GRU
+ | set(("BlockLSTM"))
+ )
+ self.elem_wise_main_ops = set(
+ (
+ # element-wise
+ "AddAct",
+ "MulAct",
+ "SubAct",
+ "QuantizedAdd",
+ "QuantizedSub",
+ "QuantizedMul",
+ "Mul",
+ "Add",
+ "Sub",
+ "Minimum",
+ "Maximum",
+ )
+ )
+ self.activation_ops = set(
+ ("QuantizedRelu", "QuantizedRelu1", "QuantizedRelu6", "Relu", "Relu6", "ReluN1To1", "Sigmoid", "Tanh")
+ )
+ self.npu_post_ops = (
+ # activation functions
+ self.activation_ops
+ # concatenation write direction
+ | set(("ConcatSliceWrite"))
+ # bias add and batch norm
+ | set(("QuantizedBiasAdd", "Requantize", "QuantizedBatchNorm", "BiasAdd", "FusedBatchNorm"))
+ )
+ self.split_ops = set(("Split", "StridedSlice", "Slice", "UnpackReshaped", "Unpack"))
+ self.concat_ops = set(("Concat", "ConcatV2", "QuantizedConcat", "ConcatTFLite", "PackReshaped", "Pack"))
+ self.memory_only_ops = (
+ set(("Squeeze", "Reshape", "QuantizedReshape", "ExpandDims")) | self.concat_ops | self.split_ops
+ )
+ self.supported_fused_activations = set(("Relu", "Relu6", "ReluN1To1", "Tanh", "Sigmoid"))
+ self.supported_operators = (
+ self.npu_pre_ops | self.mac_main_ops | self.elem_wise_main_ops | self.npu_post_ops | self.memory_only_ops
+ )
+ # Setup supported operator restriction checkers
+ self.supported_operator_restrictions = {}
+ self.supported_operator_restrictions.update(
+ {op: self.check_convolution_restrictions for op in self.convolution_ops}
+ )
+ self.supported_operator_restrictions.update(
+ {op: self.check_depthwise_convolution_restrictions for op in self.depthwise_convolution_ops}
+ )
+ self.supported_operator_restrictions.update({op: self.check_pooling_restrictions for op in self.pooling_ops})
+ self.supported_operator_restrictions.update(
+ {op: self.check_vector_product_restrictions for op in self.fc_vector_products}
+ )
+ self.supported_operator_restrictions.update(
+ {op: self.check_element_wise_restrictions for op in self.elem_wise_main_ops}
+ )
+ self.supported_operator_restrictions.update(
+ {op: self.check_memory_only_restrictions for op in self.memory_only_ops}
+ )
+
+ def is_operator_supported(self, op):
+ if op.type not in self.supported_operators:
+ return False
+ if not self.check_generic_restrictions(op):
+ return False
+ if op.type in self.supported_operator_restrictions:
+ return self.supported_operator_restrictions[op.type](op)
+ return True
+
+ def check_generic_restrictions(self, op):
+ # check fully defined shapes
+ for t in op.inputs + op.outputs:
+ if not t.has_fully_defined_shape():
+ print("Warning:", op, "has inputs/outputs of undefined shape, placing on CPU")
+ return False
+
+ # check data type
+ tensors = [t for t in op.get_ifm_ifm2_weights_ofm() if t is not None]
+ if not tensors:
+ tensors = op.inputs
+ for t in tensors:
+ if not (t.dtype.type & BaseType.Int):
+ return False
+ if t.element_size() > 2 and op.type != "Requantize":
+ return False
+ # check size
+ if any(dim > 65536 for dim in t.shape):
+ return False
+
+ # check fused activations
+ if (
+ "fused_activation_function" in op.attrs
+ and op.attrs["fused_activation_function"] is not None
+ and op.attrs["fused_activation_function"] not in self.supported_fused_activations
+ ):
+ return False
+ return True
+
+ def check_convolution_restrictions(self, op):
+ # check stride
+ if op.attrs["stride_w"] > 2 or op.attrs["stride_h"] > 2:
+ return False
+
+ # check dilation
+ dilation_w_factor = op.attrs.get("dilation_w_factor", 1)
+ dilation_h_factor = op.attrs.get("dilation_h_factor", 1)
+ if dilation_w_factor > 2 or dilation_h_factor > 2:
+ return False
+
+ # check data type
+ ifm_tensor, _, weight_tensor, _ = op.get_ifm_ifm2_weights_ofm()
+ if weight_tensor.element_size() > 1:
+ return False
+
+ # check kernel size
+ dilated_weight_w = weight_tensor.shape[0] + (weight_tensor.shape[0] - 1) * (dilation_w_factor - 1)
+ dilated_weight_h = weight_tensor.shape[1] + (weight_tensor.shape[1] - 1) * (dilation_h_factor - 1)
+ if (
+ dilated_weight_w > 64
+ or dilated_weight_h > 64
+ or dilated_weight_w * dilated_weight_h * weight_tensor.shape[2] > 127 * 65536
+ ):
+ return False
+
+ # check batch size
+ if ifm_tensor.shape[0] != 1:
+ return False
+ return True
+
+ def check_depthwise_convolution_restrictions(self, op):
+ # check depth
+ ifm_tensor, _, _, ofm_tensor = op.get_ifm_ifm2_weights_ofm()
+ if op.attrs["depth_multiplier"] > 1 and not (
+ (ifm_tensor.shape[3] == 1) and (ofm_tensor.shape[3] == op.attrs["depth_multiplier"])
+ ):
+ return False
+ return self.check_convolution_restrictions(op)
+
+ def check_pooling_restrictions(self, op):
+ # check stride
+ if op.attrs["stride_w"] > 2 or op.attrs["stride_h"] > 2:
+ return False
+
+ # check data type
+ ifm_tensor, _, _, ofm_tensor = op.get_ifm_ifm2_weights_ofm()
+ if ifm_tensor.dtype != ofm_tensor.dtype:
+ return False
+
+ # check batch size
+ if ifm_tensor.shape[0] != 1:
+ return False
+
+ if op.type in self.avg_pooling_ops:
+ # check kernel size
+ if op.attrs["padding"] == b"SAME" and (op.attrs["filter_width"] > 8 or op.attrs["filter_height"] > 8):
+ return False
+ if op.attrs["padding"] == b"VALID" and (op.attrs["filter_width"] > 256 or op.attrs["filter_height"] > 256):
+ return False
+
+ if op.type in self.max_pooling_ops:
+ # check data type
+ if not ifm_tensor.dtype == ofm_tensor.dtype:
+ return False
+ # check kernel size
+ if op.attrs["filter_width"] > 256 or op.attrs["filter_height"] > 256: # any padding
+ return False
+ return True
+
+ def check_vector_product_restrictions(self, op):
+ # check data type
+ ifm_tensor, _, weight_tensor, _ = op.get_ifm_ifm2_weights_ofm()
+ if weight_tensor.element_size() > 1:
+ return False
+
+ return True
+
+ def check_element_wise_restrictions(self, op):
+ # check data type
+ ifm_tensor, ifm2_tensor, _, ofm_tensor = op.get_ifm_ifm2_weights_ofm()
+ if op.type in ("Minimum", "Maximum") and ifm_tensor.dtype != ofm_tensor.dtype:
+ return False
+
+ # check batch size
+ if (len(ifm_tensor.shape) > 2 and ifm_tensor.shape[0] != 1) or (
+ len(ifm2_tensor.shape) > 2 and ifm2_tensor.shape[0] != 1
+ ):
+ return False
+
+ # check scalar size
+ if (hasattr(ifm_tensor.values, "__len__") and len(ifm_tensor.values) > 1) or (
+ hasattr(ifm2_tensor.values, "__len__") and len(ifm2_tensor.values) > 1
+ ):
+ return False
+ return True
+
+ def check_memory_only_restrictions(self, op):
+ # check stride size
+ if op.type == "StridedSlice":
+ if len(op.inputs) > 3 and any(stride != 1 for stride in op.inputs[3].values):
+ return False
+ return True
diff --git a/ethosu/vela/tensor.py b/ethosu/vela/tensor.py
new file mode 100644
index 0000000..46040a4
--- /dev/null
+++ b/ethosu/vela/tensor.py
@@ -0,0 +1,629 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Internal representation of a Neural Network Tensor.
+
+import enum
+from . import numeric_util
+import numpy as np
+from . import data_type
+import uuid
+from .range_set import MemoryRangeSet
+from .numeric_util import round_up_divide
+
+
+class MemArea(enum.IntFlag):
+ Unknown = 0
+ Sram = 1
+ Dram = 2
+ OnChipFlash = 3
+ OffChipFlash = 4
+ Size = OffChipFlash + 1
+
+ def display_name(self):
+ return ("Unknown", "SRAM", "DRAM", "On-chip Flash", "Off-chip Flash", "Size")[self.value]
+
+ def identifier_name(self):
+ return ("unknown", "sram", "dram", "on_chip_flash", "off_chip_flash", "size")[self.value]
+
+ def all():
+ return (MemArea.Sram, MemArea.Dram, MemArea.OnChipFlash, MemArea.OffChipFlash)
+
+ def __str__(self):
+ return self.name
+
+
+class TensorPurpose(enum.IntFlag):
+ Unknown = 0
+ Weights = 1
+ FeatureMap = 2
+ Scratch = 3
+ Size = 4
+
+ def display_name(self):
+ return ("Unknown", "Weights", "FeatureMap", "Scratch", "Size")[self.value]
+
+ def identifier_name(self):
+ return ("unknown", "weights", "feature_map", "scratch", "size")[self.value]
+
+ def all():
+ return (TensorPurpose.Weights, TensorPurpose.FeatureMap)
+
+
+class TensorSubPurpose(enum.Enum):
+ Standard = 0
+ DoubleBuffer = 1
+ RollingBufferX = 2
+ RollingBufferY = 3
+ RollingBufferXY = 4
+
+ def display_name(self):
+ return ("Standard", "Double Buffer", "Rolling Buffer X", "Rolling Buffer Y", "Rolling Buffer XY")[self.value]
+
+ def identifier_name(self):
+ return ("standard", "double_buffer", "rolling_buffer_x", "rolling_buffer_y", "rolling_buffer_xy")[self.value]
+
+ def all():
+ return (
+ TensorSubPurpose.Standard,
+ TensorSubPurpose.DoubleBuffer,
+ TensorSubPurpose.RollingBufferX,
+ TensorSubPurpose.RollingBufferY,
+ TensorSubPurpose.RollingBufferXY,
+ )
+
+
+class TensorFormat(enum.Flag):
+ Unknown = 0
+ WeightsCompressed = 1
+ NHWC = 2
+ NHCWB16 = 3
+
+ def __str__(self):
+ return self.name
+
+
+class TensorBlockTraversal(enum.Enum):
+ Default = 0
+ DepthWise = 1
+ DepthFirst = 2
+ PartKernelFirst = 3
+
+
+def shape_num_elements(shp):
+ elems = 1
+ if shp is None:
+ return None
+ for d in shp:
+ if d is None:
+ return None
+ elems *= d
+ return elems
+
+
+def shape_fully_defined(shp):
+ if shp is None:
+ return False
+ for d in shp:
+ if d is None:
+ return False
+ return True
+
+
+def shape_round_to_quantum(shp, quantum):
+ new_shp = list(shp)
+
+ # Traverse backwards using length of shape since there may be more rounding quantums than shape elements
+ for i in range(-1, -len(shp) - 1, -1):
+ if new_shp[i] is not None:
+ new_shp[i] = numeric_util.round_up(new_shp[i], quantum[i])
+ return new_shp
+
+
+class QuantizationParameters:
+ __slots__ = "min", "max", "num_bits", "narrow_range", "scale_f32", "zero_point", "quant_min", "quant_max"
+
+ def __init__(self, min=None, max=None, num_bits=None, narrow_range=None):
+ self.min = min
+ self.max = max
+
+ self.num_bits = num_bits
+ self.narrow_range = narrow_range
+
+ self.scale_f32 = None
+ self.zero_point = None
+ self.quant_min = None
+ self.quant_max = None
+
+ def __str__(self):
+ return "<nng.QuantizationParameters min=%s max=%s, num_bits=%s, scale=%s, zero_point=%s>" % (
+ self.min,
+ self.max,
+ self.num_bits,
+ self.scale_f32,
+ self.zero_point,
+ )
+
+ __repr__ = __str__
+
+ def clone(self):
+ res = QuantizationParameters()
+ res.min = self.min
+ res.max = self.max
+
+ res.num_bits = self.num_bits
+ res.narrow_range = self.narrow_range
+
+ res.scale_f32 = self.scale_f32
+ res.zero_point = self.zero_point
+ res.quant_min = self.quant_min
+ res.quant_max = self.quant_max
+ return res
+
+ def dequantize(self, values):
+ if self.zero_point.size == 1 and self.scale_f32.size == 1:
+ # same scale is used for all values
+ res = (values.astype(np.float64) - self.zero_point) * self.scale_f32
+ else:
+ # a different scale is used for different sets of values
+ values_as_float = values.astype(np.float64)
+
+ # this is not compatible with the format of depthwise weights,
+ # where input is at index 3 (Output, Kh, Kw, Input)
+ # return the quantized values
+ return np.ndarray((values_as_float.shape))
+
+ shape = values_as_float.shape[0]
+ assert self.zero_point.size == self.scale_f32.size == shape
+ res = np.ndarray(values_as_float.shape)
+ for i in range(shape):
+ res[i] = (values_as_float[i] - self.zero_point[i]) * self.scale_f32[i]
+
+ return res
+
+
+class Tensor:
+ __slots__ = (
+ "shape",
+ "storage_shape",
+ "bandwidth_shape",
+ "dtype",
+ "name",
+ "ops",
+ "consumer_list",
+ "values",
+ "quant_values",
+ "compressed_values",
+ "mem_area",
+ "format",
+ "purpose",
+ "sub_purpose",
+ "alignment",
+ "weight_transpose_depthwise",
+ "storage_compression_scale",
+ "bandwidth_compression_scale",
+ "compression_scale_for_worst_weight_stream",
+ "weight_compression_scales",
+ "weight_compression_config",
+ "storage_rounding_quantum",
+ "brick_size",
+ "address",
+ "quantization",
+ "weight_compressed_offsets",
+ "element_size_bytes",
+ "reshaped",
+ "block_traversal",
+ "offset",
+ "cpu_tensor",
+ "npu_tensor",
+ "equivalence_id",
+ )
+ AllocationQuantum = 16
+
+ def __init__(self, shape, dtype, name):
+ self.shape = shape
+ self.storage_shape = shape
+ self.bandwidth_shape = shape
+ self.dtype = dtype
+ self.name = name
+ self.equivalence_id = uuid.uuid4()
+
+ self.ops = []
+ self.consumer_list = []
+ # Below attributes are only set if a tensor has been cloned,
+ # either from Cpu -> Npu or vice versa. Needed for offline allocation
+ self.cpu_tensor = None # reference to the corresponding Cpu tensor
+ self.npu_tensor = None # reference to the corresponding Npu tensor
+
+ self.values = None
+ self.quant_values = None
+ self.compressed_values = None
+ self.mem_area = MemArea.Unknown
+ self.format = TensorFormat.Unknown
+ self.purpose = TensorPurpose.Unknown
+ self.sub_purpose = TensorSubPurpose.Standard
+ self.alignment = Tensor.AllocationQuantum
+ self.weight_transpose_depthwise = False
+
+ self.storage_compression_scale = 1.0
+ self.bandwidth_compression_scale = 1.0
+ self.compression_scale_for_worst_weight_stream = 1.0
+ self.weight_compression_scales = None
+ self.weight_compression_config = None
+ self.weight_compressed_offsets = []
+ self.storage_rounding_quantum = (1, 1, 1, 1)
+ self.brick_size = (1, 1, 1, 1)
+ self.address = 0 # start address of tensor. will be filled in by tensor allocator
+ self.element_size_bytes = 0
+
+ # quantization parameters
+ self.quantization = None
+
+ self.reshaped = False
+ self.block_traversal = TensorBlockTraversal.Default
+
+ def element_size(self):
+ if self.element_size_bytes == 0:
+ return self.dtype.size_in_bits() / 8
+ return self.element_size_bytes
+
+ def clone(self, suffix="_clone"):
+ res = Tensor(self.shape, self.dtype, self.name + suffix)
+ res.storage_shape = list(self.storage_shape)
+ res.bandwidth_shape = list(self.bandwidth_shape)
+
+ res.ops = []
+ res.consumer_list = []
+ res.equivalence_id = self.equivalence_id
+
+ res.values = self.values
+ res.quant_values = self.quant_values
+ res.compressed_values = self.compressed_values
+ res.mem_area = self.mem_area
+ res.format = self.format
+ res.purpose = self.purpose
+ res.sub_purpose = self.sub_purpose
+ res.alignment = self.alignment
+ res.weight_transpose_depthwise = self.weight_transpose_depthwise
+
+ res.storage_compression_scale = self.storage_compression_scale
+ res.bandwidth_compression_scale = self.bandwidth_compression_scale
+ res.compression_scale_for_worst_weight_stream = self.compression_scale_for_worst_weight_stream
+ res.weight_compression_scales = self.weight_compression_scales
+ res.storage_rounding_quantum = self.storage_rounding_quantum
+ res.brick_size = self.brick_size
+ res.address = 0
+
+ if self.quantization is not None:
+ res.quantization = self.quantization.clone()
+ else:
+ res.quantization = None
+
+ return res
+
+ def clone_into_fast_storage(self, arch):
+ res = self.clone(suffix="_fast_storage")
+ res.mem_area = arch.fast_storage_mem_area
+ return res
+
+ def set_format(self, fmt, arch):
+ self.format = fmt
+ shape_len = 0
+ try:
+ shape_len = len(self.shape)
+ except TypeError:
+ pass
+
+ self.storage_rounding_quantum = arch.storage_rounding_quantums[self.format]
+ self.storage_rounding_quantum = self.storage_rounding_quantum[-shape_len:]
+ if self.format == TensorFormat.NHCWB16:
+ self.storage_rounding_quantum = self.storage_rounding_quantum[:-1] + (
+ int(self.storage_rounding_quantum[-1] / self.dtype.size_in_bytes()),
+ )
+ self.brick_size = arch.brick_sizes[self.format]
+ self.brick_size = self.brick_size[-shape_len:]
+ if self.shape is None:
+ return
+
+ self.bandwidth_shape = shape_round_to_quantum(self.shape, self.brick_size)
+ self.storage_shape = shape_round_to_quantum(self.shape, self.storage_rounding_quantum)
+
+ if fmt == TensorFormat.WeightsCompressed:
+ compression_ratio = 5 / 8
+ self.storage_compression_scale = compression_ratio
+ self.bandwidth_compression_scale = compression_ratio
+ self.compression_scale_for_worst_weight_stream = compression_ratio
+
+ def storage_elements(self):
+ elems = shape_num_elements(self.storage_shape)
+ if elems is None:
+ return 0
+ return elems
+
+ def elements(self):
+ elems = shape_num_elements(self.shape)
+ if elems is None:
+ return 0
+ return elems
+
+ def has_fully_defined_shape(self):
+ return shape_fully_defined(self.shape)
+
+ def storage_size(self):
+ raw_size = self.storage_elements() * self.element_size()
+ if raw_size == 0:
+ raw_size = 1 # force it to take up space
+ rounded_size = numeric_util.round_up(numeric_util.round_up_to_int(raw_size), self.alignment)
+ return rounded_size
+
+ def storage_size_for_sub_purpose(self, sub_purpose, param_a=None, param_b=None):
+ alt_shape = self.storage_shape_for_sub_purpose(sub_purpose, param_a, param_b)
+ elems = shape_num_elements(alt_shape)
+ if elems is None:
+ return 0
+ if sub_purpose == TensorSubPurpose.DoubleBuffer:
+ raw_size = elems * self.element_size() * self.compression_scale_for_worst_weight_stream
+ else:
+ raw_size = elems * self.element_size() * self.storage_compression_scale
+ rounded_size = numeric_util.round_up(numeric_util.round_up_to_int(raw_size), self.alignment)
+ return rounded_size
+
+ def storage_shape_for_sub_purpose(self, sub_purpose, param_a, param_b):
+ shp = list(self.storage_shape)
+ if sub_purpose == TensorSubPurpose.DoubleBuffer:
+ assert len(shp) >= 2
+ shp[-1] = min(shp[-1], param_a * 2)
+ elif sub_purpose == TensorSubPurpose.RollingBufferX:
+ assert len(shp) == 4
+ shp[0] = 1
+ shp[2] = min(shp[2], param_a)
+ elif sub_purpose == TensorSubPurpose.RollingBufferY:
+ assert len(shp) == 4
+ shp[0] = 1
+ shp[1] = min(shp[1], param_a)
+ elif sub_purpose == TensorSubPurpose.RollingBufferXY:
+ assert len(shp) == 4
+ shp[0] = 1
+ shp[2] = min(shp[2], param_a)
+ shp[1] = min(shp[1], param_b)
+ elif sub_purpose == TensorSubPurpose.Standard:
+ pass
+ else:
+ assert 0, "did not expect new sub purpose %s" % (sub_purpose,)
+ return shp
+
+ def set_new_sub_purpose(self, sub_purpose, param_a=None, param_b=None):
+ self.storage_shape = self.storage_shape_for_sub_purpose(sub_purpose, param_a, param_b)
+ self.sub_purpose = sub_purpose
+ if sub_purpose == TensorSubPurpose.DoubleBuffer:
+ self.storage_compression_scale = self.compression_scale_for_worst_weight_stream
+
+ def bandwidth(self):
+ elems = shape_num_elements(self.bandwidth_shape)
+ if elems is None:
+ return 0
+ return elems * self.element_size() * self.bandwidth_compression_scale
+
+ def consumers(self):
+ return self.consumer_list
+
+ def get_address_ranges_for_coordinates(self, start_coord, end_coord):
+ if self.sub_purpose in set(
+ (TensorSubPurpose.RollingBufferX, TensorSubPurpose.RollingBufferY, TensorSubPurpose.RollingBufferXY)
+ ):
+ # build dummy coordinates that cover the entire buffer
+ start_coord = [0] * len(start_coord)
+ end_coord = [min(self.storage_shape[i], self.shape[i]) for i in range(len(end_coord))]
+
+ start = self.address_for_coordinate(start_coord, is_top_box=False)
+ end = self.address_for_coordinate(end_coord, is_top_box=True)
+ return MemoryRangeSet(self.mem_area, start, end)
+
+ def addresses_for_rolling_buffer(self, start_coord, end_coord):
+ # returns ( box_height0, box_height1, box_width, [address_tl, address_tr, address_bl, address_br] )
+
+ if len(start_coord) < 4:
+ box_height0 = 1
+ box_width = 1
+
+ if len(start_coord) >= 2:
+ box_width = end_coord[-2] - start_coord[-2]
+
+ return box_height0, box_height0, box_width, [self.address_for_coordinate(start_coord), None, None, None]
+
+ crossing_y = numeric_util.round_up(start_coord[1] + 1, self.storage_shape[1])
+ crossing_x = numeric_util.round_up(start_coord[2] + 1, self.storage_shape[2])
+
+ crossing_y = min(crossing_y, end_coord[1])
+ crossing_x = min(crossing_x, end_coord[2])
+
+ box_height0 = crossing_y - start_coord[1]
+ box_width = crossing_x - start_coord[2]
+
+ addresses = [None] * 4
+ addresses[0] = self.address_for_coordinate(start_coord)
+
+ if end_coord[2] > crossing_x:
+ addresses[1] = self.address_for_coordinate([start_coord[0], start_coord[1], crossing_x, start_coord[3]])
+ raise Exception("Striping in vertical direction is not supported")
+ if end_coord[1] > crossing_y:
+ addresses[2] = self.address_for_coordinate([start_coord[0], crossing_y, start_coord[2], start_coord[3]])
+ if end_coord[1] > crossing_y and end_coord[2] > crossing_x:
+ addresses[3] = self.address_for_coordinate([start_coord[0], crossing_y, crossing_x, start_coord[3]])
+
+ return box_height0, box_height0, box_width, addresses
+
+ def address_for_coordinate(self, coord, is_top_box=False):
+ return self.address + self.address_offset_for_coordinate(coord, is_top_box)
+
+ def get_strides_and_coord(self, coord=None):
+ if coord is None:
+ coord = [0] * len(self.storage_shape)
+
+ augmented_coord = coord
+ augmented_shape = self.storage_shape
+ while len(augmented_shape) < 4:
+ augmented_shape = [1] + augmented_shape
+
+ while len(augmented_coord) < 4:
+ augmented_coord = [0] + augmented_coord
+
+ assert len(augmented_coord) == len(augmented_shape)
+
+ if self.format == TensorFormat.NHWC:
+ augmented_shape = [augmented_shape[0], augmented_shape[3]] + augmented_shape[1:3] + [1]
+ augmented_coord = [augmented_coord[0], augmented_coord[3]] + augmented_coord[1:3] + [0]
+ stride_order = [4, 1, 3, 2, 0]
+
+ elif self.format == TensorFormat.NHCWB16:
+ channel_divisor = int(16 / self.element_size())
+ augmented_shape = augmented_shape[0:4] + [1]
+ augmented_coord = (
+ [augmented_coord[0], augmented_coord[3] // channel_divisor]
+ + augmented_coord[1:3]
+ + [augmented_coord[3] % channel_divisor]
+ )
+
+ if augmented_shape[1] == 0:
+ augmented_shape[1] = 1
+
+ else:
+ assert self.format in set((TensorFormat.Unknown, TensorFormat.WeightsCompressed))
+ return None, None
+
+ strides = [0] * len(augmented_shape)
+ stride = self.element_size() * self.storage_compression_scale
+
+ if self.format != TensorFormat.NHCWB16:
+ for i in stride_order:
+ strides[i] = stride
+ stride *= augmented_shape[i]
+ else:
+ assert len(strides) == 5
+ channel_divisor = int(16 / self.element_size())
+ strides[4] = stride
+ strides[3] = channel_divisor # STRIDE_X
+ strides[1] = strides[3] * augmented_shape[2] # STRIDE_C
+ strides[2] = augmented_shape[2] * augmented_shape[3] # STRIDE_Y
+ strides[0] = strides[2] * augmented_shape[1] # STRIDE_N
+
+ return strides, augmented_coord
+
+ def get_strides(self):
+ strides, _ = self.get_strides_and_coord()
+
+ return strides
+
+ def compressed_stream_index_from_coord(self, coord):
+ assert self.format == TensorFormat.WeightsCompressed
+ assert len(self.compressed_values) > 0
+ assert len(self.compressed_values) + 1 == len(self.weight_compressed_offsets)
+
+ depth = coord[-1]
+ brick_depth = self.brick_size[-1]
+ # Clamp position at final element index
+ if depth > self.shape[-1]:
+ depth = self.shape[-1]
+
+ # Always round up to next boundary
+ index = round_up_divide(depth, brick_depth)
+
+ # Check boundaries on all but last weight set (which may be shorter
+ # than the brick we divided it up into)
+ if index < len(self.weight_compressed_offsets) - 1:
+ # There are no half-way points in the weights
+ if (depth % brick_depth) != 0:
+ raise Exception("Offset into weights must be aligned to a brick")
+
+ return index
+
+ def size_of_compressed_stream(self, index):
+ assert 0 <= index < len(self.compressed_values)
+ return len(self.compressed_values[index])
+
+ def is_last_index_in_compressed_stream(self, index):
+ assert 0 <= index < len(self.compressed_values)
+ return index == len(self.compressed_values) - 1
+
+ def address_offset_for_coordinate(self, orig_coord, is_top_box=False):
+ address_offset = 0
+ coord = orig_coord
+
+ coord = coord[-len(self.storage_shape) :]
+
+ if self.sub_purpose == TensorSubPurpose.Standard:
+ for idx, c in enumerate(coord):
+ if is_top_box:
+ assert c > 0 and c <= self.shape[idx]
+ else:
+ assert c >= 0 and c < self.shape[idx]
+
+ if self.format == TensorFormat.WeightsCompressed:
+ if len(self.weight_compressed_offsets) == 0:
+ return 0
+
+ if len(self.ops) == 1 and self.ops[0].type == "DMA" and self.sub_purpose == TensorSubPurpose.DoubleBuffer:
+ depth = orig_coord[-1]
+ brick_depth = self.brick_size[-1]
+ # Clamp position at final element index
+ if depth > self.shape[-1]:
+ depth = self.shape[-1]
+
+ # Always round up to next boundary
+ index = round_up_divide(depth, brick_depth)
+ index = index % 2
+
+ if len(self.compressed_values) <= 2:
+ if is_top_box and index == 0:
+ for cv in self.compressed_values:
+ address_offset += len(cv)
+ else:
+ address_offset = index * len(self.compressed_values[0])
+ else:
+ if is_top_box and index == 0:
+ address_offset = self.storage_shape[-1]
+ else:
+ address_offset = index * (self.storage_shape[-1] // 2)
+ else:
+ index = self.compressed_stream_index_from_coord(orig_coord)
+ assert index < len(self.weight_compressed_offsets)
+ address_offset = self.weight_compressed_offsets[index]
+ else:
+ if is_top_box:
+ coord = [c - 1 for c in coord]
+
+ # handle wraparound for partial buffers. make sure to do this after subtracting top box:
+ coord = [c % self.storage_shape[idx] for idx, c in enumerate(coord)]
+
+ strides, augmented_coord = self.get_strides_and_coord(coord)
+ if strides is None:
+ return None
+
+ if is_top_box:
+ address_offset += 1 * strides[-1] # one element
+
+ address_offset += np.dot(augmented_coord, strides)
+
+ assert address_offset >= 0
+ assert address_offset <= self.storage_size()
+ return address_offset
+
+ def __str__(self):
+ return "<nng.Tensor '%s' shape=%s dtype=%s>" % (self.name, self.shape, self.dtype)
+
+ __repr__ = __str__
diff --git a/ethosu/vela/tensor_allocation.py b/ethosu/vela/tensor_allocation.py
new file mode 100644
index 0000000..94aa608
--- /dev/null
+++ b/ethosu/vela/tensor_allocation.py
@@ -0,0 +1,139 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Wrapping function to do tensor address allocation. That is, assigning addresses to tensors based on what has been
+# worked out from the allowable overlaps that are calculated by the live range analysis.
+
+from . import live_range
+from .tensor import MemArea
+import math
+from . import numeric_util
+import numpy as np
+from .nn_graph import TensorAllocator, PassPlacement
+
+from .greedy_allocation import allocate_live_ranges as greedy_allocate_live_ranges
+
+
+def linear_allocate_live_ranges(live_ranges, alloc_granularity=256):
+ total_sz = 0
+ allocated_tensors = []
+
+ # just assign increasing addresses
+ for tens, lr in live_ranges.ranges.items():
+ if tens in allocated_tensors:
+ continue
+
+ lr.set_address(total_sz)
+ allocated_tensors += lr.tensors
+ total_sz += numeric_util.round_up(int(math.ceil(lr.size)), alloc_granularity)
+
+ return total_sz
+
+
+def mark_sram_used_for_cascaded_passes(sg, lrs):
+ end_pos = max(ps.time for ps in sg.cascaded_passes) + 2
+ mem_usage = np.zeros(end_pos, dtype=np.int64)
+
+ for tens, rng in lrs.ranges.items():
+ storage_size = tens.storage_size()
+ mem_usage[rng.start_time : rng.end_time] += storage_size
+
+ for cps in sg.cascaded_passes:
+ sram_used = max(mem_usage[cps.time], mem_usage[cps.time + 1])
+ cps.sram_used = sram_used
+ for ps in cps.passes:
+ ps.sram_used = sram_used
+
+
+def print_allocation(lrs, mem_area, sg, verbose_allocation, show_minimum_possible_allocation):
+ if verbose_allocation:
+ if mem_area == MemArea.Sram:
+ print("allocation for", mem_area, "- non-constant tensors in Cpu and Npu subgraphs")
+ else:
+ print("allocation for", mem_area, "- constant tensors in", sg.placement.name, "subgraph(s)")
+ for start_time, start, end, name, end_time in sorted(
+ (
+ lr.start_time,
+ tens.address,
+ tens.address + int(math.ceil(tens.storage_size())),
+ tens.name + " " + str(tens.purpose),
+ lr.end_time,
+ )
+ for tens, lr in lrs.ranges.items()
+ ):
+ name = name.replace("\x00", "")
+ print("%9d: %#12x - %#12x: %3d - %3d %s" % ((end - start), start, end, start_time, end_time, name))
+ print()
+
+ if show_minimum_possible_allocation and mem_area == MemArea.Sram:
+ min_possible_allocation = max(cps.sram_used for cps in sg.cascaded_passes)
+ print(
+ "Min possible allocation %d bytes / %.1f KB / %.1f MB"
+ % (min_possible_allocation, min_possible_allocation / 1024, min_possible_allocation / 1024 / 1024)
+ )
+
+
+def allocate_tensors(
+ nng,
+ sg,
+ arch,
+ mem_area,
+ use_ifm_ofm_overlap=True,
+ tensor_allocator=TensorAllocator.Greedy,
+ verbose_allocation=False,
+ show_minimum_possible_allocation=False,
+ lr_graph=None,
+):
+ ignore_subgraph_input_output_tensors = False
+ lrs = live_range.extract_live_ranges_from_cascaded_passes(
+ sg,
+ mem_area,
+ mark_output_tensors_overlapping_with_input_tensors=False,
+ use_ifm_ofm_overlap=use_ifm_ofm_overlap,
+ ignore_subgraph_input_output_tensors=ignore_subgraph_input_output_tensors,
+ lr_graph=lr_graph,
+ )
+
+ if lrs.ranges:
+ tens_alloc = tensor_allocator
+ if tens_alloc == TensorAllocator.Greedy:
+ total_sz = greedy_allocate_live_ranges(sg, arch, lrs, mem_area, verbose_allocation)
+ elif tens_alloc == TensorAllocator.LinearAlloc:
+ total_sz = linear_allocate_live_ranges(lrs)
+ else:
+ assert 0
+
+ sg.memory_used[mem_area] = total_sz
+
+ nng.total_size[mem_area] = nng.total_size.get(mem_area, 0) + sum(tens.storage_size() for tens in lrs.ranges)
+ nng.total_elements[mem_area] = nng.total_elements.get(mem_area, 0) + sum(tens.elements() for tens in lrs.ranges)
+
+ print_allocation(lrs, mem_area, sg, verbose_allocation, show_minimum_possible_allocation)
+
+ if mem_area == MemArea.Sram:
+ # Mark Sram usage for all subgraphs
+ for sg_ in nng.subgraphs:
+ mark_sram_used_for_cascaded_passes(sg_, lrs)
+
+ if sg == nng.get_root_subgraph():
+ nng.memory_used = sg.memory_used
+ for mem_area in nng.total_elements.keys():
+ try:
+ nng.bits_per_element[mem_area] = nng.total_size[mem_area] * 8 / nng.total_elements[mem_area]
+ except ZeroDivisionError:
+ nng.bits_per_element[mem_area] = 0.0
diff --git a/ethosu/vela/tflite/AbsOptions.py b/ethosu/vela/tflite/AbsOptions.py
new file mode 100644
index 0000000..0cbfb8c
--- /dev/null
+++ b/ethosu/vela/tflite/AbsOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class AbsOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsAbsOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = AbsOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # AbsOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def AbsOptionsStart(builder): builder.StartObject(0)
+def AbsOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ActivationFunctionType.py b/ethosu/vela/tflite/ActivationFunctionType.py
new file mode 100644
index 0000000..6d8ec95
--- /dev/null
+++ b/ethosu/vela/tflite/ActivationFunctionType.py
@@ -0,0 +1,11 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class ActivationFunctionType(object):
+ NONE = 0
+ RELU = 1
+ RELU_N1_TO_1 = 2
+ RELU6 = 3
+ TANH = 4
+ SIGN_BIT = 5
diff --git a/ethosu/vela/tflite/AddNOptions.py b/ethosu/vela/tflite/AddNOptions.py
new file mode 100644
index 0000000..b5c2ddb
--- /dev/null
+++ b/ethosu/vela/tflite/AddNOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class AddNOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsAddNOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = AddNOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # AddNOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def AddNOptionsStart(builder): builder.StartObject(0)
+def AddNOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/AddOptions.py b/ethosu/vela/tflite/AddOptions.py
new file mode 100644
index 0000000..d6cbfcf
--- /dev/null
+++ b/ethosu/vela/tflite/AddOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class AddOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsAddOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = AddOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # AddOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # AddOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def AddOptionsStart(builder): builder.StartObject(1)
+def AddOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def AddOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ArgMaxOptions.py b/ethosu/vela/tflite/ArgMaxOptions.py
new file mode 100644
index 0000000..fbf1415
--- /dev/null
+++ b/ethosu/vela/tflite/ArgMaxOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ArgMaxOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsArgMaxOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ArgMaxOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ArgMaxOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ArgMaxOptions
+ def OutputType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def ArgMaxOptionsStart(builder): builder.StartObject(1)
+def ArgMaxOptionsAddOutputType(builder, outputType): builder.PrependInt8Slot(0, outputType, 0)
+def ArgMaxOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ArgMinOptions.py b/ethosu/vela/tflite/ArgMinOptions.py
new file mode 100644
index 0000000..120fdca
--- /dev/null
+++ b/ethosu/vela/tflite/ArgMinOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ArgMinOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsArgMinOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ArgMinOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ArgMinOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ArgMinOptions
+ def OutputType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def ArgMinOptionsStart(builder): builder.StartObject(1)
+def ArgMinOptionsAddOutputType(builder, outputType): builder.PrependInt8Slot(0, outputType, 0)
+def ArgMinOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/BatchToSpaceNDOptions.py b/ethosu/vela/tflite/BatchToSpaceNDOptions.py
new file mode 100644
index 0000000..3ddcfd3
--- /dev/null
+++ b/ethosu/vela/tflite/BatchToSpaceNDOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class BatchToSpaceNDOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsBatchToSpaceNDOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = BatchToSpaceNDOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # BatchToSpaceNDOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def BatchToSpaceNDOptionsStart(builder): builder.StartObject(0)
+def BatchToSpaceNDOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/BidirectionalSequenceLSTMOptions.py b/ethosu/vela/tflite/BidirectionalSequenceLSTMOptions.py
new file mode 100644
index 0000000..8d8b7be
--- /dev/null
+++ b/ethosu/vela/tflite/BidirectionalSequenceLSTMOptions.py
@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class BidirectionalSequenceLSTMOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsBidirectionalSequenceLSTMOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = BidirectionalSequenceLSTMOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # BidirectionalSequenceLSTMOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # BidirectionalSequenceLSTMOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # BidirectionalSequenceLSTMOptions
+ def CellClip(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
+
+ # BidirectionalSequenceLSTMOptions
+ def ProjClip(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
+
+ # BidirectionalSequenceLSTMOptions
+ def MergeOutputs(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
+
+ # BidirectionalSequenceLSTMOptions
+ def TimeMajor(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 True
+
+def BidirectionalSequenceLSTMOptionsStart(builder): builder.StartObject(5)
+def BidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def BidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0)
+def BidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0)
+def BidirectionalSequenceLSTMOptionsAddMergeOutputs(builder, mergeOutputs): builder.PrependBoolSlot(3, mergeOutputs, 0)
+def BidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(4, timeMajor, 1)
+def BidirectionalSequenceLSTMOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/BidirectionalSequenceRNNOptions.py b/ethosu/vela/tflite/BidirectionalSequenceRNNOptions.py
new file mode 100644
index 0000000..673af6b
--- /dev/null
+++ b/ethosu/vela/tflite/BidirectionalSequenceRNNOptions.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class BidirectionalSequenceRNNOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsBidirectionalSequenceRNNOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = BidirectionalSequenceRNNOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # BidirectionalSequenceRNNOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # BidirectionalSequenceRNNOptions
+ def TimeMajor(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+ return False
+
+ # BidirectionalSequenceRNNOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # BidirectionalSequenceRNNOptions
+ def MergeOutputs(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+ return False
+
+def BidirectionalSequenceRNNOptionsStart(builder): builder.StartObject(3)
+def BidirectionalSequenceRNNOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(0, timeMajor, 0)
+def BidirectionalSequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0)
+def BidirectionalSequenceRNNOptionsAddMergeOutputs(builder, mergeOutputs): builder.PrependBoolSlot(2, mergeOutputs, 0)
+def BidirectionalSequenceRNNOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Buffer.py b/ethosu/vela/tflite/Buffer.py
new file mode 100644
index 0000000..754dee3
--- /dev/null
+++ b/ethosu/vela/tflite/Buffer.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Buffer(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsBuffer(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Buffer()
+ x.Init(buf, n + offset)
+ return x
+
+ # Buffer
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Buffer
+ def Data(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.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+ return 0
+
+ # Buffer
+ def DataAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+ return 0
+
+ # Buffer
+ def DataLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def BufferStart(builder): builder.StartObject(1)
+def BufferAddData(builder, data): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(data), 0)
+def BufferStartDataVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def BufferEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/BuiltinOperator.py b/ethosu/vela/tflite/BuiltinOperator.py
new file mode 100644
index 0000000..2713653
--- /dev/null
+++ b/ethosu/vela/tflite/BuiltinOperator.py
@@ -0,0 +1,131 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class BuiltinOperator(object):
+ ADD = 0
+ AVERAGE_POOL_2D = 1
+ CONCATENATION = 2
+ CONV_2D = 3
+ DEPTHWISE_CONV_2D = 4
+ DEPTH_TO_SPACE = 5
+ DEQUANTIZE = 6
+ EMBEDDING_LOOKUP = 7
+ FLOOR = 8
+ FULLY_CONNECTED = 9
+ HASHTABLE_LOOKUP = 10
+ L2_NORMALIZATION = 11
+ L2_POOL_2D = 12
+ LOCAL_RESPONSE_NORMALIZATION = 13
+ LOGISTIC = 14
+ LSH_PROJECTION = 15
+ LSTM = 16
+ MAX_POOL_2D = 17
+ MUL = 18
+ RELU = 19
+ RELU_N1_TO_1 = 20
+ RELU6 = 21
+ RESHAPE = 22
+ RESIZE_BILINEAR = 23
+ RNN = 24
+ SOFTMAX = 25
+ SPACE_TO_DEPTH = 26
+ SVDF = 27
+ TANH = 28
+ CONCAT_EMBEDDINGS = 29
+ SKIP_GRAM = 30
+ CALL = 31
+ CUSTOM = 32
+ EMBEDDING_LOOKUP_SPARSE = 33
+ PAD = 34
+ UNIDIRECTIONAL_SEQUENCE_RNN = 35
+ GATHER = 36
+ BATCH_TO_SPACE_ND = 37
+ SPACE_TO_BATCH_ND = 38
+ TRANSPOSE = 39
+ MEAN = 40
+ SUB = 41
+ DIV = 42
+ SQUEEZE = 43
+ UNIDIRECTIONAL_SEQUENCE_LSTM = 44
+ STRIDED_SLICE = 45
+ BIDIRECTIONAL_SEQUENCE_RNN = 46
+ EXP = 47
+ TOPK_V2 = 48
+ SPLIT = 49
+ LOG_SOFTMAX = 50
+ DELEGATE = 51
+ BIDIRECTIONAL_SEQUENCE_LSTM = 52
+ CAST = 53
+ PRELU = 54
+ MAXIMUM = 55
+ ARG_MAX = 56
+ MINIMUM = 57
+ LESS = 58
+ NEG = 59
+ PADV2 = 60
+ GREATER = 61
+ GREATER_EQUAL = 62
+ LESS_EQUAL = 63
+ SELECT = 64
+ SLICE = 65
+ SIN = 66
+ TRANSPOSE_CONV = 67
+ SPARSE_TO_DENSE = 68
+ TILE = 69
+ EXPAND_DIMS = 70
+ EQUAL = 71
+ NOT_EQUAL = 72
+ LOG = 73
+ SUM = 74
+ SQRT = 75
+ RSQRT = 76
+ SHAPE = 77
+ POW = 78
+ ARG_MIN = 79
+ FAKE_QUANT = 80
+ REDUCE_PROD = 81
+ REDUCE_MAX = 82
+ PACK = 83
+ LOGICAL_OR = 84
+ ONE_HOT = 85
+ LOGICAL_AND = 86
+ LOGICAL_NOT = 87
+ UNPACK = 88
+ REDUCE_MIN = 89
+ FLOOR_DIV = 90
+ REDUCE_ANY = 91
+ SQUARE = 92
+ ZEROS_LIKE = 93
+ FILL = 94
+ FLOOR_MOD = 95
+ RANGE = 96
+ RESIZE_NEAREST_NEIGHBOR = 97
+ LEAKY_RELU = 98
+ SQUARED_DIFFERENCE = 99
+ MIRROR_PAD = 100
+ ABS = 101
+ SPLIT_V = 102
+ UNIQUE = 103
+ CEIL = 104
+ REVERSE_V2 = 105
+ ADD_N = 106
+ GATHER_ND = 107
+ COS = 108
+ WHERE = 109
+ RANK = 110
+ ELU = 111
+ REVERSE_SEQUENCE = 112
+ MATRIX_DIAG = 113
+ QUANTIZE = 114
+ MATRIX_SET_DIAG = 115
+ ROUND = 116
+ HARD_SWISH = 117
+ IF = 118
+ WHILE = 119
+ NON_MAX_SUPPRESSION_V4 = 120
+ NON_MAX_SUPPRESSION_V5 = 121
+ SCATTER_ND = 122
+ SELECT_V2 = 123
+ DENSIFY = 124
+ SEGMENT_SUM = 125
diff --git a/ethosu/vela/tflite/BuiltinOptions.py b/ethosu/vela/tflite/BuiltinOptions.py
new file mode 100644
index 0000000..babbcb1
--- /dev/null
+++ b/ethosu/vela/tflite/BuiltinOptions.py
@@ -0,0 +1,106 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class BuiltinOptions(object):
+ NONE = 0
+ Conv2DOptions = 1
+ DepthwiseConv2DOptions = 2
+ ConcatEmbeddingsOptions = 3
+ LSHProjectionOptions = 4
+ Pool2DOptions = 5
+ SVDFOptions = 6
+ RNNOptions = 7
+ FullyConnectedOptions = 8
+ SoftmaxOptions = 9
+ ConcatenationOptions = 10
+ AddOptions = 11
+ L2NormOptions = 12
+ LocalResponseNormalizationOptions = 13
+ LSTMOptions = 14
+ ResizeBilinearOptions = 15
+ CallOptions = 16
+ ReshapeOptions = 17
+ SkipGramOptions = 18
+ SpaceToDepthOptions = 19
+ EmbeddingLookupSparseOptions = 20
+ MulOptions = 21
+ PadOptions = 22
+ GatherOptions = 23
+ BatchToSpaceNDOptions = 24
+ SpaceToBatchNDOptions = 25
+ TransposeOptions = 26
+ ReducerOptions = 27
+ SubOptions = 28
+ DivOptions = 29
+ SqueezeOptions = 30
+ SequenceRNNOptions = 31
+ StridedSliceOptions = 32
+ ExpOptions = 33
+ TopKV2Options = 34
+ SplitOptions = 35
+ LogSoftmaxOptions = 36
+ CastOptions = 37
+ DequantizeOptions = 38
+ MaximumMinimumOptions = 39
+ ArgMaxOptions = 40
+ LessOptions = 41
+ NegOptions = 42
+ PadV2Options = 43
+ GreaterOptions = 44
+ GreaterEqualOptions = 45
+ LessEqualOptions = 46
+ SelectOptions = 47
+ SliceOptions = 48
+ TransposeConvOptions = 49
+ SparseToDenseOptions = 50
+ TileOptions = 51
+ ExpandDimsOptions = 52
+ EqualOptions = 53
+ NotEqualOptions = 54
+ ShapeOptions = 55
+ PowOptions = 56
+ ArgMinOptions = 57
+ FakeQuantOptions = 58
+ PackOptions = 59
+ LogicalOrOptions = 60
+ OneHotOptions = 61
+ LogicalAndOptions = 62
+ LogicalNotOptions = 63
+ UnpackOptions = 64
+ FloorDivOptions = 65
+ SquareOptions = 66
+ ZerosLikeOptions = 67
+ FillOptions = 68
+ BidirectionalSequenceLSTMOptions = 69
+ BidirectionalSequenceRNNOptions = 70
+ UnidirectionalSequenceLSTMOptions = 71
+ FloorModOptions = 72
+ RangeOptions = 73
+ ResizeNearestNeighborOptions = 74
+ LeakyReluOptions = 75
+ SquaredDifferenceOptions = 76
+ MirrorPadOptions = 77
+ AbsOptions = 78
+ SplitVOptions = 79
+ UniqueOptions = 80
+ ReverseV2Options = 81
+ AddNOptions = 82
+ GatherNdOptions = 83
+ CosOptions = 84
+ WhereOptions = 85
+ RankOptions = 86
+ ReverseSequenceOptions = 87
+ MatrixDiagOptions = 88
+ QuantizeOptions = 89
+ MatrixSetDiagOptions = 90
+ HardSwishOptions = 91
+ IfOptions = 92
+ WhileOptions = 93
+ DepthToSpaceOptions = 94
+ NonMaxSuppressionV4Options = 95
+ NonMaxSuppressionV5Options = 96
+ ScatterNdOptions = 97
+ SelectV2Options = 98
+ DensifyOptions = 99
+ SegmentSumOptions = 100
diff --git a/ethosu/vela/tflite/CallOptions.py b/ethosu/vela/tflite/CallOptions.py
new file mode 100644
index 0000000..5ae2eea
--- /dev/null
+++ b/ethosu/vela/tflite/CallOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class CallOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsCallOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = CallOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # CallOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # CallOptions
+ def Subgraph(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
+
+def CallOptionsStart(builder): builder.StartObject(1)
+def CallOptionsAddSubgraph(builder, subgraph): builder.PrependUint32Slot(0, subgraph, 0)
+def CallOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/CastOptions.py b/ethosu/vela/tflite/CastOptions.py
new file mode 100644
index 0000000..70ae2e3
--- /dev/null
+++ b/ethosu/vela/tflite/CastOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class CastOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsCastOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = CastOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # CastOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # CastOptions
+ def InDataType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # CastOptions
+ def OutDataType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def CastOptionsStart(builder): builder.StartObject(2)
+def CastOptionsAddInDataType(builder, inDataType): builder.PrependInt8Slot(0, inDataType, 0)
+def CastOptionsAddOutDataType(builder, outDataType): builder.PrependInt8Slot(1, outDataType, 0)
+def CastOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/CombinerType.py b/ethosu/vela/tflite/CombinerType.py
new file mode 100644
index 0000000..1e3a61f
--- /dev/null
+++ b/ethosu/vela/tflite/CombinerType.py
@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class CombinerType(object):
+ SUM = 0
+ MEAN = 1
+ SQRTN = 2
diff --git a/ethosu/vela/tflite/ConcatEmbeddingsOptions.py b/ethosu/vela/tflite/ConcatEmbeddingsOptions.py
new file mode 100644
index 0000000..9d26c51
--- /dev/null
+++ b/ethosu/vela/tflite/ConcatEmbeddingsOptions.py
@@ -0,0 +1,78 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ConcatEmbeddingsOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsConcatEmbeddingsOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ConcatEmbeddingsOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ConcatEmbeddingsOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ConcatEmbeddingsOptions
+ def NumChannels(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
+
+ # ConcatEmbeddingsOptions
+ def NumColumnsPerChannel(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
+
+ # ConcatEmbeddingsOptions
+ def NumColumnsPerChannelAsNumpy(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
+
+ # ConcatEmbeddingsOptions
+ def NumColumnsPerChannelLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # ConcatEmbeddingsOptions
+ def EmbeddingDimPerChannel(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
+
+ # ConcatEmbeddingsOptions
+ def EmbeddingDimPerChannelAsNumpy(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
+
+ # ConcatEmbeddingsOptions
+ def EmbeddingDimPerChannelLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def ConcatEmbeddingsOptionsStart(builder): builder.StartObject(3)
+def ConcatEmbeddingsOptionsAddNumChannels(builder, numChannels): builder.PrependInt32Slot(0, numChannels, 0)
+def ConcatEmbeddingsOptionsAddNumColumnsPerChannel(builder, numColumnsPerChannel): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(numColumnsPerChannel), 0)
+def ConcatEmbeddingsOptionsStartNumColumnsPerChannelVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def ConcatEmbeddingsOptionsAddEmbeddingDimPerChannel(builder, embeddingDimPerChannel): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(embeddingDimPerChannel), 0)
+def ConcatEmbeddingsOptionsStartEmbeddingDimPerChannelVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def ConcatEmbeddingsOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ConcatenationOptions.py b/ethosu/vela/tflite/ConcatenationOptions.py
new file mode 100644
index 0000000..c8e0b6a
--- /dev/null
+++ b/ethosu/vela/tflite/ConcatenationOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ConcatenationOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsConcatenationOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ConcatenationOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ConcatenationOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ConcatenationOptions
+ 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
+
+ # ConcatenationOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def ConcatenationOptionsStart(builder): builder.StartObject(2)
+def ConcatenationOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0)
+def ConcatenationOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0)
+def ConcatenationOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Conv2DOptions.py b/ethosu/vela/tflite/Conv2DOptions.py
new file mode 100644
index 0000000..ef49f75
--- /dev/null
+++ b/ethosu/vela/tflite/Conv2DOptions.py
@@ -0,0 +1,70 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Conv2DOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsConv2DOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Conv2DOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # Conv2DOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Conv2DOptions
+ def Padding(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # Conv2DOptions
+ def StrideW(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
+
+ # Conv2DOptions
+ def StrideH(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
+
+ # Conv2DOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # Conv2DOptions
+ def DilationWFactor(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+ return 1
+
+ # Conv2DOptions
+ def DilationHFactor(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+ return 1
+
+def Conv2DOptionsStart(builder): builder.StartObject(6)
+def Conv2DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0)
+def Conv2DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0)
+def Conv2DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0)
+def Conv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(3, fusedActivationFunction, 0)
+def Conv2DOptionsAddDilationWFactor(builder, dilationWFactor): builder.PrependInt32Slot(4, dilationWFactor, 1)
+def Conv2DOptionsAddDilationHFactor(builder, dilationHFactor): builder.PrependInt32Slot(5, dilationHFactor, 1)
+def Conv2DOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/CosOptions.py b/ethosu/vela/tflite/CosOptions.py
new file mode 100644
index 0000000..7fbf848
--- /dev/null
+++ b/ethosu/vela/tflite/CosOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class CosOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsCosOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = CosOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # CosOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def CosOptionsStart(builder): builder.StartObject(0)
+def CosOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/CustomOptionsFormat.py b/ethosu/vela/tflite/CustomOptionsFormat.py
new file mode 100644
index 0000000..c2fc07c
--- /dev/null
+++ b/ethosu/vela/tflite/CustomOptionsFormat.py
@@ -0,0 +1,6 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class CustomOptionsFormat(object):
+ FLEXBUFFERS = 0
diff --git a/ethosu/vela/tflite/CustomQuantization.py b/ethosu/vela/tflite/CustomQuantization.py
new file mode 100644
index 0000000..21ec0da
--- /dev/null
+++ b/ethosu/vela/tflite/CustomQuantization.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class CustomQuantization(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsCustomQuantization(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = CustomQuantization()
+ x.Init(buf, n + offset)
+ return x
+
+ # CustomQuantization
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # CustomQuantization
+ def Custom(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.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+ return 0
+
+ # CustomQuantization
+ def CustomAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+ return 0
+
+ # CustomQuantization
+ def CustomLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def CustomQuantizationStart(builder): builder.StartObject(1)
+def CustomQuantizationAddCustom(builder, custom): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(custom), 0)
+def CustomQuantizationStartCustomVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def CustomQuantizationEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/DensifyOptions.py b/ethosu/vela/tflite/DensifyOptions.py
new file mode 100644
index 0000000..12cbfb2
--- /dev/null
+++ b/ethosu/vela/tflite/DensifyOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class DensifyOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsDensifyOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DensifyOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # DensifyOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def DensifyOptionsStart(builder): builder.StartObject(0)
+def DensifyOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/DepthToSpaceOptions.py b/ethosu/vela/tflite/DepthToSpaceOptions.py
new file mode 100644
index 0000000..97b93aa
--- /dev/null
+++ b/ethosu/vela/tflite/DepthToSpaceOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class DepthToSpaceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsDepthToSpaceOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DepthToSpaceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # DepthToSpaceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # DepthToSpaceOptions
+ def BlockSize(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 DepthToSpaceOptionsStart(builder): builder.StartObject(1)
+def DepthToSpaceOptionsAddBlockSize(builder, blockSize): builder.PrependInt32Slot(0, blockSize, 0)
+def DepthToSpaceOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/DepthwiseConv2DOptions.py b/ethosu/vela/tflite/DepthwiseConv2DOptions.py
new file mode 100644
index 0000000..9689383
--- /dev/null
+++ b/ethosu/vela/tflite/DepthwiseConv2DOptions.py
@@ -0,0 +1,78 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class DepthwiseConv2DOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsDepthwiseConv2DOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DepthwiseConv2DOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # DepthwiseConv2DOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # DepthwiseConv2DOptions
+ def Padding(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # DepthwiseConv2DOptions
+ def StrideW(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
+
+ # DepthwiseConv2DOptions
+ def StrideH(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
+
+ # DepthwiseConv2DOptions
+ def DepthMultiplier(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
+
+ # DepthwiseConv2DOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # DepthwiseConv2DOptions
+ def DilationWFactor(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+ return 1
+
+ # DepthwiseConv2DOptions
+ def DilationHFactor(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+ return 1
+
+def DepthwiseConv2DOptionsStart(builder): builder.StartObject(7)
+def DepthwiseConv2DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0)
+def DepthwiseConv2DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0)
+def DepthwiseConv2DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0)
+def DepthwiseConv2DOptionsAddDepthMultiplier(builder, depthMultiplier): builder.PrependInt32Slot(3, depthMultiplier, 0)
+def DepthwiseConv2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(4, fusedActivationFunction, 0)
+def DepthwiseConv2DOptionsAddDilationWFactor(builder, dilationWFactor): builder.PrependInt32Slot(5, dilationWFactor, 1)
+def DepthwiseConv2DOptionsAddDilationHFactor(builder, dilationHFactor): builder.PrependInt32Slot(6, dilationHFactor, 1)
+def DepthwiseConv2DOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/DequantizeOptions.py b/ethosu/vela/tflite/DequantizeOptions.py
new file mode 100644
index 0000000..5ef8b8d
--- /dev/null
+++ b/ethosu/vela/tflite/DequantizeOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class DequantizeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsDequantizeOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DequantizeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # DequantizeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def DequantizeOptionsStart(builder): builder.StartObject(0)
+def DequantizeOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/DimensionMetadata.py b/ethosu/vela/tflite/DimensionMetadata.py
new file mode 100644
index 0000000..c9fe7cd
--- /dev/null
+++ b/ethosu/vela/tflite/DimensionMetadata.py
@@ -0,0 +1,76 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class DimensionMetadata(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsDimensionMetadata(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DimensionMetadata()
+ x.Init(buf, n + offset)
+ return x
+
+ # DimensionMetadata
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # DimensionMetadata
+ def Format(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # DimensionMetadata
+ def DenseSize(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
+
+ # DimensionMetadata
+ def ArraySegmentsType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+ return 0
+
+ # DimensionMetadata
+ def ArraySegments(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ from flatbuffers.table import Table
+ obj = Table(bytearray(), 0)
+ self._tab.Union(obj, o)
+ return obj
+ return None
+
+ # DimensionMetadata
+ def ArrayIndicesType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+ return 0
+
+ # DimensionMetadata
+ def ArrayIndices(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ from flatbuffers.table import Table
+ obj = Table(bytearray(), 0)
+ self._tab.Union(obj, o)
+ return obj
+ return None
+
+def DimensionMetadataStart(builder): builder.StartObject(6)
+def DimensionMetadataAddFormat(builder, format): builder.PrependInt8Slot(0, format, 0)
+def DimensionMetadataAddDenseSize(builder, denseSize): builder.PrependInt32Slot(1, denseSize, 0)
+def DimensionMetadataAddArraySegmentsType(builder, arraySegmentsType): builder.PrependUint8Slot(2, arraySegmentsType, 0)
+def DimensionMetadataAddArraySegments(builder, arraySegments): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(arraySegments), 0)
+def DimensionMetadataAddArrayIndicesType(builder, arrayIndicesType): builder.PrependUint8Slot(4, arrayIndicesType, 0)
+def DimensionMetadataAddArrayIndices(builder, arrayIndices): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(arrayIndices), 0)
+def DimensionMetadataEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/DimensionType.py b/ethosu/vela/tflite/DimensionType.py
new file mode 100644
index 0000000..310d8ee
--- /dev/null
+++ b/ethosu/vela/tflite/DimensionType.py
@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class DimensionType(object):
+ DENSE = 0
+ SPARSE_CSR = 1
diff --git a/ethosu/vela/tflite/DivOptions.py b/ethosu/vela/tflite/DivOptions.py
new file mode 100644
index 0000000..905a3be
--- /dev/null
+++ b/ethosu/vela/tflite/DivOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class DivOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsDivOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = DivOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # DivOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # DivOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def DivOptionsStart(builder): builder.StartObject(1)
+def DivOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def DivOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/EmbeddingLookupSparseOptions.py b/ethosu/vela/tflite/EmbeddingLookupSparseOptions.py
new file mode 100644
index 0000000..7d9c144
--- /dev/null
+++ b/ethosu/vela/tflite/EmbeddingLookupSparseOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class EmbeddingLookupSparseOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsEmbeddingLookupSparseOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = EmbeddingLookupSparseOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # EmbeddingLookupSparseOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # EmbeddingLookupSparseOptions
+ def Combiner(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def EmbeddingLookupSparseOptionsStart(builder): builder.StartObject(1)
+def EmbeddingLookupSparseOptionsAddCombiner(builder, combiner): builder.PrependInt8Slot(0, combiner, 0)
+def EmbeddingLookupSparseOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/EqualOptions.py b/ethosu/vela/tflite/EqualOptions.py
new file mode 100644
index 0000000..f787ef8
--- /dev/null
+++ b/ethosu/vela/tflite/EqualOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class EqualOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsEqualOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = EqualOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # EqualOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def EqualOptionsStart(builder): builder.StartObject(0)
+def EqualOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ExpOptions.py b/ethosu/vela/tflite/ExpOptions.py
new file mode 100644
index 0000000..eac1456
--- /dev/null
+++ b/ethosu/vela/tflite/ExpOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ExpOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsExpOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ExpOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ExpOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ExpOptionsStart(builder): builder.StartObject(0)
+def ExpOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ExpandDimsOptions.py b/ethosu/vela/tflite/ExpandDimsOptions.py
new file mode 100644
index 0000000..69d6366
--- /dev/null
+++ b/ethosu/vela/tflite/ExpandDimsOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ExpandDimsOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsExpandDimsOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ExpandDimsOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ExpandDimsOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ExpandDimsOptionsStart(builder): builder.StartObject(0)
+def ExpandDimsOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/FakeQuantOptions.py b/ethosu/vela/tflite/FakeQuantOptions.py
new file mode 100644
index 0000000..46c371c
--- /dev/null
+++ b/ethosu/vela/tflite/FakeQuantOptions.py
@@ -0,0 +1,54 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class FakeQuantOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsFakeQuantOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FakeQuantOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # FakeQuantOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # FakeQuantOptions
+ def Min(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+ return 0.0
+
+ # FakeQuantOptions
+ def Max(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
+
+ # FakeQuantOptions
+ def NumBits(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
+
+ # FakeQuantOptions
+ def NarrowRange(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 FakeQuantOptionsStart(builder): builder.StartObject(4)
+def FakeQuantOptionsAddMin(builder, min): builder.PrependFloat32Slot(0, min, 0.0)
+def FakeQuantOptionsAddMax(builder, max): builder.PrependFloat32Slot(1, max, 0.0)
+def FakeQuantOptionsAddNumBits(builder, numBits): builder.PrependInt32Slot(2, numBits, 0)
+def FakeQuantOptionsAddNarrowRange(builder, narrowRange): builder.PrependBoolSlot(3, narrowRange, 0)
+def FakeQuantOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/FillOptions.py b/ethosu/vela/tflite/FillOptions.py
new file mode 100644
index 0000000..5a1e651
--- /dev/null
+++ b/ethosu/vela/tflite/FillOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class FillOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsFillOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FillOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # FillOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def FillOptionsStart(builder): builder.StartObject(0)
+def FillOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/FloorDivOptions.py b/ethosu/vela/tflite/FloorDivOptions.py
new file mode 100644
index 0000000..64b474f
--- /dev/null
+++ b/ethosu/vela/tflite/FloorDivOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class FloorDivOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsFloorDivOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FloorDivOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # FloorDivOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def FloorDivOptionsStart(builder): builder.StartObject(0)
+def FloorDivOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/FloorModOptions.py b/ethosu/vela/tflite/FloorModOptions.py
new file mode 100644
index 0000000..37c8e5a
--- /dev/null
+++ b/ethosu/vela/tflite/FloorModOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class FloorModOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsFloorModOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FloorModOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # FloorModOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def FloorModOptionsStart(builder): builder.StartObject(0)
+def FloorModOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/FullyConnectedOptions.py b/ethosu/vela/tflite/FullyConnectedOptions.py
new file mode 100644
index 0000000..a6b4e40
--- /dev/null
+++ b/ethosu/vela/tflite/FullyConnectedOptions.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class FullyConnectedOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsFullyConnectedOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = FullyConnectedOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # FullyConnectedOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # FullyConnectedOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # FullyConnectedOptions
+ def WeightsFormat(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # FullyConnectedOptions
+ def KeepNumDims(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+ return False
+
+def FullyConnectedOptionsStart(builder): builder.StartObject(3)
+def FullyConnectedOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def FullyConnectedOptionsAddWeightsFormat(builder, weightsFormat): builder.PrependInt8Slot(1, weightsFormat, 0)
+def FullyConnectedOptionsAddKeepNumDims(builder, keepNumDims): builder.PrependBoolSlot(2, keepNumDims, 0)
+def FullyConnectedOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/FullyConnectedOptionsWeightsFormat.py b/ethosu/vela/tflite/FullyConnectedOptionsWeightsFormat.py
new file mode 100644
index 0000000..d9a5388
--- /dev/null
+++ b/ethosu/vela/tflite/FullyConnectedOptionsWeightsFormat.py
@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class FullyConnectedOptionsWeightsFormat(object):
+ DEFAULT = 0
+ SHUFFLED4x16INT8 = 1
diff --git a/ethosu/vela/tflite/GatherNdOptions.py b/ethosu/vela/tflite/GatherNdOptions.py
new file mode 100644
index 0000000..f515eb5
--- /dev/null
+++ b/ethosu/vela/tflite/GatherNdOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class GatherNdOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsGatherNdOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = GatherNdOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # GatherNdOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def GatherNdOptionsStart(builder): builder.StartObject(0)
+def GatherNdOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/GatherOptions.py b/ethosu/vela/tflite/GatherOptions.py
new file mode 100644
index 0000000..9fbc3e4
--- /dev/null
+++ b/ethosu/vela/tflite/GatherOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class GatherOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsGatherOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = GatherOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # GatherOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # GatherOptions
+ 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 GatherOptionsStart(builder): builder.StartObject(1)
+def GatherOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0)
+def GatherOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/GreaterEqualOptions.py b/ethosu/vela/tflite/GreaterEqualOptions.py
new file mode 100644
index 0000000..a29e200
--- /dev/null
+++ b/ethosu/vela/tflite/GreaterEqualOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class GreaterEqualOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsGreaterEqualOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = GreaterEqualOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # GreaterEqualOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def GreaterEqualOptionsStart(builder): builder.StartObject(0)
+def GreaterEqualOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/GreaterOptions.py b/ethosu/vela/tflite/GreaterOptions.py
new file mode 100644
index 0000000..59d6350
--- /dev/null
+++ b/ethosu/vela/tflite/GreaterOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class GreaterOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsGreaterOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = GreaterOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # GreaterOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def GreaterOptionsStart(builder): builder.StartObject(0)
+def GreaterOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/HardSwishOptions.py b/ethosu/vela/tflite/HardSwishOptions.py
new file mode 100644
index 0000000..4f6a520
--- /dev/null
+++ b/ethosu/vela/tflite/HardSwishOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class HardSwishOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsHardSwishOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = HardSwishOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # HardSwishOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def HardSwishOptionsStart(builder): builder.StartObject(0)
+def HardSwishOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/IfOptions.py b/ethosu/vela/tflite/IfOptions.py
new file mode 100644
index 0000000..13f4e69
--- /dev/null
+++ b/ethosu/vela/tflite/IfOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class IfOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsIfOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = IfOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # IfOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # IfOptions
+ def ThenSubgraphIndex(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
+
+ # IfOptions
+ def ElseSubgraphIndex(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 IfOptionsStart(builder): builder.StartObject(2)
+def IfOptionsAddThenSubgraphIndex(builder, thenSubgraphIndex): builder.PrependInt32Slot(0, thenSubgraphIndex, 0)
+def IfOptionsAddElseSubgraphIndex(builder, elseSubgraphIndex): builder.PrependInt32Slot(1, elseSubgraphIndex, 0)
+def IfOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Int32Vector.py b/ethosu/vela/tflite/Int32Vector.py
new file mode 100644
index 0000000..e70851b
--- /dev/null
+++ b/ethosu/vela/tflite/Int32Vector.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Int32Vector(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsInt32Vector(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Int32Vector()
+ x.Init(buf, n + offset)
+ return x
+
+ # Int32Vector
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Int32Vector
+ def Values(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
+
+ # Int32Vector
+ def ValuesAsNumpy(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
+
+ # Int32Vector
+ def ValuesLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def Int32VectorStart(builder): builder.StartObject(1)
+def Int32VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
+def Int32VectorStartValuesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def Int32VectorEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/L2NormOptions.py b/ethosu/vela/tflite/L2NormOptions.py
new file mode 100644
index 0000000..38bdf57
--- /dev/null
+++ b/ethosu/vela/tflite/L2NormOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class L2NormOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsL2NormOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = L2NormOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # L2NormOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # L2NormOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def L2NormOptionsStart(builder): builder.StartObject(1)
+def L2NormOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def L2NormOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LSHProjectionOptions.py b/ethosu/vela/tflite/LSHProjectionOptions.py
new file mode 100644
index 0000000..ad550be
--- /dev/null
+++ b/ethosu/vela/tflite/LSHProjectionOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LSHProjectionOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLSHProjectionOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LSHProjectionOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LSHProjectionOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # LSHProjectionOptions
+ def Type(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def LSHProjectionOptionsStart(builder): builder.StartObject(1)
+def LSHProjectionOptionsAddType(builder, type): builder.PrependInt8Slot(0, type, 0)
+def LSHProjectionOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LSHProjectionType.py b/ethosu/vela/tflite/LSHProjectionType.py
new file mode 100644
index 0000000..a7d6a31
--- /dev/null
+++ b/ethosu/vela/tflite/LSHProjectionType.py
@@ -0,0 +1,8 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class LSHProjectionType(object):
+ UNKNOWN = 0
+ SPARSE = 1
+ DENSE = 2
diff --git a/ethosu/vela/tflite/LSTMKernelType.py b/ethosu/vela/tflite/LSTMKernelType.py
new file mode 100644
index 0000000..fd65799
--- /dev/null
+++ b/ethosu/vela/tflite/LSTMKernelType.py
@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class LSTMKernelType(object):
+ FULL = 0
+ BASIC = 1
diff --git a/ethosu/vela/tflite/LSTMOptions.py b/ethosu/vela/tflite/LSTMOptions.py
new file mode 100644
index 0000000..93a8309
--- /dev/null
+++ b/ethosu/vela/tflite/LSTMOptions.py
@@ -0,0 +1,54 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LSTMOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLSTMOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LSTMOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LSTMOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # LSTMOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # LSTMOptions
+ def CellClip(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
+
+ # LSTMOptions
+ def ProjClip(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
+
+ # LSTMOptions
+ def KernelType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def LSTMOptionsStart(builder): builder.StartObject(4)
+def LSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def LSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0)
+def LSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0)
+def LSTMOptionsAddKernelType(builder, kernelType): builder.PrependInt8Slot(3, kernelType, 0)
+def LSTMOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LeakyReluOptions.py b/ethosu/vela/tflite/LeakyReluOptions.py
new file mode 100644
index 0000000..b61b21d
--- /dev/null
+++ b/ethosu/vela/tflite/LeakyReluOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LeakyReluOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLeakyReluOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LeakyReluOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LeakyReluOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # LeakyReluOptions
+ def Alpha(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+ return 0.0
+
+def LeakyReluOptionsStart(builder): builder.StartObject(1)
+def LeakyReluOptionsAddAlpha(builder, alpha): builder.PrependFloat32Slot(0, alpha, 0.0)
+def LeakyReluOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LessEqualOptions.py b/ethosu/vela/tflite/LessEqualOptions.py
new file mode 100644
index 0000000..d49b728
--- /dev/null
+++ b/ethosu/vela/tflite/LessEqualOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LessEqualOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLessEqualOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LessEqualOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LessEqualOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LessEqualOptionsStart(builder): builder.StartObject(0)
+def LessEqualOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LessOptions.py b/ethosu/vela/tflite/LessOptions.py
new file mode 100644
index 0000000..469cb0b
--- /dev/null
+++ b/ethosu/vela/tflite/LessOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LessOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLessOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LessOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LessOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LessOptionsStart(builder): builder.StartObject(0)
+def LessOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LocalResponseNormalizationOptions.py b/ethosu/vela/tflite/LocalResponseNormalizationOptions.py
new file mode 100644
index 0000000..db87560
--- /dev/null
+++ b/ethosu/vela/tflite/LocalResponseNormalizationOptions.py
@@ -0,0 +1,54 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LocalResponseNormalizationOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLocalResponseNormalizationOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LocalResponseNormalizationOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LocalResponseNormalizationOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # LocalResponseNormalizationOptions
+ def Radius(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
+
+ # LocalResponseNormalizationOptions
+ def Bias(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
+
+ # LocalResponseNormalizationOptions
+ def Alpha(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
+
+ # LocalResponseNormalizationOptions
+ def Beta(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 LocalResponseNormalizationOptionsStart(builder): builder.StartObject(4)
+def LocalResponseNormalizationOptionsAddRadius(builder, radius): builder.PrependInt32Slot(0, radius, 0)
+def LocalResponseNormalizationOptionsAddBias(builder, bias): builder.PrependFloat32Slot(1, bias, 0.0)
+def LocalResponseNormalizationOptionsAddAlpha(builder, alpha): builder.PrependFloat32Slot(2, alpha, 0.0)
+def LocalResponseNormalizationOptionsAddBeta(builder, beta): builder.PrependFloat32Slot(3, beta, 0.0)
+def LocalResponseNormalizationOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LogSoftmaxOptions.py b/ethosu/vela/tflite/LogSoftmaxOptions.py
new file mode 100644
index 0000000..4789385
--- /dev/null
+++ b/ethosu/vela/tflite/LogSoftmaxOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LogSoftmaxOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLogSoftmaxOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LogSoftmaxOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LogSoftmaxOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LogSoftmaxOptionsStart(builder): builder.StartObject(0)
+def LogSoftmaxOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LogicalAndOptions.py b/ethosu/vela/tflite/LogicalAndOptions.py
new file mode 100644
index 0000000..cee1cdb
--- /dev/null
+++ b/ethosu/vela/tflite/LogicalAndOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LogicalAndOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLogicalAndOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LogicalAndOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LogicalAndOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LogicalAndOptionsStart(builder): builder.StartObject(0)
+def LogicalAndOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LogicalNotOptions.py b/ethosu/vela/tflite/LogicalNotOptions.py
new file mode 100644
index 0000000..9971450
--- /dev/null
+++ b/ethosu/vela/tflite/LogicalNotOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LogicalNotOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLogicalNotOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LogicalNotOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LogicalNotOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LogicalNotOptionsStart(builder): builder.StartObject(0)
+def LogicalNotOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/LogicalOrOptions.py b/ethosu/vela/tflite/LogicalOrOptions.py
new file mode 100644
index 0000000..e94a5de
--- /dev/null
+++ b/ethosu/vela/tflite/LogicalOrOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class LogicalOrOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsLogicalOrOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = LogicalOrOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # LogicalOrOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def LogicalOrOptionsStart(builder): builder.StartObject(0)
+def LogicalOrOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/MatrixDiagOptions.py b/ethosu/vela/tflite/MatrixDiagOptions.py
new file mode 100644
index 0000000..0f64e65
--- /dev/null
+++ b/ethosu/vela/tflite/MatrixDiagOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class MatrixDiagOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsMatrixDiagOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = MatrixDiagOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # MatrixDiagOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def MatrixDiagOptionsStart(builder): builder.StartObject(0)
+def MatrixDiagOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/MatrixSetDiagOptions.py b/ethosu/vela/tflite/MatrixSetDiagOptions.py
new file mode 100644
index 0000000..14178cf
--- /dev/null
+++ b/ethosu/vela/tflite/MatrixSetDiagOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class MatrixSetDiagOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsMatrixSetDiagOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = MatrixSetDiagOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # MatrixSetDiagOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def MatrixSetDiagOptionsStart(builder): builder.StartObject(0)
+def MatrixSetDiagOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/MaximumMinimumOptions.py b/ethosu/vela/tflite/MaximumMinimumOptions.py
new file mode 100644
index 0000000..f0806e2
--- /dev/null
+++ b/ethosu/vela/tflite/MaximumMinimumOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class MaximumMinimumOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsMaximumMinimumOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = MaximumMinimumOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # MaximumMinimumOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def MaximumMinimumOptionsStart(builder): builder.StartObject(0)
+def MaximumMinimumOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Metadata.py b/ethosu/vela/tflite/Metadata.py
new file mode 100644
index 0000000..273e51e
--- /dev/null
+++ b/ethosu/vela/tflite/Metadata.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Metadata(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsMetadata(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Metadata()
+ x.Init(buf, n + offset)
+ return x
+
+ # Metadata
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Metadata
+ 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
+
+ # Metadata
+ def Buffer(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Uint32Flags, o + self._tab.Pos)
+ return 0
+
+def MetadataStart(builder): builder.StartObject(2)
+def MetadataAddName(builder, name): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+def MetadataAddBuffer(builder, buffer): builder.PrependUint32Slot(1, buffer, 0)
+def MetadataEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/MirrorPadMode.py b/ethosu/vela/tflite/MirrorPadMode.py
new file mode 100644
index 0000000..8fb6396
--- /dev/null
+++ b/ethosu/vela/tflite/MirrorPadMode.py
@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class MirrorPadMode(object):
+ REFLECT = 0
+ SYMMETRIC = 1
diff --git a/ethosu/vela/tflite/MirrorPadOptions.py b/ethosu/vela/tflite/MirrorPadOptions.py
new file mode 100644
index 0000000..254ae21
--- /dev/null
+++ b/ethosu/vela/tflite/MirrorPadOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class MirrorPadOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsMirrorPadOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = MirrorPadOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # MirrorPadOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # MirrorPadOptions
+ def Mode(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def MirrorPadOptionsStart(builder): builder.StartObject(1)
+def MirrorPadOptionsAddMode(builder, mode): builder.PrependInt8Slot(0, mode, 0)
+def MirrorPadOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Model.py b/ethosu/vela/tflite/Model.py
new file mode 100644
index 0000000..cc9991b
--- /dev/null
+++ b/ethosu/vela/tflite/Model.py
@@ -0,0 +1,150 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Model(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsModel(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Model()
+ x.Init(buf, n + offset)
+ return x
+
+ # Model
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Model
+ def Version(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
+
+ # Model
+ def OperatorCodes(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 .OperatorCode import OperatorCode
+ obj = OperatorCode()
+ obj.Init(self._tab.Bytes, x)
+ return obj
+ return None
+
+ # Model
+ def OperatorCodesLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Model
+ def Subgraphs(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 .SubGraph import SubGraph
+ obj = SubGraph()
+ obj.Init(self._tab.Bytes, x)
+ return obj
+ return None
+
+ # Model
+ def SubgraphsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Model
+ def Description(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ return self._tab.String(o + self._tab.Pos)
+ return None
+
+ # Model
+ def Buffers(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ x = self._tab.Vector(o)
+ x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+ x = self._tab.Indirect(x)
+ from .Buffer import Buffer
+ obj = Buffer()
+ obj.Init(self._tab.Bytes, x)
+ return obj
+ return None
+
+ # Model
+ def BuffersLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Model
+ def MetadataBuffer(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ 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
+
+ # Model
+ def MetadataBufferAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+ return 0
+
+ # Model
+ def MetadataBufferLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Model
+ def Metadata(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+ if o != 0:
+ x = self._tab.Vector(o)
+ x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+ x = self._tab.Indirect(x)
+ from .Metadata import Metadata
+ obj = Metadata()
+ obj.Init(self._tab.Bytes, x)
+ return obj
+ return None
+
+ # Model
+ def MetadataLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def ModelStart(builder): builder.StartObject(7)
+def ModelAddVersion(builder, version): builder.PrependUint32Slot(0, version, 0)
+def ModelAddOperatorCodes(builder, operatorCodes): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(operatorCodes), 0)
+def ModelStartOperatorCodesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def ModelAddSubgraphs(builder, subgraphs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(subgraphs), 0)
+def ModelStartSubgraphsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def ModelAddDescription(builder, description): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(description), 0)
+def ModelAddBuffers(builder, buffers): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(buffers), 0)
+def ModelStartBuffersVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def ModelAddMetadataBuffer(builder, metadataBuffer): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(metadataBuffer), 0)
+def ModelStartMetadataBufferVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def ModelAddMetadata(builder, metadata): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(metadata), 0)
+def ModelStartMetadataVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def ModelEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/MulOptions.py b/ethosu/vela/tflite/MulOptions.py
new file mode 100644
index 0000000..55b9506
--- /dev/null
+++ b/ethosu/vela/tflite/MulOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class MulOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsMulOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = MulOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # MulOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # MulOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def MulOptionsStart(builder): builder.StartObject(1)
+def MulOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def MulOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/NegOptions.py b/ethosu/vela/tflite/NegOptions.py
new file mode 100644
index 0000000..05d55c2
--- /dev/null
+++ b/ethosu/vela/tflite/NegOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class NegOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsNegOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = NegOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # NegOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def NegOptionsStart(builder): builder.StartObject(0)
+def NegOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/NonMaxSuppressionV4Options.py b/ethosu/vela/tflite/NonMaxSuppressionV4Options.py
new file mode 100644
index 0000000..6ad10a2
--- /dev/null
+++ b/ethosu/vela/tflite/NonMaxSuppressionV4Options.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class NonMaxSuppressionV4Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsNonMaxSuppressionV4Options(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = NonMaxSuppressionV4Options()
+ x.Init(buf, n + offset)
+ return x
+
+ # NonMaxSuppressionV4Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def NonMaxSuppressionV4OptionsStart(builder): builder.StartObject(0)
+def NonMaxSuppressionV4OptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/NonMaxSuppressionV5Options.py b/ethosu/vela/tflite/NonMaxSuppressionV5Options.py
new file mode 100644
index 0000000..99cbdbb
--- /dev/null
+++ b/ethosu/vela/tflite/NonMaxSuppressionV5Options.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class NonMaxSuppressionV5Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsNonMaxSuppressionV5Options(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = NonMaxSuppressionV5Options()
+ x.Init(buf, n + offset)
+ return x
+
+ # NonMaxSuppressionV5Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def NonMaxSuppressionV5OptionsStart(builder): builder.StartObject(0)
+def NonMaxSuppressionV5OptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/NotEqualOptions.py b/ethosu/vela/tflite/NotEqualOptions.py
new file mode 100644
index 0000000..4c511e9
--- /dev/null
+++ b/ethosu/vela/tflite/NotEqualOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class NotEqualOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsNotEqualOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = NotEqualOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # NotEqualOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def NotEqualOptionsStart(builder): builder.StartObject(0)
+def NotEqualOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/OneHotOptions.py b/ethosu/vela/tflite/OneHotOptions.py
new file mode 100644
index 0000000..793a3e7
--- /dev/null
+++ b/ethosu/vela/tflite/OneHotOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class OneHotOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsOneHotOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = OneHotOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # OneHotOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # OneHotOptions
+ 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 OneHotOptionsStart(builder): builder.StartObject(1)
+def OneHotOptionsAddAxis(builder, axis): builder.PrependInt32Slot(0, axis, 0)
+def OneHotOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Operator.py b/ethosu/vela/tflite/Operator.py
new file mode 100644
index 0000000..cbae3da
--- /dev/null
+++ b/ethosu/vela/tflite/Operator.py
@@ -0,0 +1,177 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Operator(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsOperator(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Operator()
+ x.Init(buf, n + offset)
+ return x
+
+ # Operator
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Operator
+ def OpcodeIndex(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
+
+ # Operator
+ def Inputs(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
+
+ # Operator
+ def InputsAsNumpy(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
+
+ # Operator
+ def InputsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Operator
+ def Outputs(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
+
+ # Operator
+ def OutputsAsNumpy(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
+
+ # Operator
+ def OutputsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Operator
+ def BuiltinOptionsType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+ return 0
+
+ # Operator
+ def BuiltinOptions(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ from flatbuffers.table import Table
+ obj = Table(bytearray(), 0)
+ self._tab.Union(obj, o)
+ return obj
+ return None
+
+ # Operator
+ def CustomOptions(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ a = self._tab.Vector(o)
+ return self._tab.Get(flatbuffers.number_types.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+ return 0
+
+ # Operator
+ def CustomOptionsAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+ return 0
+
+ # Operator
+ def CustomOptionsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Operator
+ def CustomOptionsFormat(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # Operator
+ def MutatingVariableInputs(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+ if o != 0:
+ a = self._tab.Vector(o)
+ return self._tab.Get(flatbuffers.number_types.BoolFlags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+ return 0
+
+ # Operator
+ def MutatingVariableInputsAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.BoolFlags, o)
+ return 0
+
+ # Operator
+ def MutatingVariableInputsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Operator
+ def Intermediates(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+ 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
+
+ # Operator
+ def IntermediatesAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+ return 0
+
+ # Operator
+ def IntermediatesLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(20))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def OperatorStart(builder): builder.StartObject(9)
+def OperatorAddOpcodeIndex(builder, opcodeIndex): builder.PrependUint32Slot(0, opcodeIndex, 0)
+def OperatorAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0)
+def OperatorStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def OperatorAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0)
+def OperatorStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def OperatorAddBuiltinOptionsType(builder, builtinOptionsType): builder.PrependUint8Slot(3, builtinOptionsType, 0)
+def OperatorAddBuiltinOptions(builder, builtinOptions): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(builtinOptions), 0)
+def OperatorAddCustomOptions(builder, customOptions): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(customOptions), 0)
+def OperatorStartCustomOptionsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def OperatorAddCustomOptionsFormat(builder, customOptionsFormat): builder.PrependInt8Slot(6, customOptionsFormat, 0)
+def OperatorAddMutatingVariableInputs(builder, mutatingVariableInputs): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(mutatingVariableInputs), 0)
+def OperatorStartMutatingVariableInputsVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def OperatorAddIntermediates(builder, intermediates): builder.PrependUOffsetTRelativeSlot(8, flatbuffers.number_types.UOffsetTFlags.py_type(intermediates), 0)
+def OperatorStartIntermediatesVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def OperatorEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/OperatorCode.py b/ethosu/vela/tflite/OperatorCode.py
new file mode 100644
index 0000000..dd525f5
--- /dev/null
+++ b/ethosu/vela/tflite/OperatorCode.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class OperatorCode(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsOperatorCode(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = OperatorCode()
+ x.Init(buf, n + offset)
+ return x
+
+ # OperatorCode
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # OperatorCode
+ def BuiltinCode(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # OperatorCode
+ def CustomCode(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
+
+ # OperatorCode
+ def Version(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 1
+
+def OperatorCodeStart(builder): builder.StartObject(3)
+def OperatorCodeAddBuiltinCode(builder, builtinCode): builder.PrependInt8Slot(0, builtinCode, 0)
+def OperatorCodeAddCustomCode(builder, customCode): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(customCode), 0)
+def OperatorCodeAddVersion(builder, version): builder.PrependInt32Slot(2, version, 1)
+def OperatorCodeEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/PackOptions.py b/ethosu/vela/tflite/PackOptions.py
new file mode 100644
index 0000000..6a8ee2b
--- /dev/null
+++ b/ethosu/vela/tflite/PackOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class PackOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsPackOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = PackOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # PackOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # PackOptions
+ def ValuesCount(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
+
+ # PackOptions
+ def Axis(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 PackOptionsStart(builder): builder.StartObject(2)
+def PackOptionsAddValuesCount(builder, valuesCount): builder.PrependInt32Slot(0, valuesCount, 0)
+def PackOptionsAddAxis(builder, axis): builder.PrependInt32Slot(1, axis, 0)
+def PackOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/PadOptions.py b/ethosu/vela/tflite/PadOptions.py
new file mode 100644
index 0000000..d0833c6
--- /dev/null
+++ b/ethosu/vela/tflite/PadOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class PadOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsPadOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = PadOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # PadOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def PadOptionsStart(builder): builder.StartObject(0)
+def PadOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/PadV2Options.py b/ethosu/vela/tflite/PadV2Options.py
new file mode 100644
index 0000000..5ea0d70
--- /dev/null
+++ b/ethosu/vela/tflite/PadV2Options.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class PadV2Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsPadV2Options(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = PadV2Options()
+ x.Init(buf, n + offset)
+ return x
+
+ # PadV2Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def PadV2OptionsStart(builder): builder.StartObject(0)
+def PadV2OptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Padding.py b/ethosu/vela/tflite/Padding.py
new file mode 100644
index 0000000..168bf74
--- /dev/null
+++ b/ethosu/vela/tflite/Padding.py
@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class Padding(object):
+ SAME = 0
+ VALID = 1
diff --git a/ethosu/vela/tflite/Pool2DOptions.py b/ethosu/vela/tflite/Pool2DOptions.py
new file mode 100644
index 0000000..b8b9f17
--- /dev/null
+++ b/ethosu/vela/tflite/Pool2DOptions.py
@@ -0,0 +1,70 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Pool2DOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsPool2DOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Pool2DOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # Pool2DOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Pool2DOptions
+ def Padding(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # Pool2DOptions
+ def StrideW(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
+
+ # Pool2DOptions
+ def StrideH(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
+
+ # Pool2DOptions
+ def FilterWidth(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
+
+ # Pool2DOptions
+ def FilterHeight(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+ return 0
+
+ # Pool2DOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def Pool2DOptionsStart(builder): builder.StartObject(6)
+def Pool2DOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0)
+def Pool2DOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0)
+def Pool2DOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0)
+def Pool2DOptionsAddFilterWidth(builder, filterWidth): builder.PrependInt32Slot(3, filterWidth, 0)
+def Pool2DOptionsAddFilterHeight(builder, filterHeight): builder.PrependInt32Slot(4, filterHeight, 0)
+def Pool2DOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(5, fusedActivationFunction, 0)
+def Pool2DOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/PowOptions.py b/ethosu/vela/tflite/PowOptions.py
new file mode 100644
index 0000000..666ca48
--- /dev/null
+++ b/ethosu/vela/tflite/PowOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class PowOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsPowOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = PowOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # PowOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def PowOptionsStart(builder): builder.StartObject(0)
+def PowOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/QuantizationDetails.py b/ethosu/vela/tflite/QuantizationDetails.py
new file mode 100644
index 0000000..8d53af9
--- /dev/null
+++ b/ethosu/vela/tflite/QuantizationDetails.py
@@ -0,0 +1,7 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class QuantizationDetails(object):
+ NONE = 0
+ CustomQuantization = 1
diff --git a/ethosu/vela/tflite/QuantizationParameters.py b/ethosu/vela/tflite/QuantizationParameters.py
new file mode 100644
index 0000000..fcd686c
--- /dev/null
+++ b/ethosu/vela/tflite/QuantizationParameters.py
@@ -0,0 +1,145 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class QuantizationParameters(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsQuantizationParameters(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = QuantizationParameters()
+ x.Init(buf, n + offset)
+ return x
+
+ # QuantizationParameters
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # QuantizationParameters
+ def Min(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.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+ return 0
+
+ # QuantizationParameters
+ def MinAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o)
+ return 0
+
+ # QuantizationParameters
+ def MinLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # QuantizationParameters
+ def Max(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.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+ return 0
+
+ # QuantizationParameters
+ def MaxAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o)
+ return 0
+
+ # QuantizationParameters
+ def MaxLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # QuantizationParameters
+ def Scale(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.Float32Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 4))
+ return 0
+
+ # QuantizationParameters
+ def ScaleAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Float32Flags, o)
+ return 0
+
+ # QuantizationParameters
+ def ScaleLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # QuantizationParameters
+ def ZeroPoint(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.Int64Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 8))
+ return 0
+
+ # QuantizationParameters
+ def ZeroPointAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int64Flags, o)
+ return 0
+
+ # QuantizationParameters
+ def ZeroPointLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # QuantizationParameters
+ def DetailsType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Uint8Flags, o + self._tab.Pos)
+ return 0
+
+ # QuantizationParameters
+ def Details(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(14))
+ if o != 0:
+ from flatbuffers.table import Table
+ obj = Table(bytearray(), 0)
+ self._tab.Union(obj, o)
+ return obj
+ return None
+
+ # QuantizationParameters
+ def QuantizedDimension(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+ return 0
+
+def QuantizationParametersStart(builder): builder.StartObject(7)
+def QuantizationParametersAddMin(builder, min): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(min), 0)
+def QuantizationParametersStartMinVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def QuantizationParametersAddMax(builder, max): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(max), 0)
+def QuantizationParametersStartMaxVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def QuantizationParametersAddScale(builder, scale): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(scale), 0)
+def QuantizationParametersStartScaleVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def QuantizationParametersAddZeroPoint(builder, zeroPoint): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(zeroPoint), 0)
+def QuantizationParametersStartZeroPointVector(builder, numElems): return builder.StartVector(8, numElems, 8)
+def QuantizationParametersAddDetailsType(builder, detailsType): builder.PrependUint8Slot(4, detailsType, 0)
+def QuantizationParametersAddDetails(builder, details): builder.PrependUOffsetTRelativeSlot(5, flatbuffers.number_types.UOffsetTFlags.py_type(details), 0)
+def QuantizationParametersAddQuantizedDimension(builder, quantizedDimension): builder.PrependInt32Slot(6, quantizedDimension, 0)
+def QuantizationParametersEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/QuantizeOptions.py b/ethosu/vela/tflite/QuantizeOptions.py
new file mode 100644
index 0000000..28af8cc
--- /dev/null
+++ b/ethosu/vela/tflite/QuantizeOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class QuantizeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsQuantizeOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = QuantizeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # QuantizeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def QuantizeOptionsStart(builder): builder.StartObject(0)
+def QuantizeOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/RNNOptions.py b/ethosu/vela/tflite/RNNOptions.py
new file mode 100644
index 0000000..3cfdb6a
--- /dev/null
+++ b/ethosu/vela/tflite/RNNOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class RNNOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsRNNOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = RNNOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # RNNOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # RNNOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def RNNOptionsStart(builder): builder.StartObject(1)
+def RNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def RNNOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/RangeOptions.py b/ethosu/vela/tflite/RangeOptions.py
new file mode 100644
index 0000000..cb705b5
--- /dev/null
+++ b/ethosu/vela/tflite/RangeOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class RangeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsRangeOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = RangeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # RangeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def RangeOptionsStart(builder): builder.StartObject(0)
+def RangeOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/RankOptions.py b/ethosu/vela/tflite/RankOptions.py
new file mode 100644
index 0000000..4e4a5ec
--- /dev/null
+++ b/ethosu/vela/tflite/RankOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class RankOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsRankOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = RankOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # RankOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def RankOptionsStart(builder): builder.StartObject(0)
+def RankOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ReducerOptions.py b/ethosu/vela/tflite/ReducerOptions.py
new file mode 100644
index 0000000..93bbde1
--- /dev/null
+++ b/ethosu/vela/tflite/ReducerOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ReducerOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsReducerOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReducerOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ReducerOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ReducerOptions
+ def KeepDims(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+ return False
+
+def ReducerOptionsStart(builder): builder.StartObject(1)
+def ReducerOptionsAddKeepDims(builder, keepDims): builder.PrependBoolSlot(0, keepDims, 0)
+def ReducerOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ReshapeOptions.py b/ethosu/vela/tflite/ReshapeOptions.py
new file mode 100644
index 0000000..157d45d
--- /dev/null
+++ b/ethosu/vela/tflite/ReshapeOptions.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ReshapeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsReshapeOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReshapeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ReshapeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ReshapeOptions
+ def NewShape(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
+
+ # ReshapeOptions
+ def NewShapeAsNumpy(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
+
+ # ReshapeOptions
+ def NewShapeLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def ReshapeOptionsStart(builder): builder.StartObject(1)
+def ReshapeOptionsAddNewShape(builder, newShape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(newShape), 0)
+def ReshapeOptionsStartNewShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def ReshapeOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ResizeBilinearOptions.py b/ethosu/vela/tflite/ResizeBilinearOptions.py
new file mode 100644
index 0000000..fb05ca4
--- /dev/null
+++ b/ethosu/vela/tflite/ResizeBilinearOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ResizeBilinearOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsResizeBilinearOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ResizeBilinearOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ResizeBilinearOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ResizeBilinearOptions
+ def AlignCorners(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+ return False
+
+ # ResizeBilinearOptions
+ def HalfPixelCenters(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 ResizeBilinearOptionsStart(builder): builder.StartObject(4)
+def ResizeBilinearOptionsAddAlignCorners(builder, alignCorners): builder.PrependBoolSlot(2, alignCorners, 0)
+def ResizeBilinearOptionsAddHalfPixelCenters(builder, halfPixelCenters): builder.PrependBoolSlot(3, halfPixelCenters, 0)
+def ResizeBilinearOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ResizeNearestNeighborOptions.py b/ethosu/vela/tflite/ResizeNearestNeighborOptions.py
new file mode 100644
index 0000000..4b166e9
--- /dev/null
+++ b/ethosu/vela/tflite/ResizeNearestNeighborOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ResizeNearestNeighborOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsResizeNearestNeighborOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ResizeNearestNeighborOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ResizeNearestNeighborOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ResizeNearestNeighborOptions
+ def AlignCorners(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+ return False
+
+def ResizeNearestNeighborOptionsStart(builder): builder.StartObject(1)
+def ResizeNearestNeighborOptionsAddAlignCorners(builder, alignCorners): builder.PrependBoolSlot(0, alignCorners, 0)
+def ResizeNearestNeighborOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ReverseSequenceOptions.py b/ethosu/vela/tflite/ReverseSequenceOptions.py
new file mode 100644
index 0000000..cbaf96d
--- /dev/null
+++ b/ethosu/vela/tflite/ReverseSequenceOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ReverseSequenceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsReverseSequenceOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReverseSequenceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ReverseSequenceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ReverseSequenceOptions
+ def SeqDim(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
+
+ # ReverseSequenceOptions
+ def BatchDim(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 ReverseSequenceOptionsStart(builder): builder.StartObject(2)
+def ReverseSequenceOptionsAddSeqDim(builder, seqDim): builder.PrependInt32Slot(0, seqDim, 0)
+def ReverseSequenceOptionsAddBatchDim(builder, batchDim): builder.PrependInt32Slot(1, batchDim, 0)
+def ReverseSequenceOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ReverseV2Options.py b/ethosu/vela/tflite/ReverseV2Options.py
new file mode 100644
index 0000000..dbac936
--- /dev/null
+++ b/ethosu/vela/tflite/ReverseV2Options.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ReverseV2Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsReverseV2Options(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ReverseV2Options()
+ x.Init(buf, n + offset)
+ return x
+
+ # ReverseV2Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ReverseV2OptionsStart(builder): builder.StartObject(0)
+def ReverseV2OptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SVDFOptions.py b/ethosu/vela/tflite/SVDFOptions.py
new file mode 100644
index 0000000..6f391db
--- /dev/null
+++ b/ethosu/vela/tflite/SVDFOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SVDFOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSVDFOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SVDFOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SVDFOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SVDFOptions
+ def Rank(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
+
+ # SVDFOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def SVDFOptionsStart(builder): builder.StartObject(2)
+def SVDFOptionsAddRank(builder, rank): builder.PrependInt32Slot(0, rank, 0)
+def SVDFOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0)
+def SVDFOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ScatterNdOptions.py b/ethosu/vela/tflite/ScatterNdOptions.py
new file mode 100644
index 0000000..e6bf3a1
--- /dev/null
+++ b/ethosu/vela/tflite/ScatterNdOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ScatterNdOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsScatterNdOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ScatterNdOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ScatterNdOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ScatterNdOptionsStart(builder): builder.StartObject(0)
+def ScatterNdOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SegmentSumOptions.py b/ethosu/vela/tflite/SegmentSumOptions.py
new file mode 100644
index 0000000..d1c3213
--- /dev/null
+++ b/ethosu/vela/tflite/SegmentSumOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SegmentSumOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSegmentSumOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SegmentSumOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SegmentSumOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SegmentSumOptionsStart(builder): builder.StartObject(0)
+def SegmentSumOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SelectOptions.py b/ethosu/vela/tflite/SelectOptions.py
new file mode 100644
index 0000000..d67daf3
--- /dev/null
+++ b/ethosu/vela/tflite/SelectOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SelectOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSelectOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SelectOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SelectOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SelectOptionsStart(builder): builder.StartObject(0)
+def SelectOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SelectV2Options.py b/ethosu/vela/tflite/SelectV2Options.py
new file mode 100644
index 0000000..5d03fc2
--- /dev/null
+++ b/ethosu/vela/tflite/SelectV2Options.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SelectV2Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSelectV2Options(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SelectV2Options()
+ x.Init(buf, n + offset)
+ return x
+
+ # SelectV2Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SelectV2OptionsStart(builder): builder.StartObject(0)
+def SelectV2OptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SequenceRNNOptions.py b/ethosu/vela/tflite/SequenceRNNOptions.py
new file mode 100644
index 0000000..74a4954
--- /dev/null
+++ b/ethosu/vela/tflite/SequenceRNNOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SequenceRNNOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSequenceRNNOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SequenceRNNOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SequenceRNNOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SequenceRNNOptions
+ def TimeMajor(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+ return False
+
+ # SequenceRNNOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def SequenceRNNOptionsStart(builder): builder.StartObject(2)
+def SequenceRNNOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(0, timeMajor, 0)
+def SequenceRNNOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(1, fusedActivationFunction, 0)
+def SequenceRNNOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ShapeOptions.py b/ethosu/vela/tflite/ShapeOptions.py
new file mode 100644
index 0000000..2d24c05
--- /dev/null
+++ b/ethosu/vela/tflite/ShapeOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ShapeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsShapeOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ShapeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ShapeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # ShapeOptions
+ def OutType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def ShapeOptionsStart(builder): builder.StartObject(1)
+def ShapeOptionsAddOutType(builder, outType): builder.PrependInt8Slot(0, outType, 0)
+def ShapeOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SkipGramOptions.py b/ethosu/vela/tflite/SkipGramOptions.py
new file mode 100644
index 0000000..0e8bdc1
--- /dev/null
+++ b/ethosu/vela/tflite/SkipGramOptions.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SkipGramOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSkipGramOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SkipGramOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SkipGramOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SkipGramOptions
+ def NgramSize(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
+
+ # SkipGramOptions
+ def MaxSkipSize(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
+
+ # SkipGramOptions
+ def IncludeAllNgrams(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+ return False
+
+def SkipGramOptionsStart(builder): builder.StartObject(3)
+def SkipGramOptionsAddNgramSize(builder, ngramSize): builder.PrependInt32Slot(0, ngramSize, 0)
+def SkipGramOptionsAddMaxSkipSize(builder, maxSkipSize): builder.PrependInt32Slot(1, maxSkipSize, 0)
+def SkipGramOptionsAddIncludeAllNgrams(builder, includeAllNgrams): builder.PrependBoolSlot(2, includeAllNgrams, 0)
+def SkipGramOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SliceOptions.py b/ethosu/vela/tflite/SliceOptions.py
new file mode 100644
index 0000000..4b41568
--- /dev/null
+++ b/ethosu/vela/tflite/SliceOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SliceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSliceOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SliceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SliceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SliceOptionsStart(builder): builder.StartObject(0)
+def SliceOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SoftmaxOptions.py b/ethosu/vela/tflite/SoftmaxOptions.py
new file mode 100644
index 0000000..a716853
--- /dev/null
+++ b/ethosu/vela/tflite/SoftmaxOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SoftmaxOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSoftmaxOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SoftmaxOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SoftmaxOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SoftmaxOptions
+ def Beta(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Float32Flags, o + self._tab.Pos)
+ return 0.0
+
+def SoftmaxOptionsStart(builder): builder.StartObject(1)
+def SoftmaxOptionsAddBeta(builder, beta): builder.PrependFloat32Slot(0, beta, 0.0)
+def SoftmaxOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SpaceToBatchNDOptions.py b/ethosu/vela/tflite/SpaceToBatchNDOptions.py
new file mode 100644
index 0000000..b61ef96
--- /dev/null
+++ b/ethosu/vela/tflite/SpaceToBatchNDOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SpaceToBatchNDOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSpaceToBatchNDOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SpaceToBatchNDOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SpaceToBatchNDOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SpaceToBatchNDOptionsStart(builder): builder.StartObject(0)
+def SpaceToBatchNDOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SpaceToDepthOptions.py b/ethosu/vela/tflite/SpaceToDepthOptions.py
new file mode 100644
index 0000000..d571174
--- /dev/null
+++ b/ethosu/vela/tflite/SpaceToDepthOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SpaceToDepthOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSpaceToDepthOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SpaceToDepthOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SpaceToDepthOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SpaceToDepthOptions
+ def BlockSize(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 SpaceToDepthOptionsStart(builder): builder.StartObject(1)
+def SpaceToDepthOptionsAddBlockSize(builder, blockSize): builder.PrependInt32Slot(0, blockSize, 0)
+def SpaceToDepthOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SparseIndexVector.py b/ethosu/vela/tflite/SparseIndexVector.py
new file mode 100644
index 0000000..e2c9db7
--- /dev/null
+++ b/ethosu/vela/tflite/SparseIndexVector.py
@@ -0,0 +1,9 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class SparseIndexVector(object):
+ NONE = 0
+ Int32Vector = 1
+ Uint16Vector = 2
+ Uint8Vector = 3
diff --git a/ethosu/vela/tflite/SparseToDenseOptions.py b/ethosu/vela/tflite/SparseToDenseOptions.py
new file mode 100644
index 0000000..826eee0
--- /dev/null
+++ b/ethosu/vela/tflite/SparseToDenseOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SparseToDenseOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSparseToDenseOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SparseToDenseOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SparseToDenseOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SparseToDenseOptions
+ def ValidateIndices(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return bool(self._tab.Get(flatbuffers.number_types.BoolFlags, o + self._tab.Pos))
+ return False
+
+def SparseToDenseOptionsStart(builder): builder.StartObject(1)
+def SparseToDenseOptionsAddValidateIndices(builder, validateIndices): builder.PrependBoolSlot(0, validateIndices, 0)
+def SparseToDenseOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SparsityParameters.py b/ethosu/vela/tflite/SparsityParameters.py
new file mode 100644
index 0000000..de550a6
--- /dev/null
+++ b/ethosu/vela/tflite/SparsityParameters.py
@@ -0,0 +1,92 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SparsityParameters(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSparsityParameters(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SparsityParameters()
+ x.Init(buf, n + offset)
+ return x
+
+ # SparsityParameters
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SparsityParameters
+ def TraversalOrder(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
+
+ # SparsityParameters
+ def TraversalOrderAsNumpy(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
+
+ # SparsityParameters
+ def TraversalOrderLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # SparsityParameters
+ def BlockMap(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
+
+ # SparsityParameters
+ def BlockMapAsNumpy(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
+
+ # SparsityParameters
+ def BlockMapLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # SparsityParameters
+ def DimMetadata(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 .DimensionMetadata import DimensionMetadata
+ obj = DimensionMetadata()
+ obj.Init(self._tab.Bytes, x)
+ return obj
+ return None
+
+ # SparsityParameters
+ def DimMetadataLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def SparsityParametersStart(builder): builder.StartObject(3)
+def SparsityParametersAddTraversalOrder(builder, traversalOrder): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(traversalOrder), 0)
+def SparsityParametersStartTraversalOrderVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def SparsityParametersAddBlockMap(builder, blockMap): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(blockMap), 0)
+def SparsityParametersStartBlockMapVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def SparsityParametersAddDimMetadata(builder, dimMetadata): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(dimMetadata), 0)
+def SparsityParametersStartDimMetadataVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def SparsityParametersEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SplitOptions.py b/ethosu/vela/tflite/SplitOptions.py
new file mode 100644
index 0000000..3207525
--- /dev/null
+++ b/ethosu/vela/tflite/SplitOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SplitOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSplitOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SplitOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SplitOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SplitOptions
+ def NumSplits(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 SplitOptionsStart(builder): builder.StartObject(1)
+def SplitOptionsAddNumSplits(builder, numSplits): builder.PrependInt32Slot(0, numSplits, 0)
+def SplitOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SplitVOptions.py b/ethosu/vela/tflite/SplitVOptions.py
new file mode 100644
index 0000000..418959d
--- /dev/null
+++ b/ethosu/vela/tflite/SplitVOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SplitVOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSplitVOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SplitVOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SplitVOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SplitVOptions
+ def NumSplits(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 SplitVOptionsStart(builder): builder.StartObject(1)
+def SplitVOptionsAddNumSplits(builder, numSplits): builder.PrependInt32Slot(0, numSplits, 0)
+def SplitVOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SquareOptions.py b/ethosu/vela/tflite/SquareOptions.py
new file mode 100644
index 0000000..56633f6
--- /dev/null
+++ b/ethosu/vela/tflite/SquareOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SquareOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSquareOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SquareOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SquareOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SquareOptionsStart(builder): builder.StartObject(0)
+def SquareOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SquaredDifferenceOptions.py b/ethosu/vela/tflite/SquaredDifferenceOptions.py
new file mode 100644
index 0000000..906855d
--- /dev/null
+++ b/ethosu/vela/tflite/SquaredDifferenceOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SquaredDifferenceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSquaredDifferenceOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SquaredDifferenceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SquaredDifferenceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def SquaredDifferenceOptionsStart(builder): builder.StartObject(0)
+def SquaredDifferenceOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SqueezeOptions.py b/ethosu/vela/tflite/SqueezeOptions.py
new file mode 100644
index 0000000..25b294d
--- /dev/null
+++ b/ethosu/vela/tflite/SqueezeOptions.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SqueezeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSqueezeOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SqueezeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SqueezeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SqueezeOptions
+ def SqueezeDims(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
+
+ # SqueezeOptions
+ def SqueezeDimsAsNumpy(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
+
+ # SqueezeOptions
+ def SqueezeDimsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def SqueezeOptionsStart(builder): builder.StartObject(1)
+def SqueezeOptionsAddSqueezeDims(builder, squeezeDims): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(squeezeDims), 0)
+def SqueezeOptionsStartSqueezeDimsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def SqueezeOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/StridedSliceOptions.py b/ethosu/vela/tflite/StridedSliceOptions.py
new file mode 100644
index 0000000..3bbb36b
--- /dev/null
+++ b/ethosu/vela/tflite/StridedSliceOptions.py
@@ -0,0 +1,62 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class StridedSliceOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsStridedSliceOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = StridedSliceOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # StridedSliceOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # StridedSliceOptions
+ def BeginMask(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
+
+ # StridedSliceOptions
+ def EndMask(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
+
+ # StridedSliceOptions
+ def EllipsisMask(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
+
+ # StridedSliceOptions
+ def NewAxisMask(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
+
+ # StridedSliceOptions
+ def ShrinkAxisMask(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int32Flags, o + self._tab.Pos)
+ return 0
+
+def StridedSliceOptionsStart(builder): builder.StartObject(5)
+def StridedSliceOptionsAddBeginMask(builder, beginMask): builder.PrependInt32Slot(0, beginMask, 0)
+def StridedSliceOptionsAddEndMask(builder, endMask): builder.PrependInt32Slot(1, endMask, 0)
+def StridedSliceOptionsAddEllipsisMask(builder, ellipsisMask): builder.PrependInt32Slot(2, ellipsisMask, 0)
+def StridedSliceOptionsAddNewAxisMask(builder, newAxisMask): builder.PrependInt32Slot(3, newAxisMask, 0)
+def StridedSliceOptionsAddShrinkAxisMask(builder, shrinkAxisMask): builder.PrependInt32Slot(4, shrinkAxisMask, 0)
+def StridedSliceOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SubGraph.py b/ethosu/vela/tflite/SubGraph.py
new file mode 100644
index 0000000..eaa42fa
--- /dev/null
+++ b/ethosu/vela/tflite/SubGraph.py
@@ -0,0 +1,122 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SubGraph(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSubGraph(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SubGraph()
+ x.Init(buf, n + offset)
+ return x
+
+ # SubGraph
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SubGraph
+ def Tensors(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ x = self._tab.Vector(o)
+ x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+ x = self._tab.Indirect(x)
+ from .Tensor import Tensor
+ obj = Tensor()
+ obj.Init(self._tab.Bytes, x)
+ return obj
+ return None
+
+ # SubGraph
+ def TensorsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # SubGraph
+ def Inputs(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
+
+ # SubGraph
+ def InputsAsNumpy(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
+
+ # SubGraph
+ def InputsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # SubGraph
+ def Outputs(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
+
+ # SubGraph
+ def OutputsAsNumpy(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
+
+ # SubGraph
+ def OutputsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(8))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # SubGraph
+ def Operators(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ x = self._tab.Vector(o)
+ x += flatbuffers.number_types.UOffsetTFlags.py_type(j) * 4
+ x = self._tab.Indirect(x)
+ from .Operator import Operator
+ obj = Operator()
+ obj.Init(self._tab.Bytes, x)
+ return obj
+ return None
+
+ # SubGraph
+ def OperatorsLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # SubGraph
+ def Name(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ return self._tab.String(o + self._tab.Pos)
+ return None
+
+def SubGraphStart(builder): builder.StartObject(5)
+def SubGraphAddTensors(builder, tensors): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(tensors), 0)
+def SubGraphStartTensorsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def SubGraphAddInputs(builder, inputs): builder.PrependUOffsetTRelativeSlot(1, flatbuffers.number_types.UOffsetTFlags.py_type(inputs), 0)
+def SubGraphStartInputsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def SubGraphAddOutputs(builder, outputs): builder.PrependUOffsetTRelativeSlot(2, flatbuffers.number_types.UOffsetTFlags.py_type(outputs), 0)
+def SubGraphStartOutputsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def SubGraphAddOperators(builder, operators): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(operators), 0)
+def SubGraphStartOperatorsVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def SubGraphAddName(builder, name): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+def SubGraphEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/SubOptions.py b/ethosu/vela/tflite/SubOptions.py
new file mode 100644
index 0000000..eccd7ab
--- /dev/null
+++ b/ethosu/vela/tflite/SubOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class SubOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsSubOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = SubOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # SubOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # SubOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+def SubOptionsStart(builder): builder.StartObject(1)
+def SubOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def SubOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Tensor.py b/ethosu/vela/tflite/Tensor.py
new file mode 100644
index 0000000..4c39b7c
--- /dev/null
+++ b/ethosu/vela/tflite/Tensor.py
@@ -0,0 +1,126 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Tensor(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsTensor(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Tensor()
+ x.Init(buf, n + offset)
+ return x
+
+ # Tensor
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Tensor
+ 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
+
+ # Tensor
+ 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
+
+ # Tensor
+ def ShapeLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+ # Tensor
+ def Type(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(6))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # Tensor
+ def Buffer(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
+
+ # Tensor
+ def Name(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(10))
+ if o != 0:
+ return self._tab.String(o + self._tab.Pos)
+ return None
+
+ # Tensor
+ def Quantization(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(12))
+ if o != 0:
+ x = self._tab.Indirect(o + self._tab.Pos)
+ from .QuantizationParameters import QuantizationParameters
+ obj = QuantizationParameters()
+ obj.Init(self._tab.Bytes, x)
+ return obj
+ return None
+
+ # Tensor
+ def IsVariable(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
+
+ # Tensor
+ def Sparsity(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(16))
+ if o != 0:
+ x = self._tab.Indirect(o + self._tab.Pos)
+ from .SparsityParameters import SparsityParameters
+ obj = SparsityParameters()
+ obj.Init(self._tab.Bytes, x)
+ return obj
+ return None
+
+ # Tensor
+ def ShapeSignature(self, j):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+ 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
+
+ # Tensor
+ def ShapeSignatureAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Int32Flags, o)
+ return 0
+
+ # Tensor
+ def ShapeSignatureLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(18))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def TensorStart(builder): builder.StartObject(8)
+def TensorAddShape(builder, shape): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(shape), 0)
+def TensorStartShapeVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def TensorAddType(builder, type): builder.PrependInt8Slot(1, type, 0)
+def TensorAddBuffer(builder, buffer): builder.PrependUint32Slot(2, buffer, 0)
+def TensorAddName(builder, name): builder.PrependUOffsetTRelativeSlot(3, flatbuffers.number_types.UOffsetTFlags.py_type(name), 0)
+def TensorAddQuantization(builder, quantization): builder.PrependUOffsetTRelativeSlot(4, flatbuffers.number_types.UOffsetTFlags.py_type(quantization), 0)
+def TensorAddIsVariable(builder, isVariable): builder.PrependBoolSlot(5, isVariable, 0)
+def TensorAddSparsity(builder, sparsity): builder.PrependUOffsetTRelativeSlot(6, flatbuffers.number_types.UOffsetTFlags.py_type(sparsity), 0)
+def TensorAddShapeSignature(builder, shapeSignature): builder.PrependUOffsetTRelativeSlot(7, flatbuffers.number_types.UOffsetTFlags.py_type(shapeSignature), 0)
+def TensorStartShapeSignatureVector(builder, numElems): return builder.StartVector(4, numElems, 4)
+def TensorEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/TensorType.py b/ethosu/vela/tflite/TensorType.py
new file mode 100644
index 0000000..53c011b
--- /dev/null
+++ b/ethosu/vela/tflite/TensorType.py
@@ -0,0 +1,15 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+class TensorType(object):
+ FLOAT32 = 0
+ FLOAT16 = 1
+ INT32 = 2
+ UINT8 = 3
+ INT64 = 4
+ STRING = 5
+ BOOL = 6
+ INT16 = 7
+ COMPLEX64 = 8
+ INT8 = 9
diff --git a/ethosu/vela/tflite/TileOptions.py b/ethosu/vela/tflite/TileOptions.py
new file mode 100644
index 0000000..ec8396d
--- /dev/null
+++ b/ethosu/vela/tflite/TileOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class TileOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsTileOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = TileOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # TileOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def TileOptionsStart(builder): builder.StartObject(0)
+def TileOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/TopKV2Options.py b/ethosu/vela/tflite/TopKV2Options.py
new file mode 100644
index 0000000..ccd5103
--- /dev/null
+++ b/ethosu/vela/tflite/TopKV2Options.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class TopKV2Options(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsTopKV2Options(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = TopKV2Options()
+ x.Init(buf, n + offset)
+ return x
+
+ # TopKV2Options
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def TopKV2OptionsStart(builder): builder.StartObject(0)
+def TopKV2OptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/TransposeConvOptions.py b/ethosu/vela/tflite/TransposeConvOptions.py
new file mode 100644
index 0000000..423571c
--- /dev/null
+++ b/ethosu/vela/tflite/TransposeConvOptions.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class TransposeConvOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsTransposeConvOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = TransposeConvOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # TransposeConvOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # TransposeConvOptions
+ def Padding(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # TransposeConvOptions
+ def StrideW(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
+
+ # TransposeConvOptions
+ def StrideH(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
+
+def TransposeConvOptionsStart(builder): builder.StartObject(3)
+def TransposeConvOptionsAddPadding(builder, padding): builder.PrependInt8Slot(0, padding, 0)
+def TransposeConvOptionsAddStrideW(builder, strideW): builder.PrependInt32Slot(1, strideW, 0)
+def TransposeConvOptionsAddStrideH(builder, strideH): builder.PrependInt32Slot(2, strideH, 0)
+def TransposeConvOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/TransposeOptions.py b/ethosu/vela/tflite/TransposeOptions.py
new file mode 100644
index 0000000..42c596d
--- /dev/null
+++ b/ethosu/vela/tflite/TransposeOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class TransposeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsTransposeOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = TransposeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # TransposeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def TransposeOptionsStart(builder): builder.StartObject(0)
+def TransposeOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Uint16Vector.py b/ethosu/vela/tflite/Uint16Vector.py
new file mode 100644
index 0000000..750e52a
--- /dev/null
+++ b/ethosu/vela/tflite/Uint16Vector.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Uint16Vector(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsUint16Vector(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Uint16Vector()
+ x.Init(buf, n + offset)
+ return x
+
+ # Uint16Vector
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Uint16Vector
+ def Values(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.Uint16Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 2))
+ return 0
+
+ # Uint16Vector
+ def ValuesAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint16Flags, o)
+ return 0
+
+ # Uint16Vector
+ def ValuesLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def Uint16VectorStart(builder): builder.StartObject(1)
+def Uint16VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
+def Uint16VectorStartValuesVector(builder, numElems): return builder.StartVector(2, numElems, 2)
+def Uint16VectorEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/Uint8Vector.py b/ethosu/vela/tflite/Uint8Vector.py
new file mode 100644
index 0000000..dc475f9
--- /dev/null
+++ b/ethosu/vela/tflite/Uint8Vector.py
@@ -0,0 +1,46 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class Uint8Vector(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsUint8Vector(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = Uint8Vector()
+ x.Init(buf, n + offset)
+ return x
+
+ # Uint8Vector
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # Uint8Vector
+ def Values(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.Uint8Flags, a + flatbuffers.number_types.UOffsetTFlags.py_type(j * 1))
+ return 0
+
+ # Uint8Vector
+ def ValuesAsNumpy(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.GetVectorAsNumpy(flatbuffers.number_types.Uint8Flags, o)
+ return 0
+
+ # Uint8Vector
+ def ValuesLength(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.VectorLen(o)
+ return 0
+
+def Uint8VectorStart(builder): builder.StartObject(1)
+def Uint8VectorAddValues(builder, values): builder.PrependUOffsetTRelativeSlot(0, flatbuffers.number_types.UOffsetTFlags.py_type(values), 0)
+def Uint8VectorStartValuesVector(builder, numElems): return builder.StartVector(1, numElems, 1)
+def Uint8VectorEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/UnidirectionalSequenceLSTMOptions.py b/ethosu/vela/tflite/UnidirectionalSequenceLSTMOptions.py
new file mode 100644
index 0000000..1b0c112
--- /dev/null
+++ b/ethosu/vela/tflite/UnidirectionalSequenceLSTMOptions.py
@@ -0,0 +1,54 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class UnidirectionalSequenceLSTMOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsUnidirectionalSequenceLSTMOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = UnidirectionalSequenceLSTMOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # UnidirectionalSequenceLSTMOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # UnidirectionalSequenceLSTMOptions
+ def FusedActivationFunction(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 0
+
+ # UnidirectionalSequenceLSTMOptions
+ def CellClip(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
+
+ # UnidirectionalSequenceLSTMOptions
+ def ProjClip(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
+
+ # UnidirectionalSequenceLSTMOptions
+ def TimeMajor(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 UnidirectionalSequenceLSTMOptionsStart(builder): builder.StartObject(4)
+def UnidirectionalSequenceLSTMOptionsAddFusedActivationFunction(builder, fusedActivationFunction): builder.PrependInt8Slot(0, fusedActivationFunction, 0)
+def UnidirectionalSequenceLSTMOptionsAddCellClip(builder, cellClip): builder.PrependFloat32Slot(1, cellClip, 0.0)
+def UnidirectionalSequenceLSTMOptionsAddProjClip(builder, projClip): builder.PrependFloat32Slot(2, projClip, 0.0)
+def UnidirectionalSequenceLSTMOptionsAddTimeMajor(builder, timeMajor): builder.PrependBoolSlot(3, timeMajor, 0)
+def UnidirectionalSequenceLSTMOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/UniqueOptions.py b/ethosu/vela/tflite/UniqueOptions.py
new file mode 100644
index 0000000..841c697
--- /dev/null
+++ b/ethosu/vela/tflite/UniqueOptions.py
@@ -0,0 +1,30 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class UniqueOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsUniqueOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = UniqueOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # UniqueOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # UniqueOptions
+ def IdxOutType(self):
+ o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
+ if o != 0:
+ return self._tab.Get(flatbuffers.number_types.Int8Flags, o + self._tab.Pos)
+ return 2
+
+def UniqueOptionsStart(builder): builder.StartObject(1)
+def UniqueOptionsAddIdxOutType(builder, idxOutType): builder.PrependInt8Slot(0, idxOutType, 2)
+def UniqueOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/UnpackOptions.py b/ethosu/vela/tflite/UnpackOptions.py
new file mode 100644
index 0000000..eed4019
--- /dev/null
+++ b/ethosu/vela/tflite/UnpackOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class UnpackOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsUnpackOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = UnpackOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # UnpackOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # UnpackOptions
+ def Num(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
+
+ # UnpackOptions
+ def Axis(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 UnpackOptionsStart(builder): builder.StartObject(2)
+def UnpackOptionsAddNum(builder, num): builder.PrependInt32Slot(0, num, 0)
+def UnpackOptionsAddAxis(builder, axis): builder.PrependInt32Slot(1, axis, 0)
+def UnpackOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/WhereOptions.py b/ethosu/vela/tflite/WhereOptions.py
new file mode 100644
index 0000000..ab69f6a
--- /dev/null
+++ b/ethosu/vela/tflite/WhereOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class WhereOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsWhereOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = WhereOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # WhereOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def WhereOptionsStart(builder): builder.StartObject(0)
+def WhereOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/WhileOptions.py b/ethosu/vela/tflite/WhileOptions.py
new file mode 100644
index 0000000..7d5a6df
--- /dev/null
+++ b/ethosu/vela/tflite/WhileOptions.py
@@ -0,0 +1,38 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class WhileOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsWhileOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = WhileOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # WhileOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+ # WhileOptions
+ def CondSubgraphIndex(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
+
+ # WhileOptions
+ def BodySubgraphIndex(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 WhileOptionsStart(builder): builder.StartObject(2)
+def WhileOptionsAddCondSubgraphIndex(builder, condSubgraphIndex): builder.PrependInt32Slot(0, condSubgraphIndex, 0)
+def WhileOptionsAddBodySubgraphIndex(builder, bodySubgraphIndex): builder.PrependInt32Slot(1, bodySubgraphIndex, 0)
+def WhileOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/ZerosLikeOptions.py b/ethosu/vela/tflite/ZerosLikeOptions.py
new file mode 100644
index 0000000..e6aa963
--- /dev/null
+++ b/ethosu/vela/tflite/ZerosLikeOptions.py
@@ -0,0 +1,22 @@
+# automatically generated by the FlatBuffers compiler, do not modify
+
+# namespace: tflite
+
+import flatbuffers
+
+class ZerosLikeOptions(object):
+ __slots__ = ['_tab']
+
+ @classmethod
+ def GetRootAsZerosLikeOptions(cls, buf, offset):
+ n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
+ x = ZerosLikeOptions()
+ x.Init(buf, n + offset)
+ return x
+
+ # ZerosLikeOptions
+ def Init(self, buf, pos):
+ self._tab = flatbuffers.table.Table(buf, pos)
+
+def ZerosLikeOptionsStart(builder): builder.StartObject(0)
+def ZerosLikeOptionsEnd(builder): return builder.EndObject()
diff --git a/ethosu/vela/tflite/__init__.py b/ethosu/vela/tflite/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/ethosu/vela/tflite/__init__.py
diff --git a/ethosu/vela/tflite_mapping.py b/ethosu/vela/tflite_mapping.py
new file mode 100644
index 0000000..8e46ef2
--- /dev/null
+++ b/ethosu/vela/tflite_mapping.py
@@ -0,0 +1,644 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# TensorFlow Lite mapping functions used by both reader and writer.
+# Contains a mapping from the various TensorFlow Lite enums and options structs, generated by the FlatBuffer code
+# generator, to Vela's internal format.
+
+import numpy as np
+import struct
+
+from .data_type import DataType
+
+from .tflite.TensorType import TensorType
+from .tflite.BuiltinOperator import BuiltinOperator
+from .tflite.BuiltinOptions import BuiltinOptions
+
+
+from .tflite.Padding import Padding
+from .tflite.ActivationFunctionType import ActivationFunctionType
+
+from .tflite import Conv2DOptions
+from .tflite import DepthwiseConv2DOptions
+from .tflite import ConcatEmbeddingsOptions
+from .tflite import LSHProjectionOptions
+from .tflite import Pool2DOptions
+from .tflite import SVDFOptions
+from .tflite import RNNOptions
+from .tflite import FullyConnectedOptions
+from .tflite import SoftmaxOptions
+from .tflite import ConcatenationOptions
+from .tflite import AddOptions
+from .tflite import L2NormOptions
+from .tflite import LocalResponseNormalizationOptions
+from .tflite import LSTMOptions
+from .tflite import ResizeBilinearOptions
+from .tflite import CallOptions
+from .tflite import ReshapeOptions
+from .tflite import SkipGramOptions
+from .tflite import SpaceToDepthOptions
+from .tflite import EmbeddingLookupSparseOptions
+from .tflite import MulOptions
+from .tflite import PadOptions
+from .tflite import GatherOptions
+from .tflite import BatchToSpaceNDOptions
+from .tflite import SpaceToBatchNDOptions
+from .tflite import TransposeOptions
+from .tflite import ReducerOptions
+from .tflite import SubOptions
+from .tflite import DivOptions
+from .tflite import SqueezeOptions
+from .tflite import SequenceRNNOptions
+from .tflite import StridedSliceOptions
+from .tflite import ExpOptions
+from .tflite import TopKV2Options
+from .tflite import SplitOptions
+from .tflite import LogSoftmaxOptions
+from .tflite import CastOptions
+from .tflite import DequantizeOptions
+from .tflite import MaximumMinimumOptions
+from .tflite import ArgMaxOptions
+from .tflite import LessOptions
+from .tflite import NegOptions
+from .tflite import PadV2Options
+from .tflite import GreaterOptions
+from .tflite import GreaterEqualOptions
+from .tflite import LessEqualOptions
+from .tflite import SelectOptions
+from .tflite import SliceOptions
+from .tflite import TransposeConvOptions
+from .tflite import SparseToDenseOptions
+from .tflite import TileOptions
+from .tflite import ExpandDimsOptions
+from .tflite import EqualOptions
+from .tflite import NotEqualOptions
+from .tflite import ShapeOptions
+from .tflite import PowOptions
+from .tflite import ArgMinOptions
+from .tflite import FakeQuantOptions
+from .tflite import PackOptions
+from .tflite import LogicalOrOptions
+from .tflite import OneHotOptions
+from .tflite import LogicalAndOptions
+from .tflite import LogicalNotOptions
+from .tflite import UnpackOptions
+from .tflite import FloorDivOptions
+from .tflite import SquareOptions
+from .tflite import ZerosLikeOptions
+from .tflite import FillOptions
+from .tflite import BidirectionalSequenceLSTMOptions
+from .tflite import BidirectionalSequenceRNNOptions
+from .tflite import UnidirectionalSequenceLSTMOptions
+from .tflite import FloorModOptions
+from .tflite import RangeOptions
+from .tflite import ResizeNearestNeighborOptions
+from .tflite import LeakyReluOptions
+from .tflite import SquaredDifferenceOptions
+from .tflite import MirrorPadOptions
+from .tflite import AbsOptions
+from .tflite import SplitVOptions
+from .tflite import UniqueOptions
+from .tflite import ReverseV2Options
+from .tflite import AddNOptions
+from .tflite import GatherNdOptions
+from .tflite import CosOptions
+from .tflite import WhereOptions
+from .tflite import RankOptions
+from .tflite import ReverseSequenceOptions
+from .tflite import MatrixDiagOptions
+from .tflite import QuantizeOptions
+from .tflite import MatrixSetDiagOptions
+from .tflite import DensifyOptions
+from .tflite import DepthToSpaceOptions
+from .tflite import IfOptions
+from .tflite import NonMaxSuppressionV4Options
+from .tflite import NonMaxSuppressionV5Options
+from .tflite import ScatterNdOptions
+from .tflite import SegmentSumOptions
+from .tflite import SelectV2Options
+from .tflite import WhileOptions
+
+
+def inverse_map(map):
+ return {v: k for k, v in map.items()}
+
+
+datatype_map = {
+ TensorType.UINT8: DataType.uint8,
+ TensorType.INT8: DataType.int8,
+ TensorType.INT16: DataType.int16,
+ TensorType.INT32: DataType.int32,
+ TensorType.INT64: DataType.int64,
+ TensorType.FLOAT16: DataType.float16,
+ TensorType.FLOAT32: DataType.float32,
+ TensorType.STRING: DataType.string,
+ TensorType.BOOL: DataType.bool,
+ # no TensorType.COMPLEX64 for now
+}
+
+datatype_inv_map = inverse_map(datatype_map)
+datatype_inv_map[DataType.quint8] = TensorType.UINT8
+
+datatype_inv_map[DataType.qint8] = TensorType.INT8
+datatype_inv_map[DataType.qint16] = TensorType.INT16
+datatype_inv_map[DataType.qint32] = TensorType.INT32
+
+
+datatype_map_numpy = {
+ TensorType.UINT8: np.uint8,
+ TensorType.INT8: np.int8,
+ TensorType.INT16: np.int16,
+ TensorType.INT32: np.int32,
+ TensorType.INT64: np.int64,
+ TensorType.FLOAT16: np.float16,
+ TensorType.FLOAT32: np.float32,
+ TensorType.BOOL: np.bool,
+}
+
+
+builtin_options_map = {
+ BuiltinOptions.Conv2DOptions: Conv2DOptions.Conv2DOptions,
+ BuiltinOptions.DepthwiseConv2DOptions: DepthwiseConv2DOptions.DepthwiseConv2DOptions,
+ BuiltinOptions.ConcatEmbeddingsOptions: ConcatEmbeddingsOptions.ConcatEmbeddingsOptions,
+ BuiltinOptions.LSHProjectionOptions: LSHProjectionOptions.LSHProjectionOptions,
+ BuiltinOptions.Pool2DOptions: Pool2DOptions.Pool2DOptions,
+ BuiltinOptions.SVDFOptions: SVDFOptions.SVDFOptions,
+ BuiltinOptions.RNNOptions: RNNOptions.RNNOptions,
+ BuiltinOptions.FullyConnectedOptions: FullyConnectedOptions.FullyConnectedOptions,
+ BuiltinOptions.SoftmaxOptions: SoftmaxOptions.SoftmaxOptions,
+ BuiltinOptions.ConcatenationOptions: ConcatenationOptions.ConcatenationOptions,
+ BuiltinOptions.AddOptions: AddOptions.AddOptions,
+ BuiltinOptions.L2NormOptions: L2NormOptions.L2NormOptions,
+ BuiltinOptions.LocalResponseNormalizationOptions: LocalResponseNormalizationOptions.LocalResponseNormalizationOptions, # noqa: E501
+ BuiltinOptions.LSTMOptions: LSTMOptions.LSTMOptions,
+ BuiltinOptions.ResizeBilinearOptions: ResizeBilinearOptions.ResizeBilinearOptions,
+ BuiltinOptions.CallOptions: CallOptions.CallOptions,
+ BuiltinOptions.ReshapeOptions: ReshapeOptions.ReshapeOptions,
+ BuiltinOptions.SkipGramOptions: SkipGramOptions.SkipGramOptions,
+ BuiltinOptions.SpaceToDepthOptions: SpaceToDepthOptions.SpaceToDepthOptions,
+ BuiltinOptions.EmbeddingLookupSparseOptions: EmbeddingLookupSparseOptions.EmbeddingLookupSparseOptions,
+ BuiltinOptions.MulOptions: MulOptions.MulOptions,
+ BuiltinOptions.PadOptions: PadOptions.PadOptions,
+ BuiltinOptions.GatherOptions: GatherOptions.GatherOptions,
+ BuiltinOptions.BatchToSpaceNDOptions: BatchToSpaceNDOptions.BatchToSpaceNDOptions,
+ BuiltinOptions.SpaceToBatchNDOptions: SpaceToBatchNDOptions.SpaceToBatchNDOptions,
+ BuiltinOptions.TransposeOptions: TransposeOptions.TransposeOptions,
+ BuiltinOptions.ReducerOptions: ReducerOptions.ReducerOptions,
+ BuiltinOptions.SubOptions: SubOptions.SubOptions,
+ BuiltinOptions.DivOptions: DivOptions.DivOptions,
+ BuiltinOptions.SqueezeOptions: SqueezeOptions.SqueezeOptions,
+ BuiltinOptions.SequenceRNNOptions: SequenceRNNOptions.SequenceRNNOptions,
+ BuiltinOptions.StridedSliceOptions: StridedSliceOptions.StridedSliceOptions,
+ BuiltinOptions.ExpOptions: ExpOptions.ExpOptions,
+ BuiltinOptions.TopKV2Options: TopKV2Options.TopKV2Options,
+ BuiltinOptions.SplitOptions: SplitOptions.SplitOptions,
+ BuiltinOptions.LogSoftmaxOptions: LogSoftmaxOptions.LogSoftmaxOptions,
+ BuiltinOptions.CastOptions: CastOptions.CastOptions,
+ BuiltinOptions.DequantizeOptions: DequantizeOptions.DequantizeOptions,
+ BuiltinOptions.MaximumMinimumOptions: MaximumMinimumOptions.MaximumMinimumOptions,
+ BuiltinOptions.ArgMaxOptions: ArgMaxOptions.ArgMaxOptions,
+ BuiltinOptions.LessOptions: LessOptions.LessOptions,
+ BuiltinOptions.NegOptions: NegOptions.NegOptions,
+ BuiltinOptions.PadV2Options: PadV2Options.PadV2Options,
+ BuiltinOptions.GreaterOptions: GreaterOptions.GreaterOptions,
+ BuiltinOptions.GreaterEqualOptions: GreaterEqualOptions.GreaterEqualOptions,
+ BuiltinOptions.LessEqualOptions: LessEqualOptions.LessEqualOptions,
+ BuiltinOptions.SelectOptions: SelectOptions.SelectOptions,
+ BuiltinOptions.SliceOptions: SliceOptions.SliceOptions,
+ BuiltinOptions.TransposeConvOptions: TransposeConvOptions.TransposeConvOptions,
+ BuiltinOptions.SparseToDenseOptions: SparseToDenseOptions.SparseToDenseOptions,
+ BuiltinOptions.TileOptions: TileOptions.TileOptions,
+ BuiltinOptions.ExpandDimsOptions: ExpandDimsOptions.ExpandDimsOptions,
+ BuiltinOptions.EqualOptions: EqualOptions.EqualOptions,
+ BuiltinOptions.NotEqualOptions: NotEqualOptions.NotEqualOptions,
+ BuiltinOptions.ShapeOptions: ShapeOptions.ShapeOptions,
+ BuiltinOptions.PowOptions: PowOptions.PowOptions,
+ BuiltinOptions.ArgMinOptions: ArgMinOptions.ArgMinOptions,
+ BuiltinOptions.FakeQuantOptions: FakeQuantOptions.FakeQuantOptions,
+ BuiltinOptions.PackOptions: PackOptions.PackOptions,
+ BuiltinOptions.LogicalOrOptions: LogicalOrOptions.LogicalOrOptions,
+ BuiltinOptions.OneHotOptions: OneHotOptions.OneHotOptions,
+ BuiltinOptions.LogicalAndOptions: LogicalAndOptions.LogicalAndOptions,
+ BuiltinOptions.LogicalNotOptions: LogicalNotOptions.LogicalNotOptions,
+ BuiltinOptions.UnpackOptions: UnpackOptions.UnpackOptions,
+ BuiltinOptions.FloorDivOptions: FloorDivOptions.FloorDivOptions,
+ BuiltinOptions.SquareOptions: SquareOptions.SquareOptions,
+ BuiltinOptions.ZerosLikeOptions: ZerosLikeOptions.ZerosLikeOptions,
+ BuiltinOptions.FillOptions: FillOptions.FillOptions,
+ BuiltinOptions.BidirectionalSequenceLSTMOptions: BidirectionalSequenceLSTMOptions.BidirectionalSequenceLSTMOptions,
+ BuiltinOptions.BidirectionalSequenceRNNOptions: BidirectionalSequenceRNNOptions.BidirectionalSequenceRNNOptions,
+ BuiltinOptions.UnidirectionalSequenceLSTMOptions: UnidirectionalSequenceLSTMOptions.UnidirectionalSequenceLSTMOptions, # noqa: E501
+ BuiltinOptions.FloorModOptions: FloorModOptions.FloorModOptions,
+ BuiltinOptions.RangeOptions: RangeOptions.RangeOptions,
+ BuiltinOptions.ResizeNearestNeighborOptions: ResizeNearestNeighborOptions.ResizeNearestNeighborOptions,
+ BuiltinOptions.LeakyReluOptions: LeakyReluOptions.LeakyReluOptions,
+ BuiltinOptions.SquaredDifferenceOptions: SquaredDifferenceOptions.SquaredDifferenceOptions,
+ BuiltinOptions.MirrorPadOptions: MirrorPadOptions.MirrorPadOptions,
+ BuiltinOptions.AbsOptions: AbsOptions.AbsOptions,
+ BuiltinOptions.SplitVOptions: SplitVOptions.SplitVOptions,
+ BuiltinOptions.UniqueOptions: UniqueOptions.UniqueOptions,
+ BuiltinOptions.ReverseV2Options: ReverseV2Options.ReverseV2Options,
+ BuiltinOptions.AddNOptions: AddNOptions.AddNOptions,
+ BuiltinOptions.GatherNdOptions: GatherNdOptions.GatherNdOptions,
+ BuiltinOptions.CosOptions: CosOptions.CosOptions,
+ BuiltinOptions.WhereOptions: WhereOptions.WhereOptions,
+ BuiltinOptions.RankOptions: RankOptions.RankOptions,
+ BuiltinOptions.ReverseSequenceOptions: ReverseSequenceOptions.ReverseSequenceOptions,
+ BuiltinOptions.MatrixDiagOptions: MatrixDiagOptions.MatrixDiagOptions,
+ BuiltinOptions.QuantizeOptions: QuantizeOptions.QuantizeOptions,
+ BuiltinOptions.MatrixSetDiagOptions: MatrixSetDiagOptions.MatrixSetDiagOptions,
+ BuiltinOptions.DensifyOptions: DensifyOptions.DensifyOptions,
+ BuiltinOptions.DepthToSpaceOptions: DepthToSpaceOptions.DepthToSpaceOptions,
+ BuiltinOptions.IfOptions: IfOptions.IfOptions,
+ BuiltinOptions.NonMaxSuppressionV4Options: NonMaxSuppressionV4Options.NonMaxSuppressionV4Options,
+ BuiltinOptions.NonMaxSuppressionV5Options: NonMaxSuppressionV5Options.NonMaxSuppressionV5Options,
+ BuiltinOptions.ScatterNdOptions: ScatterNdOptions.ScatterNdOptions,
+ BuiltinOptions.SegmentSumOptions: SegmentSumOptions.SegmentSumOptions,
+ BuiltinOptions.SelectV2Options: SelectV2Options.SelectV2Options,
+ BuiltinOptions.WhileOptions: WhileOptions.WhileOptions,
+}
+
+builtin_options_inv_map = inverse_map(builtin_options_map)
+
+
+def underscore_to_camel_case(s):
+ return "".join(x.title() for x in s.split("_"))
+
+
+def padding_deserialize(x):
+ return padding_map[x]
+
+
+def padding_serialize(builder, x):
+ return padding_inv_map[x]
+
+
+def activation_deserialize(x):
+ return activation_function_map[x]
+
+
+def activation_serialize(builder, x):
+ return activation_function_inv_map[x]
+
+
+def datatype_deserialize(x):
+ return datatype_map[x]
+
+
+def datatype_serialize(builder, x):
+ return datatype_inv_map[x]
+
+
+def identity(x):
+ return x
+
+
+def identity_serialize(builder, x):
+ return x
+
+
+def write_byte_vector(builder, v):
+ builder.StartVector(1, len(v), 1)
+ for e in v[::-1]:
+ builder.PrependByte(e)
+ return builder.EndVector(len(v))
+
+
+def write_int_vector(builder, v):
+ builder.StartVector(4, len(v), 4)
+ for e in v[::-1]:
+ builder.PrependInt32(e)
+ return builder.EndVector(len(v))
+
+
+class OptionsSerializer:
+ def __init__(self, name, members=[]):
+ self.name = name
+ self.module = globals()[self.name]
+ self.cls = getattr(self.module, self.name)
+ self.builtin_opt_type = builtin_options_inv_map[self.cls]
+ self.custom_opt_format = 0
+ self.members = []
+ for mem in members:
+ deserialize = identity
+ serialize = identity_serialize
+ is_vector = False
+ if isinstance(mem, tuple):
+ if len(mem) == 3:
+ mem, deserialize, serialize = mem
+ elif len(mem) == 2:
+ mem, is_vector = mem
+ deserialize = tuple
+ serialize = write_int_vector
+ else:
+ assert 0
+ underscore_mem = mem
+ camelcase_mem = underscore_to_camel_case(mem)
+ self.members.append((underscore_mem, camelcase_mem, deserialize, serialize, is_vector))
+
+ def deserialize(self, builtin_data, custom_data):
+ attrs = {}
+ if builtin_data:
+ tfattrs = self.cls()
+ tfattrs.Init(builtin_data.Bytes, builtin_data.Pos)
+ for underscore_mem, camelcase_mem, deserialize, serialize, is_vector in self.members:
+ fun = camelcase_mem
+ if is_vector:
+ fun += "AsNumpy"
+
+ a = deserialize(getattr(tfattrs, fun)())
+ attrs[underscore_mem] = a
+ return attrs
+
+ def serialize(self, builder, attrs):
+ ser_attrs = []
+ for underscore_mem, camelcase_mem, deserialize, serialize, is_vector in self.members:
+ a = serialize(builder, attrs[underscore_mem])
+ ser_attrs.append((camelcase_mem, a))
+
+ getattr(self.module, self.name + "Start")(builder)
+
+ for camelcase_mem, a in ser_attrs:
+ getattr(self.module, self.name + "Add" + camelcase_mem)(builder, a)
+
+ return getattr(self.module, self.name + "End")(builder), None
+
+
+class CustomOptionsSerializer:
+ def __init__(self):
+ self.builtin_opt_type = 0
+ self.custom_opt_format = 0
+
+ def deserialize(self, builtin_data, custom_data):
+ attrs = {}
+ attrs["custom_options"] = custom_data
+ return attrs
+
+ def serialize(self, builder, attrs):
+
+ custom_opts = attrs.get("custom_options", [])
+ custom_data = []
+
+ # Set NPU op custom options for the TensorFlow Lite custom operator
+ if custom_opts["type"] == "NpuOp":
+ custom_data = [0x01, 0x04, 0x01] # NpuOp=1, FlexbufferFormat.UINT8=4, byte length=1
+
+ custom_data_bytes = struct.pack("<{0}B".format(len(custom_data)), *custom_data)
+ custom_offset = write_byte_vector(builder, custom_data_bytes)
+
+ return None, custom_offset
+
+
+padding_map = {
+ Padding.SAME: b"SAME",
+ Padding.VALID: b"VALID",
+}
+
+padding_inv_map = inverse_map(padding_map)
+
+
+activation_function_map = {
+ ActivationFunctionType.NONE: None,
+ ActivationFunctionType.RELU: "Relu",
+ ActivationFunctionType.RELU_N1_TO_1: "ReluN1To1",
+ ActivationFunctionType.RELU6: "Relu6",
+ ActivationFunctionType.TANH: "Tanh",
+ ActivationFunctionType.SIGN_BIT: "SignBit",
+}
+
+activation_function_inv_map = inverse_map(activation_function_map)
+
+fused_act = ("fused_activation_function", activation_deserialize, activation_serialize)
+padding = ("padding", padding_deserialize, padding_serialize)
+
+pool2d_opts = OptionsSerializer(
+ "Pool2DOptions", (padding, "stride_w", "stride_h", "filter_width", "filter_height", fused_act,)
+)
+
+depthwise_opts = OptionsSerializer(
+ "DepthwiseConv2DOptions",
+ (padding, "stride_w", "stride_h", "depth_multiplier", fused_act, "dilation_w_factor", "dilation_h_factor",),
+)
+
+conv2d_opts = OptionsSerializer(
+ "Conv2DOptions", (padding, "stride_w", "stride_h", fused_act, "dilation_w_factor", "dilation_h_factor",)
+)
+
+lstm_opts = OptionsSerializer("LSTMOptions", (fused_act, "cell_clip", "proj_clip", "kernel_type"))
+
+unidir_seq_lstm_opts = OptionsSerializer(
+ "UnidirectionalSequenceLSTMOptions", (fused_act, "cell_clip", "proj_clip", "time_major")
+)
+
+bidir_seq_lstm_opts = OptionsSerializer(
+ "BidirectionalSequenceLSTMOptions", (fused_act, "cell_clip", "proj_clip", "merge_outputs", "time_major")
+)
+
+rnn_opts = OptionsSerializer("RNNOptions", (fused_act,))
+
+seq_rnn_opts = OptionsSerializer("SequenceRNNOptions", ("time_major", fused_act,))
+
+bidir_seq_rnn_opts = OptionsSerializer("BidirectionalSequenceRNNOptions", ("time_major", fused_act, "merge_outputs",))
+
+
+reducer_opts = OptionsSerializer("ReducerOptions", ("keep_dims",))
+
+is_int_vec = True
+
+custom_prefix = "Custom_"
+
+builtin_operator_map = {
+ BuiltinOperator.ADD: ("AddAct", OptionsSerializer("AddOptions", (fused_act,))),
+ BuiltinOperator.AVERAGE_POOL_2D: ("AvgPoolAct", pool2d_opts),
+ BuiltinOperator.CONCATENATION: ("ConcatTFLite", OptionsSerializer("ConcatenationOptions", ("axis", fused_act))),
+ BuiltinOperator.CONV_2D: ("Conv2DBiasAct", conv2d_opts),
+ BuiltinOperator.DEPTHWISE_CONV_2D: ("DepthwiseConv2dBiasAct", depthwise_opts),
+ BuiltinOperator.DEPTH_TO_SPACE: ("DepthToSpace", OptionsSerializer("DepthToSpaceOptions", ("block_size",))),
+ BuiltinOperator.DEQUANTIZE: ("Dequantize", OptionsSerializer("DequantizeOptions")),
+ BuiltinOperator.EMBEDDING_LOOKUP: (None, None),
+ BuiltinOperator.FLOOR: ("Floor", None),
+ BuiltinOperator.FULLY_CONNECTED: (
+ "FullyConnectedAct",
+ OptionsSerializer("FullyConnectedOptions", (fused_act, "weights_format")),
+ ),
+ BuiltinOperator.HASHTABLE_LOOKUP: (None, None),
+ # BuiltinOperator.L2_NORMALIZATION : "L2NormAct",
+ BuiltinOperator.L2_POOL_2D: (None, pool2d_opts),
+ BuiltinOperator.LOCAL_RESPONSE_NORMALIZATION: (
+ "LRN",
+ OptionsSerializer("LocalResponseNormalizationOptions", ("radius", "bias", "alpha", "beta")),
+ ),
+ BuiltinOperator.LOGISTIC: ("Sigmoid", None),
+ # BuiltinOperator.LSH_PROJECTION : "",
+ BuiltinOperator.LSTM: ("LstmAct", lstm_opts),
+ BuiltinOperator.MAX_POOL_2D: ("MaxPool", pool2d_opts),
+ BuiltinOperator.MUL: ("MulAct", OptionsSerializer("MulOptions", (fused_act,))),
+ BuiltinOperator.RELU: ("Relu", None),
+ BuiltinOperator.RELU_N1_TO_1: (None, None),
+ BuiltinOperator.RELU6: ("Relu6", None),
+ BuiltinOperator.RESHAPE: ("Reshape", OptionsSerializer("ReshapeOptions", (("new_shape", is_int_vec),))),
+ BuiltinOperator.RESIZE_BILINEAR: (
+ "ResizeBilinear",
+ OptionsSerializer("ResizeBilinearOptions", ("align_corners", "half_pixel_centers")),
+ ),
+ BuiltinOperator.RNN: ("RnnAct", rnn_opts),
+ BuiltinOperator.SOFTMAX: ("Softmax", OptionsSerializer("SoftmaxOptions", ("beta",))),
+ BuiltinOperator.SPACE_TO_DEPTH: ("SpaceToDepth", OptionsSerializer("SpaceToDepthOptions", ("block_size",))),
+ BuiltinOperator.SVDF: ("SvdfAct", OptionsSerializer("SVDFOptions", ("rank", fused_act))),
+ BuiltinOperator.TANH: ("Tanh", None),
+ # BuiltinOperator.CONCAT_EMBEDDINGS : "",
+ # BuiltinOperator.SKIP_GRAM : "",
+ # BuiltinOperator.CALL : "",
+ BuiltinOperator.EMBEDDING_LOOKUP_SPARSE: (None, OptionsSerializer("EmbeddingLookupSparseOptions", ("combiner",))),
+ BuiltinOperator.PAD: ("Pad", OptionsSerializer("PadOptions")),
+ BuiltinOperator.UNIDIRECTIONAL_SEQUENCE_RNN: ("UnidirectionalSequenceRnnAct", seq_rnn_opts),
+ BuiltinOperator.GATHER: ("GatherV2", OptionsSerializer("GatherOptions", ("axis",))),
+ BuiltinOperator.BATCH_TO_SPACE_ND: ("BatchToSpaceND", OptionsSerializer("BatchToSpaceNDOptions")),
+ BuiltinOperator.SPACE_TO_BATCH_ND: ("SpaceToBatchND", OptionsSerializer("SpaceToBatchNDOptions")),
+ BuiltinOperator.TRANSPOSE: ("Transpose", OptionsSerializer("TransposeOptions")),
+ BuiltinOperator.MEAN: ("Mean", None),
+ BuiltinOperator.SUB: ("SubAct", OptionsSerializer("SubOptions", (fused_act,))),
+ BuiltinOperator.DIV: ("DivAct", OptionsSerializer("DivOptions", (fused_act,))),
+ BuiltinOperator.SQUEEZE: ("Squeeze", OptionsSerializer("SqueezeOptions", (("squeeze_dims", is_int_vec),))),
+ BuiltinOperator.UNIDIRECTIONAL_SEQUENCE_LSTM: ("UnidirectionalSequenceLstmAct", unidir_seq_lstm_opts),
+ BuiltinOperator.STRIDED_SLICE: (
+ "StridedSlice",
+ OptionsSerializer(
+ "StridedSliceOptions", ("begin_mask", "end_mask", "ellipsis_mask", "new_axis_mask", "shrink_axis_mask")
+ ),
+ ),
+ BuiltinOperator.BIDIRECTIONAL_SEQUENCE_RNN: ("BidirectionalSequenceRnnAct", bidir_seq_rnn_opts),
+ BuiltinOperator.EXP: ("Exp", OptionsSerializer("ExpOptions")),
+ BuiltinOperator.TOPK_V2: ("TopKV2", OptionsSerializer("TopKV2Options")),
+ BuiltinOperator.SPLIT: ("Split", OptionsSerializer("SplitOptions", ("num_splits",))),
+ BuiltinOperator.LOG_SOFTMAX: ("LogSoftmax", OptionsSerializer("LogSoftmaxOptions")),
+ # BuiltinOperator.DELEGATE : "",
+ BuiltinOperator.BIDIRECTIONAL_SEQUENCE_LSTM: ("BidirectionalSequenceLstmAct", bidir_seq_lstm_opts),
+ BuiltinOperator.CAST: (
+ "Cast",
+ OptionsSerializer(
+ "CastOptions",
+ (
+ ("in_data_type", datatype_deserialize, datatype_serialize),
+ ("out_data_type", datatype_deserialize, datatype_serialize),
+ ),
+ ),
+ ),
+ # BuiltinOperator.PRELU : "",
+ BuiltinOperator.MAXIMUM: ("Maximum", OptionsSerializer("MaximumMinimumOptions")),
+ BuiltinOperator.ARG_MAX: (
+ "ArgMax",
+ OptionsSerializer("ArgMaxOptions", (("output_type", datatype_deserialize, datatype_serialize),)),
+ ),
+ BuiltinOperator.MINIMUM: ("Minimum", OptionsSerializer("MaximumMinimumOptions")),
+ BuiltinOperator.LESS: ("Less", None),
+ BuiltinOperator.NEG: ("Neg", None),
+ BuiltinOperator.PADV2: ("PadV2", None),
+ BuiltinOperator.GREATER: ("Greater", None),
+ BuiltinOperator.GREATER_EQUAL: ("GreaterEqual", None),
+ BuiltinOperator.LESS_EQUAL: ("LessEqual", None),
+ BuiltinOperator.SELECT: ("Select", None),
+ BuiltinOperator.SLICE: ("Slice", None),
+ BuiltinOperator.SIN: ("Sin", None),
+ BuiltinOperator.TRANSPOSE_CONV: (
+ "Conv2DBackpropInput",
+ OptionsSerializer("TransposeConvOptions", (padding, "stride_w", "stride_h")),
+ ),
+ BuiltinOperator.SPARSE_TO_DENSE: (
+ "SparseToDense",
+ OptionsSerializer("SparseToDenseOptions", ("validate_indices",)),
+ ),
+ BuiltinOperator.TILE: ("Tile", OptionsSerializer("TileOptions")),
+ BuiltinOperator.EXPAND_DIMS: ("ExpandDims", None),
+ BuiltinOperator.EQUAL: ("Equal", None),
+ BuiltinOperator.NOT_EQUAL: ("NotEqual", None),
+ BuiltinOperator.LOG: ("Log", None),
+ BuiltinOperator.SUM: ("Sum", None),
+ BuiltinOperator.SQRT: ("Sqrt", None),
+ BuiltinOperator.RSQRT: ("Rsqrt", None),
+ BuiltinOperator.SHAPE: (
+ "Shape",
+ OptionsSerializer("ShapeOptions", (("out_type", datatype_deserialize, datatype_serialize),)),
+ ),
+ BuiltinOperator.POW: "Pow",
+ BuiltinOperator.ARG_MIN: (
+ "ArgMin",
+ OptionsSerializer("ArgMinOptions", (("output_type", datatype_deserialize, datatype_serialize),)),
+ ),
+ BuiltinOperator.FAKE_QUANT: (
+ "FakeQuantWithMinMaxArgs",
+ OptionsSerializer("FakeQuantOptions", ("min", "max", "num_bits", "narrow_range")),
+ ),
+ BuiltinOperator.REDUCE_PROD: ("Prod", reducer_opts),
+ BuiltinOperator.REDUCE_MAX: ("Max", reducer_opts),
+ BuiltinOperator.PACK: ("Pack", OptionsSerializer("PackOptions", ("values_count", "axis"))),
+ BuiltinOperator.LOGICAL_OR: ("LogicalOr", None),
+ BuiltinOperator.ONE_HOT: ("OneHot", OptionsSerializer("OneHotOptions", ("axis",))),
+ BuiltinOperator.LOGICAL_AND: ("LogicalAnd", None),
+ BuiltinOperator.LOGICAL_NOT: ("LogicalNot", None),
+ BuiltinOperator.UNPACK: ("Unpack", OptionsSerializer("UnpackOptions", ("num", "axis"))),
+ BuiltinOperator.REDUCE_MIN: ("Min", reducer_opts),
+ BuiltinOperator.FLOOR_DIV: ("FloorDiv", None),
+ BuiltinOperator.REDUCE_ANY: ("Any", reducer_opts),
+ BuiltinOperator.SQUARE: ("Square", None),
+ BuiltinOperator.ZEROS_LIKE: ("ZerosLike", None),
+ BuiltinOperator.FILL: ("Fill", None),
+ BuiltinOperator.FLOOR_MOD: ("FloorMod", None),
+ BuiltinOperator.RANGE: ("Range", None),
+ BuiltinOperator.RESIZE_NEAREST_NEIGHBOR: (
+ "ResizeNearestNeighbor",
+ OptionsSerializer("ResizeNearestNeighborOptions", ("align_corners",)),
+ ),
+ BuiltinOperator.LEAKY_RELU: ("LeakyRelu", OptionsSerializer("LeakyReluOptions", ("alpha",))),
+ BuiltinOperator.SQUARED_DIFFERENCE: ("SquaredDifference", None),
+ BuiltinOperator.MIRROR_PAD: ("MirrorPad", OptionsSerializer("MirrorPadOptions", ("mode",))),
+ BuiltinOperator.ABS: ("Abs", None),
+ BuiltinOperator.SPLIT_V: ("SplitV", OptionsSerializer("SplitVOptions", ("num_splits",))),
+ BuiltinOperator.UNIQUE: (
+ "Unique",
+ OptionsSerializer("UniqueOptions", (("idx_out_type", datatype_deserialize, datatype_serialize),)),
+ ),
+ BuiltinOperator.CEIL: ("Ceil", None),
+ BuiltinOperator.REVERSE_V2: ("ReverseV2", None),
+ BuiltinOperator.ADD_N: ("AddN", None),
+ BuiltinOperator.GATHER_ND: ("GatherNd", None),
+ BuiltinOperator.COS: ("Cos", None),
+ BuiltinOperator.WHERE: ("Where", None),
+ BuiltinOperator.RANK: ("Rank", None),
+ BuiltinOperator.ELU: ("Elu", None),
+ BuiltinOperator.REVERSE_SEQUENCE: (
+ "ReverseSequence",
+ OptionsSerializer("ReverseSequenceOptions", ("seq_dim", "batch_dim")),
+ ),
+ BuiltinOperator.MATRIX_DIAG: ("MatrixDiag", None),
+ BuiltinOperator.QUANTIZE: ("Quantize", None),
+ BuiltinOperator.MATRIX_SET_DIAG: ("MatrixSetDiag", None),
+ BuiltinOperator.IF: ("If", OptionsSerializer("IfOptions", ("then_subgraph_index", "else_subgraph_index"))),
+ BuiltinOperator.WHILE: ("While", OptionsSerializer("WhileOptions", ("cond_subgraph_index", "body_subgraph_index"))),
+ BuiltinOperator.NON_MAX_SUPPRESSION_V4: ("NonMaxSuppressionV4", OptionsSerializer("NonMaxSuppressionV4Options")),
+ BuiltinOperator.NON_MAX_SUPPRESSION_V5: ("NonMaxSuppressionV5", OptionsSerializer("NonMaxSuppressionV5Options")),
+ BuiltinOperator.SCATTER_ND: ("ScatterNd", OptionsSerializer("ScatterNdOptions")),
+ BuiltinOperator.SELECT_V2: ("SelectV2", OptionsSerializer("SelectV2Options")),
+ BuiltinOperator.DENSIFY: ("Densify", OptionsSerializer("DensifyOptions")),
+ BuiltinOperator.SEGMENT_SUM: ("SegmentSum", OptionsSerializer("SegmentSumOptions")),
+ BuiltinOperator.CUSTOM: (custom_prefix, CustomOptionsSerializer()),
+}
+
+builtin_operator_inv_map = {v[0]: (k, v[1]) for k, v in builtin_operator_map.items()}
+
+builtin_operator_inv_map["NpuOp"] = (BuiltinOperator.CUSTOM, CustomOptionsSerializer())
diff --git a/ethosu/vela/tflite_reader.py b/ethosu/vela/tflite_reader.py
new file mode 100644
index 0000000..535847d
--- /dev/null
+++ b/ethosu/vela/tflite_reader.py
@@ -0,0 +1,252 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Functions used to read from a TensorFlow Lite format file.
+
+from .tflite.Model import Model
+from .tflite.BuiltinOperator import BuiltinOperator
+
+import numpy as np
+import os.path
+from .nn_graph import Graph, Operation, Subgraph
+from .tensor import Tensor, QuantizationParameters
+
+from .tflite_mapping import builtin_operator_map, datatype_map, datatype_map_numpy, DataType
+
+
+def decode_str(s):
+ if s is None:
+ return ""
+ return s.decode("utf-8")
+
+
+def reshape_tensor_add_const_op(tens, reorder):
+ if not tens.reshaped:
+ original_shape = tens.shape
+ tens.name = tens.name + "_reshape"
+ tens.shape = [original_shape[idx] for idx in reorder]
+ tens.bandwidth_shape = tens.shape
+ tens.storage_shape = tens.shape
+
+ if tens.values is not None:
+ tens.values = tens.values.transpose(reorder)
+
+ if tens.quant_values is not None:
+ tens.quant_values = tens.quant_values.transpose(reorder)
+
+ op = Operation("Const", tens.name)
+ op.outputs = [tens]
+ tens.ops = [op]
+ tens.reshaped = True
+
+
+class TFLiteSubgraph:
+ def __init__(self, graph, subgraph):
+ self.graph = graph
+ self.name = decode_str(subgraph.Name())
+
+ self.tensors = []
+ for idx in range(subgraph.TensorsLength()):
+ self.tensors.append(self.parse_tensor(subgraph.Tensors(idx)))
+
+ for idx in range(subgraph.OperatorsLength()):
+ self.parse_operator(subgraph.Operators(idx))
+
+ self.outputs = [self.tensors[idx] for idx in subgraph.OutputsAsNumpy()]
+ self.inputs = [self.tensors[idx] for idx in subgraph.InputsAsNumpy()]
+
+ # Fix up tensors without operations. Generate either Placeholder or Constant ops
+ for tens in self.inputs:
+ assert not tens.ops
+ op = Operation("Placeholder", tens.name)
+ op.outputs = [tens]
+ tens.ops = [op]
+
+ for tens in self.tensors:
+ if not tens.ops:
+ op = Operation("Const", tens.name)
+ op.outputs = [tens]
+ tens.ops = [op]
+
+ def parse_tensor(self, tens_data):
+ np_shape = tens_data.ShapeAsNumpy()
+ shape = list(np_shape) if type(np_shape) is np.ndarray else []
+ name = decode_str(tens_data.Name())
+ dtype = datatype_map[tens_data.Type()]
+
+ tens = Tensor(shape, dtype, name)
+
+ quant = tens_data.Quantization()
+
+ def len1_array_to_scalar(arr):
+ # The following flatbuffer quantisation fields all return a scalar value of 0 if they are not definied in
+ # the input buffer. This is represented in Vela by using None.
+ # Otherwise, the fields returned are a single or multi-element array. In which case, single element arrays
+ # are converted to scalars
+ if isinstance(arr, int) and arr == 0:
+ return None
+ if len(arr) == 1:
+ return arr[0]
+ return arr
+
+ tens.quantization = QuantizationParameters()
+ tens.quantization.min = len1_array_to_scalar(quant.MinAsNumpy())
+ tens.quantization.max = len1_array_to_scalar(quant.MaxAsNumpy())
+ tens.quantization.scale_f32 = len1_array_to_scalar(quant.ScaleAsNumpy())
+ tens.quantization.zero_point = len1_array_to_scalar(quant.ZeroPointAsNumpy())
+
+ if dtype == DataType.uint8:
+ tens.quantization.quant_min = 0
+ tens.quantization.quant_max = (1 << dtype.bits) - 1
+ elif dtype in set((DataType.int8, DataType.int16, DataType.int32, DataType.int64)):
+ tens.quantization.quant_min = -(1 << (dtype.bits - 1))
+ tens.quantization.quant_max = (1 << (dtype.bits - 1)) - 1
+ else:
+ raise Exception("DataType '" + str(dtype) + "' is not supported for quantization.")
+
+ if tens.quantization.scale_f32 is None and tens.quantization.zero_point is None:
+ tens.quantization = None
+
+ tens.values = None
+ buf = self.graph.buffers[tens_data.Buffer()]
+ if buf is not None:
+ tens.values = np.array(buf.view(datatype_map_numpy[tens_data.Type()]).reshape(shape))
+ if tens.quantization is not None:
+ tens.quant_values = tens.values
+ tens.values = tens.quantization.dequantize(tens.quant_values)
+ return tens
+
+ def parse_operator(self, op_data):
+ op_type, opt_serializer = self.graph.operator_codes[op_data.OpcodeIndex()]
+ inputs = [self.tensors[idx] for idx in op_data.InputsAsNumpy()]
+ outputs = [self.tensors[idx] for idx in op_data.OutputsAsNumpy()]
+ name = "unknown_op_name"
+ if len(outputs):
+ name = outputs[0].name
+ op = Operation(op_type, name)
+ op.inputs = inputs
+ op.outputs = outputs
+ for out in op.outputs:
+ out.ops = [op]
+
+ activation_function_to_split_out = None
+
+ if op_type.startswith("DepthwiseConv2d") or op_type.startswith("Conv2D"):
+ reshape_tensor_add_const_op(inputs[1], (1, 2, 3, 0))
+
+ if op_type.startswith("FullyConnected"):
+ reshape_tensor_add_const_op(inputs[1], (1, 0))
+
+ if opt_serializer is not None:
+ op.attrs = opt_serializer.deserialize(op_data.BuiltinOptions(), op_data.CustomOptionsAsNumpy())
+
+ if "stride_w" in op.attrs:
+ op.attrs["strides"] = (1, op.attrs["stride_h"], op.attrs["stride_w"], 1)
+ if "filter_width" in op.attrs:
+ op.attrs["ksize"] = (1, op.attrs["filter_height"], op.attrs["filter_width"], 1)
+ if "dilation_w_factor" in op.attrs:
+ op.attrs["dilation"] = (1, op.attrs["dilation_h_factor"], op.attrs["dilation_w_factor"], 1)
+ if "depth_multiplier" in op.attrs:
+ op.attrs["channel_multiplier"] = op.attrs["depth_multiplier"]
+
+ if "fused_activation_function" in op.attrs:
+ if op_type in set(("ConcatTFLite",)):
+ act = op.attrs["fused_activation_function"]
+ del op.attrs["fused_activation_function"]
+ if act is not None:
+ activation_function_to_split_out = act
+
+ if activation_function_to_split_out is not None:
+ act_op = Operation(activation_function_to_split_out, name + activation_function_to_split_out)
+ out_tens = op.outputs[0]
+ intermediate_tens = out_tens.clone("_act_intermediate")
+ out_tens.ops = [act_op]
+ act_op.outputs = [out_tens]
+ intermediate_tens.ops = [op]
+ op.outputs[0] = intermediate_tens
+ act_op.inputs = [intermediate_tens]
+
+
+class TFLiteGraph:
+ def __init__(
+ self,
+ filename,
+ batch_size=1,
+ feed_dict={},
+ output_node_names=[],
+ initialisation_nodes=[],
+ ):
+
+ self.op_times = {}
+ if batch_size is None:
+ batch_size = 1
+ self.batch_size = batch_size
+ self.name = os.path.splitext(os.path.basename(filename))[0]
+ self.initialisation_nodes = initialisation_nodes
+
+ with open(filename, "rb") as f:
+ buf = bytearray(f.read())
+
+ model = Model.GetRootAsModel(buf, 0)
+
+ self.buffers = []
+ for idx in range(model.BuffersLength()):
+ self.buffers.append(self.parse_buffer(model.Buffers(idx)))
+
+ self.operator_codes = []
+ for idx in range(model.OperatorCodesLength()):
+ self.operator_codes.append(self.parse_operator_code(model.OperatorCodes(idx)))
+
+ self.subgraphs = []
+ for idx in range(model.SubgraphsLength()):
+ self.subgraphs.append(TFLiteSubgraph(self, model.Subgraphs(idx)))
+
+ self.nng = Graph(self.name, self.batch_size)
+ for tflite_sg in self.subgraphs:
+ sg = Subgraph(tflite_sg.name)
+ sg.original_inputs = tflite_sg.inputs # Preserve the original input order
+ sg.output_tensors = tflite_sg.outputs
+ self.nng.subgraphs.append(sg)
+
+ def parse_buffer(self, buf_data):
+ if buf_data.DataLength() == 0:
+ return None
+ data = buf_data.DataAsNumpy()
+ return data
+
+ def parse_operator_code(self, code):
+ c = code.BuiltinCode()
+ op_type, ser = builtin_operator_map[c]
+ if c == BuiltinOperator.CUSTOM:
+ op_type += decode_str(code.CustomCode())
+ return op_type, ser
+
+
+def read_tflite(
+ filename,
+ batch_size=1,
+ feed_dict={},
+ output_node_names=[],
+ initialisation_nodes=[],
+):
+ tflite_graph = TFLiteGraph(
+ filename, batch_size, feed_dict, output_node_names, initialisation_nodes
+ )
+ nng = tflite_graph.nng
+ nng.refresh_after_modification()
+ return nng
diff --git a/ethosu/vela/tflite_writer.py b/ethosu/vela/tflite_writer.py
new file mode 100644
index 0000000..f55d1ce
--- /dev/null
+++ b/ethosu/vela/tflite_writer.py
@@ -0,0 +1,424 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Functions used to write to a TensorFlow Lite format file. Supports adding in file identifiers.
+
+import flatbuffers
+
+from .tflite import Tensor
+from .tflite import QuantizationParameters
+from .tflite import Model
+from .tflite import SubGraph
+from .tflite import OperatorCode
+from .tflite import Operator
+from .tflite import Buffer
+from .tflite import Metadata
+
+import numpy as np
+
+from .tflite_mapping import datatype_inv_map, builtin_operator_inv_map, custom_prefix, BuiltinOperator
+from .nn_graph import PassPlacement
+from .tensor import TensorPurpose, MemArea
+from flatbuffers.builder import UOffsetTFlags
+
+tflite_version = 3
+tflite_file_identifier = "TFL" + str(tflite_version)
+
+
+import flatbuffers.number_types as N
+from flatbuffers import encode
+
+
+def FinishWithFileIdentifier(self, rootTable, fid):
+ if fid is None or len(fid) != 4:
+ raise Exception("fid must be 4 chars")
+
+ flags = N.Uint8Flags
+ prepSize = 4
+ self.Prep(self.minalign, prepSize + len(fid))
+ for i in range(3, -1, -1):
+ self.head = self.head - flags.bytewidth
+ encode.Write(flags.packer_type, self.Bytes, self.Head(), ord(fid[i]))
+
+ return self.Finish(rootTable)
+
+
+flatbuffers.Builder.FinishWithFileIdentifier = FinishWithFileIdentifier
+
+
+def make_vector(v):
+ try:
+ len(v)
+ return v
+ except TypeError:
+ return [v]
+
+
+class TFLiteSerialiser:
+ def __init__(self, nng):
+ self.builder = flatbuffers.Builder(0)
+ self.nng = nng
+
+ self.scratch_buf_id = 0 # Always assign scratch to buffer 0
+ self.buffer_offsets_map = {}
+ self.buffers_to_write = [] # have an empty array there
+
+ self.input_tensors = []
+ self.ops_to_ignore = set(("Const", "Placeholder", "SubgraphInput"))
+
+ self.tensors_to_reshape = {}
+
+ self.subgraphs_to_write = [sg for sg in self.nng.subgraphs if sg.placement == PassPlacement.Cpu]
+
+ all_ops = []
+ for sg in self.subgraphs_to_write:
+ for ps in sg.passes:
+ for op in ps.ops:
+ if op.type not in self.ops_to_ignore:
+ all_ops.append(op)
+ if op.type.startswith("Conv2D") or op.type.startswith("DepthwiseConv2d"):
+ self.tensors_to_reshape[op.inputs[1]] = (3, 0, 1, 2)
+ if op.type.startswith("FullyConnected"):
+ self.tensors_to_reshape[op.inputs[1]] = (1, 0)
+
+ self.operator_codes = list(sorted(set(op.type for op in all_ops)))
+ self.operator_code_map = {}
+
+ def write_byte_vector(self, v, alignment=1):
+ builder = self.builder
+ builder.StartVector(1, len(v), alignment)
+ for e in v[::-1]:
+ builder.PrependByte(e)
+ return builder.EndVector(len(v))
+
+ def write_int_vector(self, v):
+ builder = self.builder
+ builder.StartVector(4, len(v), 4)
+ for e in v[::-1]:
+ builder.PrependInt32(e)
+ return builder.EndVector(len(v))
+
+ def write_long_vector(self, v):
+ builder = self.builder
+ builder.StartVector(8, len(v), 8)
+ for e in v[::-1]:
+ builder.PrependInt64(e)
+ return builder.EndVector(len(v))
+
+ def write_float_vector(self, v):
+ builder = self.builder
+ builder.StartVector(4, len(v), 4)
+ for e in v[::-1]:
+ builder.PrependFloat32(e)
+ return builder.EndVector(len(v))
+
+ def write_offset_vector(self, v):
+ builder = self.builder
+ builder.StartVector(4, len(v), 4)
+ for e in v[::-1]:
+ builder.PrependUOffsetTRelative(e)
+ return builder.EndVector(len(v))
+
+ def assign_buffers_to_tensors(self, tensors):
+ buffer_map = {}
+ scratch_tensor = [tens for tens in tensors if tens.purpose == TensorPurpose.Scratch][0]
+ buf_idx = 1
+
+ for tens in tensors:
+ if tens.mem_area == scratch_tensor.mem_area:
+ buffer_map[tens] = self.scratch_buf_id
+ else:
+ buffer_map[tens] = buf_idx
+ buf_idx += 1
+
+ # Initialize buffers_to_write to a length equal to numer of buffers so
+ # they can be appended at the correct index during tensor serialization
+ self.buffers_to_write = [None] * (buf_idx)
+
+ return buffer_map
+
+ def serialise_operator_code(self, idx, code):
+ builder = self.builder
+ custom_code_offset = None
+ if code.startswith(custom_prefix):
+ tf_code, opt_serializer = builtin_operator_inv_map[custom_prefix]
+ custom_code_offset = builder.CreateString(code[len(custom_prefix) :])
+ else:
+ try:
+ tf_code, opt_serializer = builtin_operator_inv_map[code]
+ except KeyError:
+ print(
+ "Warning: Writing operation %s, which does not have a direct TensorFlow Lite mapping, as a custom operation"
+ % (code,)
+ )
+ tf_code, opt_serializer = builtin_operator_inv_map[custom_prefix]
+
+ if tf_code == BuiltinOperator.CUSTOM:
+ assert code == "NpuOp" # Currently only support serialising NPU operators as a custom op
+ custom_code_offset = builder.CreateString("ethos-u")
+
+ self.operator_code_map[code] = (idx, tf_code, opt_serializer)
+
+ OperatorCode.OperatorCodeStart(builder)
+ OperatorCode.OperatorCodeAddBuiltinCode(builder, tf_code)
+ if custom_code_offset is not None:
+ OperatorCode.OperatorCodeAddCustomCode(builder, custom_code_offset)
+
+ return OperatorCode.OperatorCodeEnd(builder)
+
+ def serialise_quantization_parameters(self, quant):
+ builder = self.builder
+
+ min = None
+ max = None
+ scale = None
+ zero_point = None
+ if quant is not None:
+ if quant.min is not None:
+ min = self.write_float_vector(make_vector(quant.min))
+ if quant.max is not None:
+ max = self.write_float_vector(make_vector(quant.max))
+ if quant.scale_f32 is not None:
+ scale = self.write_float_vector(make_vector(quant.scale_f32))
+ if quant.zero_point is not None:
+ zero_point = self.write_long_vector(make_vector(quant.zero_point))
+
+ QuantizationParameters.QuantizationParametersStart(builder)
+ if min is not None:
+ QuantizationParameters.QuantizationParametersAddMin(builder, min)
+ if max is not None:
+ QuantizationParameters.QuantizationParametersAddMax(builder, max)
+ if scale is not None:
+ QuantizationParameters.QuantizationParametersAddScale(builder, scale)
+ if zero_point is not None:
+ QuantizationParameters.QuantizationParametersAddZeroPoint(builder, zero_point)
+ return QuantizationParameters.QuantizationParametersEnd(builder)
+
+ def serialise_tensor(self, tens):
+ builder = self.builder
+ tens_shape = tens.shape
+ values = tens.quant_values
+ if values is None:
+ values = tens.values
+
+ if values is None:
+ values = np.empty(shape=(0), dtype=np.uint8)
+
+ if tens in self.tensors_to_reshape:
+ reorder = self.tensors_to_reshape[tens]
+ tens_shape = [tens_shape[idx] for idx in reorder]
+ values = values.transpose(reorder)
+
+ if tens.purpose == TensorPurpose.Scratch:
+ tens_shape = [0]
+ self.buffers_to_write[self.scratch_buf_id] = values.flatten().view(np.uint8)
+
+ buf_id = self.buffer_map[tens]
+ if buf_id != self.scratch_buf_id:
+ self.buffers_to_write[buf_id] = values.flatten().view(np.uint8)
+
+ shape = self.write_int_vector(tens_shape)
+
+ name = builder.CreateString(tens.name)
+ quant = self.serialise_quantization_parameters(tens.quantization)
+
+ Tensor.TensorStart(builder)
+ Tensor.TensorAddShape(builder, shape)
+ Tensor.TensorAddType(builder, datatype_inv_map[tens.dtype])
+ # All tensors must have a valid backing buffer, even if it is empty.
+ # Empty buffers should be kept unique for TensorFlow Lite Micro
+ Tensor.TensorAddBuffer(builder, buf_id)
+ Tensor.TensorAddName(builder, name)
+ Tensor.TensorAddQuantization(builder, quant)
+
+ res = Tensor.TensorEnd(builder)
+ return res
+
+ def serialise_operator(self, op):
+ builder = self.builder
+
+ inputs_offset = self.write_int_vector([self.tensor_map[tens] for tens in op.inputs])
+ outputs_offset = self.write_int_vector([self.tensor_map[tens] for tens in op.outputs])
+
+ op_idx, tflop, opt_serializer = self.operator_code_map[op.type]
+
+ builtin_opt_offset = None
+ custom_opt_offset = None
+ if opt_serializer is not None:
+ attrs = dict(op.attrs)
+ if "strides" in attrs:
+ attrs["stride_h"] = attrs["strides"][1]
+ attrs["stride_w"] = attrs["strides"][2]
+ if "ksize" in attrs:
+ attrs["filter_height"] = attrs["ksize"][1]
+ attrs["filter_width"] = attrs["ksize"][2]
+ if "dilation" in attrs:
+ attrs["dilation_h_factor"] = attrs["dilation"][1]
+ attrs["dilation_w_factor"] = attrs["dilation"][2]
+ if "channel_multiplier" in attrs:
+ attrs["depth_multiplier"] = attrs["channel_multiplier"]
+
+ builtin_opt_offset, custom_opt_offset = opt_serializer.serialize(builder, attrs)
+
+ mutating_variable_inputs_offset = self.write_byte_vector([])
+ Operator.OperatorStart(builder)
+ Operator.OperatorAddOpcodeIndex(builder, op_idx)
+ Operator.OperatorAddInputs(builder, inputs_offset)
+ Operator.OperatorAddOutputs(builder, outputs_offset)
+
+ if builtin_opt_offset is not None:
+ Operator.OperatorAddBuiltinOptionsType(builder, opt_serializer.builtin_opt_type)
+ Operator.OperatorAddBuiltinOptions(builder, builtin_opt_offset)
+ if custom_opt_offset is not None:
+ Operator.OperatorAddCustomOptions(builder, custom_opt_offset)
+ Operator.OperatorAddCustomOptionsFormat(builder, opt_serializer.custom_opt_format)
+
+ Operator.OperatorAddMutatingVariableInputs(builder, mutating_variable_inputs_offset)
+ return Operator.OperatorEnd(builder)
+
+ def serialise_subgraph(self, sg):
+ builder = self.builder
+ tensor_set = set()
+
+ all_ops = []
+ for ps in sg.passes:
+ for op in ps.ops:
+ if op.type not in self.ops_to_ignore:
+ all_ops.append(op)
+
+ for op in all_ops:
+ for tens in op.inputs + op.outputs:
+ tensor_set.add(tens)
+
+ all_tensors = [tens for nm, idx, tens in sorted((tens.name, idx, tens) for idx, tens in enumerate(tensor_set))]
+
+ self.tensor_map = {tens: idx for idx, tens in enumerate(all_tensors)}
+ self.buffer_map = self.assign_buffers_to_tensors(all_tensors)
+
+ tensors_offset = self.write_offset_vector([self.serialise_tensor(tens) for tens in all_tensors])
+
+ # Add the Scratch Tensor as input to the NPU subgraph to get it allocated by TensorFlow Lite Micro
+ scratch_tensor_idx = [v for k, v in self.tensor_map.items() if k.name.endswith("scratch")]
+
+ # Make sure the input_tensors haven't been modified
+ assert all(inp in sg.original_inputs for inp in sg.input_tensors)
+ inputs_offset = self.write_int_vector(
+ [self.tensor_map[tens] for tens in sg.original_inputs] + scratch_tensor_idx
+ )
+ outputs_offset = self.write_int_vector([self.tensor_map[tens] for tens in sg.output_tensors])
+
+ operators_offset = self.write_offset_vector([self.serialise_operator(op) for op in all_ops])
+
+ SubGraph.SubGraphStart(builder)
+ SubGraph.SubGraphAddTensors(builder, tensors_offset)
+ SubGraph.SubGraphAddInputs(builder, inputs_offset)
+ SubGraph.SubGraphAddOutputs(builder, outputs_offset)
+
+ SubGraph.SubGraphAddOperators(builder, operators_offset)
+
+ return SubGraph.SubGraphEnd(builder)
+
+ def write_aligned_bytes(self, buf):
+ builder = self.builder
+ builder.nested = True
+ data = bytes(buf)
+ length_bytes = UOffsetTFlags.py_type(len(data))
+ builder.Prep(16, length_bytes) # Reserve aligned storage
+ builder.head = UOffsetTFlags.py_type(builder.Head() - length_bytes) # Update FlatBuffer internal pointer
+ builder.Bytes[builder.Head() : builder.Head() + length_bytes] = data # Assign bytes to aligned area
+ return builder.EndVector(length_bytes)
+
+ def serialise_buffer(self, buf):
+ builder = self.builder
+ data = None
+ if buf is not None:
+ data = self.write_aligned_bytes(buf)
+ Buffer.BufferStart(builder)
+ if data is not None:
+ Buffer.BufferAddData(builder, data)
+ return Buffer.BufferEnd(builder)
+
+ def serialise_metadata(self, metadata):
+ builder = self.builder
+ name = builder.CreateString(metadata[0])
+
+ Metadata.MetadataStart(builder)
+ Metadata.MetadataAddName(builder, name)
+ Metadata.MetadataAddBuffer(builder, metadata[1])
+
+ return Metadata.MetadataEnd(builder)
+
+ def serialise_model(self):
+ builder = self.builder
+ operator_code_offset = self.write_offset_vector(
+ [self.serialise_operator_code(idx, code) for idx, code in enumerate(self.operator_codes)]
+ )
+
+ description = builder.CreateString("Vela Optimised")
+
+ subgraph_offset = self.write_offset_vector([self.serialise_subgraph(sg) for sg in self.subgraphs_to_write])
+
+ # Fill the metadata buffer
+ version = np.int32(0)
+ subgraph_idx = np.int32(len(self.subgraphs_to_write)) # Only 1 supported currently
+ nbr_tensors = np.int32(len(self.tensor_map))
+
+ # An offset of -1 indicates that the tensor will be allocated online by Tensorflow Lite Micro
+ offsets = [np.int32(-1)] * nbr_tensors
+
+ # Ensure that the order of the offsets match the order of the tensors
+ for tens, idx in self.tensor_map.items():
+ if tens.mem_area == MemArea.Sram:
+ offsets[idx] = np.int32(tens.address)
+
+ metadata_buffer = np.array([version, subgraph_idx, nbr_tensors] + offsets)
+ self.buffers_to_write.append(metadata_buffer)
+
+ buffers_offset = self.write_offset_vector([self.serialise_buffer(buf) for buf in self.buffers_to_write])
+
+ metadata_list = [("OfflineMemoryAllocation", len(self.buffers_to_write) - 1)]
+ metadata_offset = self.write_offset_vector([self.serialise_metadata(metadata) for metadata in metadata_list])
+
+ Model.ModelStart(builder)
+ Model.ModelAddVersion(builder, tflite_version)
+ Model.ModelAddOperatorCodes(builder, operator_code_offset)
+ Model.ModelAddSubgraphs(builder, subgraph_offset)
+ Model.ModelAddDescription(builder, description)
+ Model.ModelAddBuffers(builder, buffers_offset)
+ Model.ModelAddMetadata(builder, metadata_offset)
+ return Model.ModelEnd(builder)
+
+ def serialise(self):
+
+ model = self.serialise_model()
+
+ self.builder.FinishWithFileIdentifier(model, tflite_file_identifier)
+
+ return self.builder.Output()
+
+ def write(self, filename):
+ with open(self.filename, "wb") as f:
+ f.write(self.serialised_buf)
+
+
+def write_tflite(nng, filename):
+ writer = TFLiteSerialiser(nng)
+ buf = writer.serialise()
+
+ with open(filename, "wb") as f:
+ f.write(buf)
diff --git a/ethosu/vela/vela.py b/ethosu/vela/vela.py
new file mode 100644
index 0000000..f07aec8
--- /dev/null
+++ b/ethosu/vela/vela.py
@@ -0,0 +1,334 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Main entry point for the Vela compiler.
+#
+# Provides command line interface, options parsing, and network loading. Before calling the compiler driver.
+
+import sys
+import os.path
+import os
+import time
+import subprocess
+import configparser
+import argparse
+import ast
+
+from . import architecture_features
+from . import stats_writer
+from . import tflite_writer
+from . import model_reader
+from . import compiler_driver
+from . import scheduler
+from ._version import __version__
+from .scheduler import ParetoMetric
+from .nn_graph import MemArea, TensorFormat, TensorAllocator, PassPlacement
+
+
+def process(fname, arch, model_reader_options, compiler_options, scheduler_options):
+ if compiler_options.timing:
+ start = time.time()
+
+ nng = model_reader.read_model(fname, model_reader_options)
+
+ if not nng:
+ print("reading of", fname, "failed")
+ assert False
+
+ if compiler_options.verbose_operators:
+ nng.print_operators()
+
+ if compiler_options.timing:
+ stop = time.time()
+ print("Model reading took %f s" % (stop - start))
+ start = time.time()
+
+ compiler_driver.compiler_driver(nng, arch, compiler_options, scheduler_options)
+
+ passes_csv_file = "%s/%s_pass-breakdown_%s.csv" % (compiler_options.output_dir, nng.name, arch.system_config)
+ stats_writer.write_pass_metrics_csv(nng, passes_csv_file)
+
+ summary_csv_file = "%s/%s_summary_%s.csv" % (compiler_options.output_dir, nng.name, arch.system_config)
+ stats_writer.write_summary_metrics_csv(nng, summary_csv_file, arch)
+
+ stats_writer.print_performance_metrics(nng, show_cpu_operations=compiler_options.show_cpu_operations, arch=arch)
+
+ if fname.endswith(".tflite"):
+ tflite_writer.write_tflite(nng, "%s/%s_vela.tflite" % (compiler_options.output_dir, nng.name))
+
+ if compiler_options.timing:
+ stop = time.time()
+ print("Compiler driver took %f s" % (stop - start))
+
+ return nng
+
+
+def print_subgraph_io_summary(nng):
+ """Print a summary of all the input and output tensor sizes for all subgraphs.
+ Also displays the total tensor size and the memory used area for sram.
+ """
+
+ print("Subgraph IO Summary")
+ print("-------------------")
+ print("NNG: {0}".format(nng.name))
+ max_sg_size = 0
+ for sg in reversed(nng.subgraphs):
+ print(" Subgraph: {0} = {1}".format(sg.name, sg.placement))
+ sg_size = 0
+
+ if sg.placement == PassPlacement.Npu:
+ for tens in sg.input_tensors + [sg.scratch_tensor] + sg.output_tensors:
+ if tens in sg.input_tensors:
+ tens_dir = "In"
+ elif tens in sg.output_tensors:
+ tens_dir = "Out"
+ else:
+ tens_dir = "In/Out"
+
+ size = tens.elements() * tens.element_size() / 1024.0
+ sg_size = sg_size + size
+ print(" Tensor [{0}]: {1} = {2} KiB".format(tens_dir, tens.name, size))
+
+ print(" Total Size = {0} KiB".format(sg_size))
+ print(" SRAM Memory Used = {0} KiB".format(sg.memory_used.get(MemArea.Sram, 0) / 1024.0))
+ max_sg_size = max(sg_size, max_sg_size)
+
+ print(" Maximum Subgraph Size = {0} KiB".format(max_sg_size))
+
+
+def main(args=None):
+ if args is None:
+ args = sys.argv[1:]
+
+ parser = argparse.ArgumentParser(prog="vela", description="Neural network model compiler for Ethos-U55")
+
+ parser.add_argument(
+ "network", metavar="NETWORK", type=str, default=None, nargs=None, help="Filename of network to process"
+ )
+
+ parser.add_argument("--version", action="version", version=__version__)
+ parser.add_argument(
+ "--output-dir", type=str, default="output", help="Output directory to write files to (default: %(default)s)"
+ )
+ parser.add_argument("--config", type=str, help="Location of vela configuration file")
+ parser.add_argument("--batch-size", type=int, default=1, help="Batch size (default: %(default)s)")
+
+ parser.add_argument("--verbose-graph", action="store_true", help="Verbose graph rewriter")
+ parser.add_argument("--verbose-quantization", action="store_true", help="Verbose quantization")
+ parser.add_argument("--verbose-packing", action="store_true", help="Verbose pass packing")
+ parser.add_argument("--verbose-tensor-purpose", action="store_true", help="Verbose tensor purpose")
+ parser.add_argument("--verbose-tensor-format", action="store_true", help="Verbose tensor format")
+ parser.add_argument("--verbose-schedule", action="store_true", help="Verbose schedule")
+ parser.add_argument(
+ "--verbose-pareto-frontier-schedules",
+ action="store_true",
+ help="Show all schedules along the pareto frontier of optimisation criteria",
+ )
+ parser.add_argument("--verbose-allocation", action="store_true", help="Verbose tensor allocation")
+ parser.add_argument(
+ "--verbose-high-level-command-stream", action="store_true", help="Verbose high level command stream"
+ )
+ parser.add_argument(
+ "--verbose-register-command-stream", action="store_true", help="Verbose register command stream"
+ )
+ parser.add_argument("--verbose-operators", action="store_true", help="Verbose operator list")
+
+ parser.add_argument(
+ "--show-minimum-possible-allocation", action="store_true", help="Show the minimum possible allocation"
+ )
+ parser.add_argument(
+ "--show-cpu-operations", action="store_true", help="Show the operations that fall back to the CPU"
+ )
+ parser.add_argument(
+ "--cascading",
+ type=ast.literal_eval,
+ default=True,
+ choices=[True, False],
+ help="Controls the packing of multiple passes into a cascade (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--ifm-ofm-overlap",
+ type=ast.literal_eval,
+ default=True,
+ choices=[True, False],
+ help="Controls the overlapping of IFM and OFM buffers (default: %(default)s)",
+ )
+ parser.add_argument("--force-block-config", type=str, default="", help="Force a specific block configuration HxWxC")
+ parser.add_argument(
+ "--inter-pass-cycle-delay",
+ type=int,
+ default=0,
+ help="Artificial delay between passes, measured in NPU cycles (default: %(default)s)",
+ )
+ parser.add_argument("--timing", action="store_true", help="Time the compiler doing operations")
+ parser.add_argument(
+ "--accelerator-config",
+ type=str,
+ default="ethos-u55-256",
+ choices=list(architecture_features.ArchitectureFeatures.accelerator_configs.keys()),
+ help="Accelerator configuration to use (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--system-config",
+ type=str,
+ default="internal-default",
+ help="System configuration to use (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--dram-bandwidth",
+ type=float,
+ default=0.0,
+ help="DRAM memory bandwidth in GB/s, use zero to select the value from system config (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--permanent-storage",
+ default=MemArea.OffChipFlash,
+ type=lambda s: MemArea[s],
+ choices=list(MemArea)[3:-1],
+ help=(
+ "Memory area for permanent storage. To store the weights and other constant data in SRAM select "
+ "'OnChipFlash' (default: %(default)s)"
+ ),
+ )
+ parser.add_argument(
+ "--tensor-allocator",
+ default=TensorAllocator.Greedy,
+ type=lambda s: TensorAllocator[s],
+ choices=list(TensorAllocator),
+ help="Tensor Allocator algorithm (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--show-subgraph-io-summary",
+ action="store_true",
+ help="Shows a summary of all the subgraphs and their inputs and outputs",
+ )
+ parser.add_argument(
+ "--ifm-streaming",
+ type=ast.literal_eval,
+ default=True,
+ choices=[True, False],
+ help="Controls scheduler IFM streaming search (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--block-config-limit",
+ type=int,
+ default=16,
+ help="Limit block config search space, use zero for unlimited (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--global-memory-clock-scale",
+ type=float,
+ default=1.0,
+ help=(
+ "Performs an additional scaling of the individual memory clock scales specified by the system config "
+ "(default: %(default)s)"
+ ),
+ )
+ parser.add_argument(
+ "--pareto-metric",
+ default=ParetoMetric.BwCycMem,
+ type=lambda s: ParetoMetric[s],
+ choices=list(ParetoMetric),
+ help="Controls the calculation of the pareto metric (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--recursion-limit",
+ type=int,
+ default=10000,
+ help="Set the recursion depth limit, may result in RecursionError if too low (default: %(default)s)",
+ )
+ parser.add_argument(
+ "--max-block-dependency",
+ type=int,
+ default=architecture_features.ArchitectureFeatures.MAX_BLOCKDEP,
+ choices=range(0, architecture_features.ArchitectureFeatures.MAX_BLOCKDEP + 1),
+ help=(
+ "Set the maximum value that can be used for the block dependency between npu kernel operations "
+ "(default: %(default)s)"
+ ),
+ )
+
+ args = parser.parse_args(args=args)
+
+ # Read configuration file
+ config_file = args.config
+ config = None
+ if config_file is not None:
+ with open(config_file) as f:
+ config = configparser.ConfigParser()
+ config.read_file(f)
+
+ if args.network is None:
+ parser.error("the following argument is required: NETWORK")
+
+ sys.setrecursionlimit(args.recursion_limit)
+
+ if args.force_block_config:
+ force_block_config = architecture_features.Block.from_string(args.force_block_config)
+ else:
+ force_block_config = None
+
+ arch = architecture_features.ArchitectureFeatures(
+ vela_config=config,
+ system_config=args.system_config,
+ accelerator_config=args.accelerator_config,
+ permanent_storage=args.permanent_storage,
+ inter_pass_cycle_delay=args.inter_pass_cycle_delay,
+ dram_bandwidth=args.dram_bandwidth,
+ override_block_config=force_block_config,
+ block_config_limit=args.block_config_limit,
+ global_memory_clock_scale=args.global_memory_clock_scale,
+ max_blockdep=args.max_block_dependency,
+ )
+
+ compiler_options = compiler_driver.CompilerOptions(
+ verbose_graph=args.verbose_graph,
+ verbose_quantization=args.verbose_quantization,
+ verbose_packing=args.verbose_packing,
+ verbose_tensor_purpose=args.verbose_tensor_purpose,
+ verbose_tensor_format=args.verbose_tensor_format,
+ verbose_allocation=args.verbose_allocation,
+ verbose_high_level_command_stream=args.verbose_high_level_command_stream,
+ verbose_register_command_stream=args.verbose_register_command_stream,
+ verbose_operators=args.verbose_operators,
+ show_minimum_possible_allocation=args.show_minimum_possible_allocation,
+ show_cpu_operations=args.show_cpu_operations,
+ tensor_allocator=args.tensor_allocator,
+ timing=args.timing,
+ output_dir=args.output_dir,
+ )
+
+ scheduler_options = scheduler.SchedulerOptions(
+ use_cascading=args.cascading,
+ use_ifm_ofm_overlap=args.ifm_ofm_overlap,
+ verbose_schedule=args.verbose_schedule,
+ verbose_pareto_frontier_schedules=args.verbose_pareto_frontier_schedules,
+ use_ifm_streaming=args.ifm_streaming,
+ pareto_metric=args.pareto_metric,
+ )
+
+ model_reader_options = model_reader.ModelReaderOptions(batch_size=args.batch_size)
+
+ os.makedirs(args.output_dir, exist_ok=True)
+
+ nng = process(args.network, arch, model_reader_options, compiler_options, scheduler_options)
+
+ if args.show_subgraph_io_summary:
+ print_subgraph_io_summary(nng)
+
+ return 0
diff --git a/ethosu/vela/weight_compressor.py b/ethosu/vela/weight_compressor.py
new file mode 100644
index 0000000..0b4ac69
--- /dev/null
+++ b/ethosu/vela/weight_compressor.py
@@ -0,0 +1,387 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Compresses and pads the weigths. It also calculates the scales and packs with the biases.
+
+import os
+import sys
+import enum
+import math
+import numpy as np
+from collections import namedtuple
+from .numeric_util import round_up
+from .scaling import quantise_scale
+from .tensor import TensorPurpose, TensorSubPurpose, TensorFormat, TensorBlockTraversal
+from .operation import NpuBlockType
+from .architecture_features import Block
+from .nn_graph import SchedulingStrategy
+from .data_type import DataType
+
+from ethosu import mlw_codec
+
+
+def encode(weight_stream):
+ assert np.amin(weight_stream) >= -255
+ assert np.amax(weight_stream) <= 255
+
+ # Encode flattened signed weight stream
+ compressed = mlw_codec.encode(weight_stream)
+
+ # pad with 0xFF as needed so the length of the weight stream
+ # is a multiple of 16
+
+ while (len(compressed) % 16) != 0:
+ compressed.append(0xFF)
+
+ return compressed
+
+
+def generate_brick(arch, brick_weights, ofm_block, block_traversal, ifm_bitdepth):
+ is_depthwise = block_traversal == TensorBlockTraversal.DepthWise
+ is_partkernel = block_traversal == TensorBlockTraversal.PartKernelFirst
+ subkernel_max = arch.subkernel_max
+ ofm_ublock = arch.ofm_ublock
+ ifm_ublock = arch.ifm_ublock
+ # Expect weights formatted HWIO
+ ofm_depth = brick_weights.shape[-1]
+ ifm_depth = brick_weights.shape[-2]
+ kernel_width = brick_weights.shape[-3]
+ kernel_height = brick_weights.shape[-4]
+ # IFM block depth
+ if is_partkernel or (ifm_bitdepth == 16):
+ # IFM block depth is always 16 for part-kernel-first
+ ifm_block_depth = 16
+ elif ifm_bitdepth == 8:
+ ifm_block_depth = 32
+ else:
+ assert False
+
+ stream = []
+
+ # Top level striping - OFM blocks in the entire brick's depth
+ for ofm_block_z in range(0, ofm_depth, ofm_block.depth):
+ clipped_ofm_block_depth = min(ofm_block.depth, ofm_depth - ofm_block_z)
+ # IFM blocks required for the brick
+ for ifm_block_z in range(0, (1 if is_depthwise else ifm_depth), ifm_block_depth):
+ if is_depthwise:
+ clipped_ifm_block_depth = ifm_ublock.depth
+ else:
+ clipped_ifm_block_depth = (
+ min(ifm_block_depth, ifm_depth - ifm_block_z) if is_partkernel else ifm_block_depth
+ )
+ # Weight decomposition
+ # Subkernel Splitting (H)
+ for subkernel_y in range(0, kernel_height, subkernel_max.height):
+ sub_height = min(kernel_height - subkernel_y, subkernel_max.height)
+ # Subkernel splitting (W)
+ for subkernel_x in range(0, kernel_width, subkernel_max.width):
+ sub_width = min(kernel_width - subkernel_x, subkernel_max.width)
+ subkernel_elements = sub_width * sub_height
+ # Part kernel first works across the kernel H/W and needs padding
+ if is_partkernel:
+ if ifm_bitdepth == 16 and subkernel_elements % 2 != 0:
+ subkernel_elements = int(math.ceil(subkernel_elements / 2) * 2)
+ elif ifm_bitdepth == 8 and subkernel_elements % 4 != 0:
+ subkernel_elements = int(math.ceil(subkernel_elements / 4) * 4)
+
+ # Depthwise Conv requires multiple of 4 kernel elements in its weight block
+ # this is different from normal conv which is considered "weights depth-first"
+ elif is_depthwise:
+ subkernel_elements = int(math.ceil(subkernel_elements / 4.0) * 4)
+
+ ifm_block_depth_outer = clipped_ifm_block_depth if is_partkernel else 1
+ ifm_block_depth_inner = 1 if is_partkernel else clipped_ifm_block_depth
+ # IFM Ublocks in IFM-block over depth for part-kernel-first mode
+ # For depth-first IFM Ublocks are traversed after subkernel elements so this loop is ignored.
+ for ifm_ublk_outer in range(0, ifm_block_depth_outer, ifm_ublock.depth):
+ # OFM Ublocks in OFM-block over depth
+ for ofm_ublk in range(0, clipped_ofm_block_depth, ofm_ublock.depth):
+ # HW Kernel element traversal - cannot be a H/W loop due to element
+ # padding requirement on depthwise/part-kernel configurations
+ for element in range(subkernel_elements):
+ kx = element % sub_width
+ ky = element // sub_width
+ # IFM Ublocks in IFM-block over depth (only 1 ublock if depthwise)
+ # In case of part-kernel-first IFM Ublock traversal have already been handled
+ # and this loop is ignored.
+ for ifm_ublk_inner in range(0, ifm_block_depth_inner, ifm_ublock.depth):
+ # Feed OFM ublock elements
+ for ofm_ublock_z in range(ofm_ublock.depth):
+ # Source IFM ublock elements (only 1 element deep if depthwise)
+ for ifm_ublock_z in range(1 if is_depthwise else ifm_ublock.depth):
+ # Source position within the current subkernel
+ wx = subkernel_x + kx
+ wy = subkernel_y + ky
+ # Source IFM/OFM slices
+ ifm_ublk = ifm_ublk_inner + ifm_ublk_outer
+ ifm_z = ifm_block_z + ifm_ublk + ifm_ublock_z
+ ofm_z = ofm_block_z + ofm_ublk + ofm_ublock_z
+ if (ifm_z >= ifm_depth) or (ofm_z >= ofm_depth) or (ky >= sub_height):
+ stream.append(0)
+ else:
+ stream.append(brick_weights[wy][wx][ifm_z][ofm_z])
+ return stream
+
+
+# Compress the weights
+def compress_weights(tens, arch, npu_block_type, ofm_block, ofm_depth_step, min_val=None, max_val=None):
+ assert tens.purpose == TensorPurpose.Weights
+ assert tens.format == TensorFormat.WeightsCompressed
+
+ WeightCompressionConfig = namedtuple("WeightCompressionConfig", ["npu_block_type", "ofm_block", "ofm_depth_step"])
+
+ # check if weights have already been compressed
+ wcc = tens.weight_compression_config
+ if wcc is not None:
+ assert wcc.npu_block_type == npu_block_type, "Weights not used by the same operator type"
+
+ if wcc.ofm_block == ofm_block and wcc.ofm_depth_step == ofm_depth_step:
+ return
+
+ assert tens.quantization is not None
+ assert tens.quantization.scale_f32 is not None
+ assert tens.quantization.zero_point is not None
+
+ zero_point = tens.quantization.zero_point
+ quant_buf = tens.quant_values.astype(np.int64)
+
+ # Early zero-point correction
+ weights = quant_buf - zero_point
+
+ if len(weights.shape) == 2:
+ weights = np.expand_dims(np.expand_dims(weights, axis=0), axis=0)
+ weights_shape = (weights.shape[0], 1, 1, weights.shape[1])
+ else:
+ weights_shape = weights.shape
+
+ compression_scales = []
+ compressed_offsets = []
+ encoded_streams = []
+ offset = 0
+ max_single_buffer_len = 0
+
+ ifm_bitdepth = tens.consumer_list[0].inputs[0].dtype.size_in_bits()
+ ifm_depth = weights.shape[-2]
+ if npu_block_type == NpuBlockType.ConvolutionDepthWise:
+ tens.block_traversal = TensorBlockTraversal.DepthWise
+ if npu_block_type == NpuBlockType.ConvolutionMxN:
+ # Determine which block traversal strategy has better DPU utilization
+ kernel_size = weights_shape[0] * weights_shape[1]
+ depth_utilization = weights_shape[2] / round_up(weights_shape[2], 32 if ifm_bitdepth == 8 else 16)
+ part_kernel_utilization = (weights_shape[2] / round_up(weights_shape[2], 8)) * (
+ kernel_size / round_up(kernel_size, 4 if ifm_bitdepth == 8 else 2)
+ )
+ if part_kernel_utilization >= depth_utilization or ifm_depth <= 8:
+ # Part-kernel first is always better for ifm depths <= 8
+ tens.block_traversal = TensorBlockTraversal.PartKernelFirst
+ else:
+ tens.block_traversal = TensorBlockTraversal.DepthFirst
+
+ # Slice weight stream up depth-ways into bricks and compress
+ full_ofm_depth = quant_buf.shape[-1]
+ for idx in range(0, full_ofm_depth, ofm_depth_step):
+ # Get the weights necessary for this brick
+ count = min(full_ofm_depth - idx, ofm_depth_step)
+ brick_weights = weights[:, :, :, idx : idx + count]
+
+ # Encode all weights into one chunk
+ raw_stream = generate_brick(arch, brick_weights, ofm_block, tens.block_traversal, ifm_bitdepth)
+ encoded = encode(raw_stream)
+ encoded_streams.append(encoded)
+
+ # Remember maximum encoded length for DoubleBuffering
+ if max_single_buffer_len < len(encoded):
+ max_single_buffer_len = len(encoded)
+
+ # Remember where we put it for linear addressing
+ compressed_offsets.append(offset)
+ offset += len(encoded)
+ assert offset % 16 == 0
+
+ # Compression scale tracking
+ compression_scales.append(len(encoded) / len(raw_stream))
+
+ # Also track complete length in the offsets array
+ compressed_offsets.append(offset)
+
+ if tens.sub_purpose == TensorSubPurpose.DoubleBuffer and len(encoded_streams) > 2:
+ offset = 2 * max_single_buffer_len
+ assert offset % 16 == 0
+
+ tens.storage_shape = [1, 1, 1, offset]
+ tens.weight_compression_scales = compression_scales
+ tens.weight_compression_config = WeightCompressionConfig(npu_block_type, ofm_block, ofm_depth_step)
+ tens.weight_compressed_offsets = compressed_offsets
+ tens.compression_scale_for_worst_weight_stream = np.amax(compression_scales)
+ tens.storage_compression_scale = tens.bandwidth_compression_scale = np.average(compression_scales)
+ tens.compressed_values = encoded_streams
+ tens.brick_size = (weights_shape[0], weights_shape[1], weights_shape[2], min(tens.shape[-1], ofm_depth_step))
+
+
+def calc_scales_and_pack_biases(tens, arch, oc_quantum, rescale_for_faf=False):
+ assert tens.purpose == TensorPurpose.FeatureMap
+ assert tens.format == TensorFormat.NHWC
+ # the connected operator should expect a bias input unless it is a FullyConnected
+ assert "Bias" in tens.consumer_list[0].type or tens.consumer_list[0].type.startswith("FullyConnected")
+ # the input bias tensor is the same as that connected to the operator
+ assert tens is tens.consumer_list[0].inputs[2]
+ # the operator should only have a single output
+ assert len(tens.consumer_list[0].outputs) == 1
+
+ def pack_bias_and_scale(bias, scale, shift):
+ bias = np.int64(bias)
+ assert -(1 << (40 - 1)) <= bias < (1 << (40 - 1)) # signed 40-bit range
+ assert 0 <= scale < (1 << 32) # unsigned 32-bit range
+ assert 0 <= shift < (1 << 6) # unsigned 6-bit range
+
+ # pack the 80 bit value = [0(2-bits),shift(6-bits),scale(32-bits),bias(40-bits)]
+ data = bytearray(10)
+ data[0] = (bias >> (0 * 8)) & 0xFF
+ data[1] = (bias >> (1 * 8)) & 0xFF
+ data[2] = (bias >> (2 * 8)) & 0xFF
+ data[3] = (bias >> (3 * 8)) & 0xFF
+ data[4] = (bias >> (4 * 8)) & 0xFF
+ data[5] = (scale >> (0 * 8)) & 0xFF
+ data[6] = (scale >> (1 * 8)) & 0xFF
+ data[7] = (scale >> (2 * 8)) & 0xFF
+ data[8] = (scale >> (3 * 8)) & 0xFF
+ data[9] = shift & 0x3F
+ return data
+
+ biases = tens.quant_values
+
+ first_consumer_op = tens.consumer_list[0]
+ ifm_dtype = first_consumer_op.inputs[0].dtype
+ ifm_scale = first_consumer_op.inputs[0].quantization.scale_f32
+ ofm_scale = first_consumer_op.outputs[0].quantization.scale_f32
+ weight_scales = first_consumer_op.inputs[1].quantization.scale_f32
+
+ # biases can have multiple consumers for rnn cells. if so, then check that they are all the same
+ for op in tens.consumer_list[1:]:
+ assert ifm_scale == op.inputs[0].quantization.scale_f32
+ assert ofm_scale == op.outputs[0].quantization.scale_f32
+ assert weight_scales == op.inputs[1].quantization.scale_f32
+
+ if not hasattr(weight_scales, "__iter__"):
+ # If weight_scales is not already an iterable make it into a list
+ weight_scales = [weight_scales]
+
+ # Convert scales to np.double (from np.float32) to conform to TensorFlow Lite which
+ # uses double during scaling calculations
+ # TensorFlow Lite casts the scales slightly differently for uint8 and int8
+ if not rescale_for_faf:
+ if ifm_dtype == DataType.uint8:
+ scales = [np.double(ifm_scale * weight_scale) / np.double(ofm_scale) for weight_scale in weight_scales]
+ elif ifm_dtype == DataType.int8:
+ scales = [
+ (np.double(ifm_scale) * np.double(weight_scale)) / np.double(ofm_scale)
+ for weight_scale in weight_scales
+ ]
+ else:
+ assert False, str(ifm_dtype) + " not implemented"
+ else:
+ if ifm_dtype == DataType.uint8:
+ scales = [np.double(ifm_scale * weight_scale * 0x3000) for weight_scale in weight_scales]
+ elif ifm_dtype == DataType.int8:
+ scales = [(np.double(ifm_scale * 0x3000) * np.double(weight_scale)) for weight_scale in weight_scales]
+ else:
+ assert False, str(ifm_dtype) + " not implemented"
+
+ # quantise all of the weight scales into (scale_factor, shift)
+ quantised_scales = [quantise_scale(scale) for scale in scales]
+
+ for _, shift in quantised_scales:
+ assert shift >= 16
+
+ # pack the biases and scales
+ tens.compressed_values = []
+ if len(quantised_scales) == 1:
+ # If only 1 quantised scale is used, repeat that value for the length of the biases
+ quantised_scales = [quantised_scales[0]] * len(biases)
+
+ assert len(quantised_scales) == len(biases)
+ for i, bias in enumerate(biases):
+ tens.compressed_values.append(pack_bias_and_scale(bias, *quantised_scales[i]))
+
+ tens.element_size_bytes = 10
+
+ # Figure out if we need padded storage (extra whole elements)
+ padding = (len(tens.compressed_values) * tens.element_size_bytes) % 16
+ if padding != 0:
+ padding = 16 - padding
+
+ # This adds enough padding to allow over-reads
+ while padding > 0:
+ tens.compressed_values.append(pack_bias_and_scale(0, 0, 0))
+ padding = padding - tens.element_size_bytes
+
+ tens.storage_shape = [len(tens.compressed_values)]
+
+
+def update_pass_weight_and_scale_tensors(nng, arch):
+ def find_npu_usage_of_tensor(tens):
+ # TODO: This function is identical to the one in mark_tensors.py. A common version should be used.
+ for op in tens.consumers():
+ if op.type == "DMA":
+ return find_npu_usage_of_tensor(op.outputs[0])
+ if "npu_block_type" in op.attrs:
+ return op.attrs["npu_block_type"]
+ return NpuBlockType.Default
+
+ for sg in nng.subgraphs:
+ for ps in sg.passes:
+ if ps.weight_tensor != None:
+ npu_usage_of_tensor = find_npu_usage_of_tensor(ps.weight_tensor)
+ if npu_usage_of_tensor == NpuBlockType.ConvolutionDepthWise:
+ ps.weight_tensor.quant_values = np.transpose(ps.weight_tensor.quant_values, (0, 1, 3, 2))
+ ps.weight_tensor.shape = ps.weight_tensor.storage_shape = ps.weight_tensor.bandwidth_shape = list(
+ ps.weight_tensor.quant_values.shape
+ )
+ ps.weight_tensor.weight_transpose_depthwise = True
+
+ needs_dma = len(ps.weight_tensor.ops) == 1 and ps.weight_tensor.ops[0].type == "DMA"
+ if ps.cascade.strategy == SchedulingStrategy.WeightStream and needs_dma:
+ ofm_depth_step = ps.block_config[-1]
+ else:
+ ofm_depth_step = ps.weight_tensor.shape[-1]
+
+ compress_weights(
+ ps.weight_tensor,
+ arch,
+ npu_usage_of_tensor,
+ Block(ps.block_config[-3], ps.block_config[-4], ps.block_config[-1]),
+ ofm_depth_step,
+ )
+ # Update source tensor
+ if len(ps.weight_tensor.ops) == 1 and ps.weight_tensor.ops[0].type == "DMA":
+ src_tens = ps.weight_tensor.ops[0].inputs[0]
+ src_tens.shape = ps.weight_tensor.shape
+ src_tens.weight_transpose_depthwise = ps.weight_tensor.weight_transpose_depthwise
+ src_tens.quant_values = ps.weight_tensor.quant_values
+ src_tens.compressed_values = ps.weight_tensor.compressed_values
+ src_tens.storage_shape = [1, 1, 1, ps.weight_tensor.weight_compressed_offsets[-1]]
+ src_tens.brick_size = ps.weight_tensor.brick_size
+ src_tens.weight_compression_scales = ps.weight_tensor.weight_compression_scales
+ src_tens.weight_compressed_offsets = ps.weight_tensor.weight_compressed_offsets
+
+ if ps.scale_tensor != None:
+ rescale_for_faf = False
+ activation_ops = set(("Sigmoid", "Tanh"))
+ if (ps.ops[-1].type in activation_ops) and (ps.npu_block_type != NpuBlockType.ElementWise):
+ rescale_for_faf = True
+ calc_scales_and_pack_biases(ps.scale_tensor, arch, ps.block_config[3], rescale_for_faf)
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..1a1ae84
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,63 @@
+# Copyright (C) 2020 Arm Limited or its affiliates. All rights reserved.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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
+#
+# 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.
+
+
+# Description:
+# Packaging for the Vela compiler
+
+from os import path
+from setuptools import setup, find_namespace_packages, Extension
+
+# Read the contents of README.md file
+this_directory = path.abspath(path.dirname(__file__))
+with open(path.join(this_directory, "README.md"), encoding="utf-8") as f:
+ long_description = f.read()
+
+mlw_module = Extension(
+ "ethosu.mlw_codec",
+ ["ethosu/mlw_codec/mlw_encode.c", "ethosu/mlw_codec/mlw_decode.c", "ethosu/mlw_codec/mlw_codecmodule.c"],
+)
+
+setup(
+ name="ethos-u-vela",
+ use_scm_version=True,
+ description="Optimise TensorFlow Lite models for Ethos-U55 NPU.",
+ long_description=long_description,
+ long_description_content_type="text/markdown",
+ url="https://git.mlplatform.org/ml/ethos-u/ethos-u-vela.git/",
+ author="Arm Ltd.",
+ license="Apache License 2.0",
+ classifiers=[
+ "Development Status :: 4 - Beta",
+ "Intended Audience :: Developers",
+ "License :: OSI Approved :: Apache Software License",
+ "Operating System :: POSIX :: Linux",
+ "Programming Language :: C",
+ "Programming Language :: Python :: 3",
+ "Programming Language :: Python :: 3.6",
+ "Programming Language :: Python :: 3.7",
+ "Programming Language :: Python :: 3.8",
+ "Topic :: Scientific/Engineering :: Artificial Intelligence",
+ "Topic :: Software Development :: Compilers",
+ ],
+ keywords=["ethos-u", "vela compiler", "tflite", "npu"],
+ packages=find_namespace_packages(include=["ethosu.*"]),
+ python_requires="~=3.6", # We support only 3.6+
+ install_requires=["flatbuffers==1.11.0", "numpy>=1.16.6"],
+ entry_points={"console_scripts": ["vela = ethosu.vela.vela:main"]},
+ ext_modules=[mlw_module],
+ setup_requires=["setuptools_scm"],
+)