xmos-ai-tools 1.3.2.dev80__py3-none-macosx_10_15_universal2.whl

xmos_ai_tools/runtime/include/tensorflow/lite/schema/schema_utils.h

@@ -0,0 +1,33 @@
+/* Copyright 2020 The TensorFlow Authors. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+#ifndef TENSORFLOW_LITE_SCHEMA_SCHEMA_UTILS_H_
+#define TENSORFLOW_LITE_SCHEMA_SCHEMA_UTILS_H_
+
+#include "flatbuffers/flatbuffers.h"
+#include "tensorflow/lite/schema/schema_generated.h"
+
+namespace tflite_micro {
+
+// The following methods are introduced to resolve op builtin code shortage
+// problem. The new builtin operator will be assigned to the extended builtin
+// code field in the flatbuffer schema. Those methods helps to hide builtin code
+// details.
+BuiltinOperator GetBuiltinCode(const OperatorCode *op_code);
+
+BuiltinOperator GetBuiltinCode(const OperatorCodeT *op_code);
+
+}  // namespace tflite_micro
+
+#endif  // TENSORFLOW_LITE_SCHEMA_SCHEMA_UTILS_H_

xmos_ai_tools/runtime/include/tile_ram_server.h

@@ -0,0 +1,38 @@
+#ifndef _tile_ram_server_h_
+#define _tile_ram_server_h_
+
+#include "flash_server.h"
+
+/**
+ * Function that runs a flash-server. A flash server is a thread that serves one
+ * or more clients. There is one flash server per flash-device, and the server
+ * can serve clients on one or more tiles.
+ *
+ * The flash server takes the following commands:
+ *   - Read a whole model from the flash.
+ *   - Read some parameters from the flash
+ *   - (future extension) Read code for an operator from flash
+ *
+ * This function does, at present, never return. It could be made to return if
+ * all clients close their connection
+ *
+ * \param c_tile_ram_clients Array of channels; one per client.
+ *                          Each client is served in turn
+ *                          NOTE MUST BE 1 FOR NOW
+ * \param headers           Space to store a header for each client
+ *                          The header for the client describes the local
+ *                          "filesystem" for that client
+ * \param n_tile_ram_clients Number of clients. The
+ *                          arrays in the first and second parameters should have this many entries
+ * \param data              Tile ram data
+ * \param n_tile_ram_flash  Number of bytes in array
+ */
+#ifdef __XC__
+void tile_ram_server(chanend c_tile_ram_clients[], flash_t headers[],
+                     int n_tile_ram_clients, const int8_t data[]);
+#else
+void tile_ram_server(chanend_t *c_tile_ram_clients, flash_t *headers,
+                     int n_tile_ram_clients, const int8_t *data);
+#endif
+
+#endif

xmos_ai_tools/xformer/__init__.py

@@ -0,0 +1,60 @@
+import subprocess
+import typing
+from pathlib import Path
+from typing import Union, List, Optional
+from .flash import generate_flash
+import re
+
+__compilation_output = ""
+__arena_size = 0
+
+
+def convert(
+    filename: Union[str, Path],
+    outfile: Union[str, Path],
+    params: Optional[typing.Dict[str, Optional[str]]],
+) -> int:
+    args: List[str] = ["xcore-opt", "-o", str(outfile)]
+
+    if params is not None:
+        for key, val in params.items():
+            if len(key) > 1:
+                flag: str = "--" + str(key)
+            else:
+                flag = "-" + str(key)
+            if str(val) == "" or val is None:
+                args.append(flag)
+            else:
+                args.append(f"{flag}={val}")
+
+    args.append(str(filename))
+
+    process_call: subprocess.CompletedProcess = subprocess.run(
+        [arg for arg in args],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        check=True,
+    )
+
+    global __compilation_output, __arena_size
+    __compilation_output = process_call.stdout.decode("utf-8")
+    size_str = re.sub("((.|\n|\r)*)Tensor arena size :", "", __compilation_output)
+    size_str = re.sub("(\n|\r)((.|\n|\r)*)", "", size_str)
+    __arena_size = int(size_str.strip())
+
+    return process_call.returncode
+
+
+def tensor_arena_size() -> int:
+    return __arena_size
+
+
+def print_optimization_report():
+    print(__compilation_output)
+
+
+def print_help(show_hidden: Optional[bool] = False) -> int:
+    if show_hidden:
+        return subprocess.run(["xcore-opt", "--help-list-hidden"]).returncode
+
+    return subprocess.run(["xcore-opt", "--help-list"]).returncode

xmos_ai_tools/xformer/flash.py

@@ -0,0 +1,190 @@
+BYTES_FOR_MAGIC_PATTERN = 32
+BYTES_FOR_VERSION = 4
+BYTES_PER_ENGINE_HEADER = 16
+VERSION_MAJOR = 1
+VERSION_MINOR = 2
+
+
+class FlashBuilder:
+    class Header:
+        """
+        Class that stores a header for a flash file system
+        The header comprises the addresses of the model, parameters, and operators
+        relative to the start address
+        """
+
+        def __init__(self, model_bytes, params_bytes, ops_bytes, xip_bytes, start):
+            self.model_start = start
+            self.parameters_start = self.model_start + model_bytes + 4  # len
+            self.operators_start = self.parameters_start + params_bytes  # no len
+            self.xip_start = self.operators_start + ops_bytes  # no len
+            new_start = self.xip_start + xip_bytes  # no len
+            self.length = new_start - start
+
+    def __init__(self, engines=1):
+        self.engines = engines
+        self.models = [bytes([])] * engines
+        self.params = [bytes([])] * engines
+        self.ops = [bytes([])] * engines
+        self.xips = [bytes([])] * engines
+
+    @staticmethod
+    def read_whole_binary_file(filename):
+        """
+        Reads a whole binary file in and returns bytes(). If the file to be read is called '-'
+        then an empty bytes is returned.
+        """
+        if filename == "-":
+            return bytes([])
+        try:
+            with open(filename, "rb") as input_fd:
+                contents = input_fd.read()
+            return contents
+        except:
+            print('File "%s" is not a readable file' % (filename))
+            return None
+
+    @staticmethod
+    def create_params_image(params=None, filename=None):
+        if params is None:
+            params = FlashBuilder.read_whole_binary_file(filename)
+        return params
+
+    @staticmethod
+    def create_model_image(model=None, filename=None):
+        if model is None:
+            model = FlashBuilder.read_whole_binary_file(filename)
+        return model
+
+    @staticmethod
+    def create_params_file(params_filename, params=None, input_filename=None):
+        image = FlashBuilder.create_params_image(params=params, filename=input_filename)
+        with open(params_filename, "wb") as output_fd:
+            output_fd.write(image)
+
+    @staticmethod
+    def tobytes(integr):
+        """Converts an int to a LSB first quad of bytes"""
+        data = []
+        for i in range(4):
+            data.append((integr >> (8 * i)) & 0xFF)
+        return bytes(data)
+
+    @staticmethod
+    def swap_nibbles(x):
+        return (x & 0x0F) << 4 | (x & 0xF0) >> 4
+
+    def add_params(self, engine, params=None, filename=None):
+        image = FlashBuilder.create_params_image(params, filename)
+        self.params[engine] = image
+
+    def add_model(self, engine, model=None, filename=None):
+        image = FlashBuilder.create_model_image(model, filename)
+        self.models[engine] = image
+
+    def flash_image(self):
+        """
+        Builds a flash image out of a collection of models and parameter blobs.
+        This function returns a bytes comprising the header, models, parameters, etc.
+        The whole thing should be written as is to flash
+        """
+        headers = [None] * self.engines
+        start = (
+            BYTES_FOR_MAGIC_PATTERN
+            + BYTES_FOR_VERSION
+            + BYTES_PER_ENGINE_HEADER * self.engines
+        )
+        for i in range(self.engines):
+            headers[i] = FlashBuilder.Header(
+                len(self.models[i]),
+                len(self.params[i]),
+                len(self.ops[i]),
+                len(self.xips[i]),
+                start,
+            )
+            start += headers[i].length
+
+        # We add the magic fast flash pattern of 32 bytes at the very beginning
+        # After that comes the version
+        output = bytes(
+            [
+                0xFF,
+                0x00,
+                0x0F,
+                0x0F,
+                0x0F,
+                0x0F,
+                0x0F,
+                0x0F,
+                0xFF,
+                0x00,
+                0xFF,
+                0x00,
+                0xFF,
+                0x00,
+                0xFF,
+                0x00,
+                0x31,
+                0xF7,
+                0xCE,
+                0x08,
+                0x31,
+                0xF7,
+                0xCE,
+                0x08,
+                0x9C,
+                0x63,
+                0x9C,
+                0x63,
+                0x9C,
+                0x63,
+                0x9C,
+                0x63,
+            ]
+        )
+
+        output += bytes(
+            [VERSION_MAJOR, VERSION_MINOR, 0xFF ^ VERSION_MAJOR, 0xFF ^ VERSION_MINOR]
+        )
+
+        for i in range(self.engines):
+            output += FlashBuilder.tobytes(
+                headers[i].model_start
+            )  # encode start of model
+            output += FlashBuilder.tobytes(
+                headers[i].parameters_start
+            )  # encode start of params
+            output += FlashBuilder.tobytes(
+                headers[i].operators_start
+            )  # encode start of ops
+            output += FlashBuilder.tobytes(headers[i].xip_start)  # encode start of xip
+
+        for i in range(self.engines):
+            output += FlashBuilder.tobytes(len(self.models[i]))  # encode len of model
+            output += self.models[i]  # add model image
+            output += self.params[i]  # add params image
+            output += self.ops[i]  # add operators image
+            output += self.xips[i]  # add exec in place image
+        return output
+
+    def flash_file(self, filename):
+        """
+        Builds a file for the host system that comprises a single parameter blob.
+        """
+        output = self.flash_image()
+        # swap nibbles around
+        swapped_output = bytes([FlashBuilder.swap_nibbles(byte) for byte in output])
+        with open(filename, "wb") as output_fd:
+            output_fd.write(swapped_output)
+
+
+def generate_flash(*, output_file, model_files, param_files):
+    assert len(model_files) == len(
+        param_files
+    ), "The number of provided model files must match the number of param files!"
+    num_of_engines = len(model_files)
+    fb = FlashBuilder(engines=num_of_engines)
+    for i in range(num_of_engines):
+        fb.add_model(i, filename=model_files[i])
+        fb.add_params(i, filename=param_files[i])
+    fb.flash_file(output_file)

xmos_ai_tools/xinterpreters/__init__.py

@@ -0,0 +1 @@
+from .host_interpreter import TFLMHostInterpreter

xmos_ai_tools/xinterpreters/exceptions.py

@@ -0,0 +1,38 @@
+# Copyright 2021 XMOS LIMITED. This Software is subject to the terms of the
+# XMOS Public License: Version 1
+
+
+class InterpreterError(Exception):
+    pass
+
+
+class AllocateTensorsError(InterpreterError):
+    pass
+
+
+class InvokeError(InterpreterError):
+    pass
+
+
+class SetTensorError(InterpreterError):
+    pass
+
+
+class GetTensorError(InterpreterError):
+    pass
+
+
+class ModelSizeError(InterpreterError):
+    pass
+
+
+class ArenaSizeError(InterpreterError):
+    pass
+
+
+class DeviceTimeoutError(InterpreterError):
+    pass
+
+
+class GetProfilerTimesError(InterpreterError):
+    pass