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

xmos_ai_tools/__init__.py

@@ -0,0 +1,7 @@
+from importlib.metadata import version, PackageNotFoundError
+
+try:
+    __version__ = version(__name__)
+except PackageNotFoundError:
+    # package is not installed
+    pass

xmos_ai_tools/io_server/__init__.py

@@ -0,0 +1,151 @@
+# Copyright (c) 2020, XMOS Ltd, All rights reserved
+
+import usb
+from typing import Tuple
+import numpy as np
+
+IOSERVER_INVOKE = int(0x01)
+IOSERVER_TENSOR_SEND_OUTPUT = int(0x02)
+IOSERVER_TENSOR_RECV_INPUT = int(0x03)
+IOSERVER_RESET = int(0x07)
+IOSERVER_EXIT = int(0x08)
+
+
+class IOServerError(Exception):
+    """Error from device"""
+
+    pass
+
+
+class IOError(IOServerError):
+    """IO Error from device"""
+
+    pass
+
+
+def handle_usb_error(func):
+    def wrapper(*args, **kwargs):
+        try:
+            return func(*args, **kwargs)
+        except usb.core.USBError as e:
+            print(f"USB error {e}")
+            if e.backend_error_code == usb.backend.libusb1.LIBUSB_ERROR_PIPE:
+                raise IOError()
+            else:
+                raise IOServerError(f"Wow...") from e
+
+    return wrapper
+
+
+class IOServer:
+    def __init__(self, output_details: Tuple[dict, ...] = None, timeout=5000):
+        self.__out_ep = None
+        self.__in_ep = None
+        self._dev = None
+        self._output_details = output_details
+        self._timeout = timeout
+        self._max_block_size = 512  # TODO read from (usb) device?
+        super().__init__()
+
+    def bytes_to_arr(self, data_bytes, tensor_num):
+        if self._output_details:
+            d = self._output_details[tensor_num]
+            s = d["shape"]
+            return np.frombuffer(data_bytes, dtype=d["dtype"])[: np.prod(s)].reshape(s)
+        return np.frombuffer(data_bytes, dtype=np.uint8)
+
+    def write_input_tensor(self, raw_img, tensor_num=0, model_num=0):
+        self._download_data(
+            IOSERVER_TENSOR_RECV_INPUT,
+            raw_img,
+            tensor_num=tensor_num,
+            model_num=model_num,
+        )
+
+    def read_output_tensor(self, tensor_num=0, model_num=0):
+        # Retrieve result from device
+        data_read = self._upload_data(
+            IOSERVER_TENSOR_SEND_OUTPUT,
+            model_num=model_num,
+            tensor_num=tensor_num,
+        )
+        assert type(data_read) is bytearray
+        return self.bytes_to_arr(data_read, tensor_num)
+
+    def close(self):
+        if self._dev is not None:
+            self._dev.write(self._out_ep, bytes([IOSERVER_EXIT, 0, 0]), 1000)
+            usb.util.dispose_resources(self._dev)
+            self._dev = None
+
+    @handle_usb_error
+    def _download_data(self, cmd, data_bytes, tensor_num=0, model_num=0):
+        # TODO rm this extra CMD packet
+        self._out_ep.write(bytes([cmd, model_num, tensor_num]))
+        self._out_ep.write(data_bytes, 1000)
+        if (len(data_bytes) % self._max_block_size) == 0:
+            self._out_ep.write(bytearray(), 1000)
+
+    @handle_usb_error
+    def _upload_data(self, cmd, tensor_num=0, model_num=0):
+        read_data = bytearray()
+        self._out_ep.write(bytes([cmd, model_num, tensor_num]), self._timeout)
+        buff = usb.util.create_buffer(self._max_block_size)
+        read_len = self._dev.read(self._in_ep, buff, 10000)
+        read_data.extend(buff[:read_len])
+        while read_len == self._max_block_size:
+            read_len = self._dev.read(self._in_ep, buff, 10000)
+            read_data.extend(buff[:read_len])
+
+        return read_data
+
+    def _clear_error(self):
+        self._dev.clear_halt(self._out_ep)
+        self._dev.clear_halt(self._in_ep)
+
+    def connect(self):
+        self._dev = None
+        while self._dev is None:
+            # TODO - more checks that we have the right device..
+            self._dev = usb.core.find(idVendor=0x20B1, product="xAISRV")
+
+        # set the active configuration. With no arguments, the first
+        # configuration will be the active one
+        self._dev.set_configuration()
+
+        # get an endpoint instance
+        cfg = self._dev.get_active_configuration()
+        intf = cfg[(0, 0)]
+        self._out_ep = usb.util.find_descriptor(
+            intf,
+            # match the first OUT endpoint
+            custom_match=lambda e: usb.util.endpoint_direction(e.bEndpointAddress)
+            == usb.util.ENDPOINT_OUT,
+        )
+
+        self._in_ep = usb.util.find_descriptor(
+            intf,
+            # match the first IN endpoint
+            custom_match=lambda e: usb.util.endpoint_direction(e.bEndpointAddress)
+            == usb.util.ENDPOINT_IN,
+        )
+
+        assert self._out_ep is not None
+        assert self._in_ep is not None
+
+        print("Connected to XCORE_IO_SERVER via USB")
+
+    # TODO move to super()
+    def start_inference(self):
+        # Send cmd
+        self._out_ep.write(bytes([IOSERVER_INVOKE, 0, 0]), 1000)
+
+        # Send out a 0 length packet
+        self._out_ep.write(bytes([]), 1000)
+
+    def reset(self):
+        # Send cmd
+        self._out_ep.write(bytes([IOSERVER_RESET, 0, 0]), 1000)
+
+        # Send out a 0 length packet
+        self._out_ep.write(bytes([]), 1000)

xmos_ai_tools/runtime/buildfiles/aitoolslib.cmake

@@ -0,0 +1,13 @@
+set(XMOS_AITOOLSLIB_DEFINITIONS
+        "TF_LITE_STATIC_MEMORY"
+		"TF_LITE_STRIP_ERROR_STRINGS"
+		"XCORE"
+		"NO_INTERPRETER"
+    )
+
+if("${APP_BUILD_ARCH}" STREQUAL xs3a OR ${CMAKE_SYSTEM_PROCESSOR} STREQUAL XCORE_XS3A)
+	set(XMOS_AITOOLSLIB_LIBRARIES "${CMAKE_CURRENT_LIST_DIR}/../lib/libxtflitemicro.a")
+else()
+	set(XMOS_AITOOLSLIB_LIBRARIES "${CMAKE_CURRENT_LIST_DIR}/../lib/libhost_xtflitemicro.a")
+endif()
+set(XMOS_AITOOLSLIB_INCLUDES "${CMAKE_CURRENT_LIST_DIR}/../include")

xmos_ai_tools/runtime/buildfiles/aitoolslib.make

@@ -0,0 +1,8 @@
+XMOS_AITOOLSLIB_DEFINITIONS = \
+-DTF_LITE_STATIC_MEMORY \
+-DTF_LITE_STRIP_ERROR_STRINGS \
+-DXCORE \
+-DNO_INTERPRETER
+
+XMOS_AITOOLSLIB_LIBRARIES = $(XMOS_AITOOLSLIB_PATH)/lib/libxtflitemicro.a
+XMOS_AITOOLSLIB_INCLUDES = -I$(XMOS_AITOOLSLIB_PATH)/include

xmos_ai_tools/runtime/include/flash_server.h

@@ -0,0 +1,73 @@
+#ifndef _flash_server_h_
+#define _flash_server_h_
+
+#include <quadflash.h>
+
+/** Struct holding the "file system" meta information for each client
+ * The flash is partitioned and each client has a section in the flash
+ * that stores data relevant to that particular client. For example, models
+ * parameters, code, etc.
+ *
+ * This struct caches all information necessary for a client for fast access.
+ * The main program must allocate this structure, one per client, prior to
+ * calling the flash server.
+ *
+ * If there is more than one flash device connected to the device, there can be
+ * multiple flash servers.
+ */
+typedef struct flash {
+  int model_start;            ///< Start address for model.
+  int parameters_start;       ///< Start address of parameters.
+  int operators_start;        ///< Start address for operator-binaries.
+  int execute_in_place_start; ///< Start address for operator-binaries.
+} flash_t;
+
+/** Type representing the commands that the flash server accepts */
+typedef enum flash_command {
+  FLASH_READ_PARAMETERS =
+      0, ///< Read a set of parameters.   // TODO: share with lib_tflite_micro
+  FLASH_READ_PARAMETERS_ASYNC = 1, ///< Read parameters asynchronously.
+  FLASH_READ_SYNCHRONIZE      = 2, ///< Complete async read.
+  FLASH_READ_XIP =
+      3, ///< Read code to execute-in-place throught L2 cache - future extension
+  FLASH_SERVER_QUIT = 4,
+  FLASH_SERVER_INIT = 5, // Initialize flash server with fast flash pattern speed match setup
+  //FLASH_READ_PARAMETERS_COMPRESSED_FLOAT = 6, // Read a set of compressed parameters
+} flash_command_t;
+
+/**
+ * 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_flash_clients Array of channels; one per client.
+ *                        Each client is served in turn
+ * \param headers         Space to store a header for each client
+ *                        The header for the client describes the local
+ * "filesystem" for that client \param n_flash_clients Number of clients. The
+ * arrays in the first and second parameters should have this many entries
+ * \param qspi            Structure holding the quad-flash ports. This contains
+ * three Ports and a clock-block, the CS_N port, the CLK port, the DATA port and
+ * a clock block to be used for the flash. \param flash_spec      Array holding
+ * specificiations of flash devices, as per the libquadflash documentation
+ * \param n_flash_spec    Number of elements in the spec array.
+ */
+#ifdef __XC__
+void flash_server(chanend c_flash_clients[], flash_t headers[],
+                  int n_flash_clients, fl_QSPIPorts &qspi,
+                  fl_QuadDeviceSpec flash_spec[], int n_flash_spec);
+#else
+void flash_server(chanend_t *c_flash_clients, flash_t *headers,
+                  int n_flash_clients, fl_QSPIPorts *qspi,
+                  fl_QuadDeviceSpec *flash_spec, int n_flash_spec);
+#endif
+
+#endif

xmos_ai_tools/runtime/include/flatbuffers/allocator.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2021 Google Inc. 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 FLATBUFFERS_ALLOCATOR_H_
+#define FLATBUFFERS_ALLOCATOR_H_
+
+#include "flatbuffers/base.h"
+
+namespace flatbuffers {
+
+// Allocator interface. This is flatbuffers-specific and meant only for
+// `vector_downward` usage.
+class Allocator {
+ public:
+  virtual ~Allocator() {}
+
+  // Allocate `size` bytes of memory.
+  virtual uint8_t *allocate(size_t size) = 0;
+
+  // Deallocate `size` bytes of memory at `p` allocated by this allocator.
+  virtual void deallocate(uint8_t *p, size_t size) = 0;
+
+  // Reallocate `new_size` bytes of memory, replacing the old region of size
+  // `old_size` at `p`. In contrast to a normal realloc, this grows downwards,
+  // and is intended specifcally for `vector_downward` use.
+  // `in_use_back` and `in_use_front` indicate how much of `old_size` is
+  // actually in use at each end, and needs to be copied.
+  virtual uint8_t *reallocate_downward(uint8_t *old_p, size_t old_size,
+                                       size_t new_size, size_t in_use_back,
+                                       size_t in_use_front) {
+    FLATBUFFERS_ASSERT(new_size > old_size);  // vector_downward only grows
+    uint8_t *new_p = allocate(new_size);
+    memcpy_downward(old_p, old_size, new_p, new_size, in_use_back,
+                    in_use_front);
+    deallocate(old_p, old_size);
+    return new_p;
+  }
+
+ protected:
+  // Called by `reallocate_downward` to copy memory from `old_p` of `old_size`
+  // to `new_p` of `new_size`. Only memory of size `in_use_front` and
+  // `in_use_back` will be copied from the front and back of the old memory
+  // allocation.
+  void memcpy_downward(uint8_t *old_p, size_t old_size, uint8_t *new_p,
+                       size_t new_size, size_t in_use_back,
+                       size_t in_use_front) {
+    memcpy(new_p + new_size - in_use_back, old_p + old_size - in_use_back,
+           in_use_back);
+    memcpy(new_p, old_p, in_use_front);
+  }
+};
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_ALLOCATOR_H_

xmos_ai_tools/runtime/include/flatbuffers/array.h

@@ -0,0 +1,243 @@
+/*
+ * Copyright 2021 Google Inc. 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 FLATBUFFERS_ARRAY_H_
+#define FLATBUFFERS_ARRAY_H_
+
+#include "flatbuffers/base.h"
+#include "flatbuffers/stl_emulation.h"
+#include "flatbuffers/vector.h"
+
+namespace flatbuffers {
+
+// This is used as a helper type for accessing arrays.
+template<typename T, uint16_t length> class Array {
+  // Array<T> can carry only POD data types (scalars or structs).
+  typedef typename flatbuffers::bool_constant<flatbuffers::is_scalar<T>::value>
+      scalar_tag;
+  typedef
+      typename flatbuffers::conditional<scalar_tag::value, T, const T *>::type
+          IndirectHelperType;
+
+ public:
+  typedef uint16_t size_type;
+  typedef typename IndirectHelper<IndirectHelperType>::return_type return_type;
+  typedef VectorIterator<T, return_type> const_iterator;
+  typedef VectorReverseIterator<const_iterator> const_reverse_iterator;
+
+  // If T is a LE-scalar or a struct (!scalar_tag::value).
+  static FLATBUFFERS_CONSTEXPR bool is_span_observable =
+      (scalar_tag::value && (FLATBUFFERS_LITTLEENDIAN || sizeof(T) == 1)) ||
+      !scalar_tag::value;
+
+  FLATBUFFERS_CONSTEXPR uint16_t size() const { return length; }
+
+  return_type Get(uoffset_t i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return IndirectHelper<IndirectHelperType>::Read(Data(), i);
+  }
+
+  return_type operator[](uoffset_t i) const { return Get(i); }
+
+  // If this is a Vector of enums, T will be its storage type, not the enum
+  // type. This function makes it convenient to retrieve value with enum
+  // type E.
+  template<typename E> E GetEnum(uoffset_t i) const {
+    return static_cast<E>(Get(i));
+  }
+
+  const_iterator begin() const { return const_iterator(Data(), 0); }
+  const_iterator end() const { return const_iterator(Data(), size()); }
+
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  const_iterator cbegin() const { return begin(); }
+  const_iterator cend() const { return end(); }
+
+  const_reverse_iterator crbegin() const { return rbegin(); }
+  const_reverse_iterator crend() const { return rend(); }
+
+  // Get a mutable pointer to elements inside this array.
+  // This method used to mutate arrays of structs followed by a @p Mutate
+  // operation. For primitive types use @p Mutate directly.
+  // @warning Assignments and reads to/from the dereferenced pointer are not
+  //  automatically converted to the correct endianness.
+  typename flatbuffers::conditional<scalar_tag::value, void, T *>::type
+  GetMutablePointer(uoffset_t i) const {
+    FLATBUFFERS_ASSERT(i < size());
+    return const_cast<T *>(&data()[i]);
+  }
+
+  // Change elements if you have a non-const pointer to this object.
+  void Mutate(uoffset_t i, const T &val) { MutateImpl(scalar_tag(), i, val); }
+
+  // The raw data in little endian format. Use with care.
+  const uint8_t *Data() const { return data_; }
+
+  uint8_t *Data() { return data_; }
+
+  // Similarly, but typed, much like std::vector::data
+  const T *data() const { return reinterpret_cast<const T *>(Data()); }
+  T *data() { return reinterpret_cast<T *>(Data()); }
+
+  // Copy data from a span with endian conversion.
+  // If this Array and the span overlap, the behavior is undefined.
+  void CopyFromSpan(flatbuffers::span<const T, length> src) {
+    const auto p1 = reinterpret_cast<const uint8_t *>(src.data());
+    const auto p2 = Data();
+    FLATBUFFERS_ASSERT(!(p1 >= p2 && p1 < (p2 + length)) &&
+                       !(p2 >= p1 && p2 < (p1 + length)));
+    (void)p1;
+    (void)p2;
+    CopyFromSpanImpl(flatbuffers::bool_constant<is_span_observable>(), src);
+  }
+
+ protected:
+  void MutateImpl(flatbuffers::true_type, uoffset_t i, const T &val) {
+    FLATBUFFERS_ASSERT(i < size());
+    WriteScalar(data() + i, val);
+  }
+
+  void MutateImpl(flatbuffers::false_type, uoffset_t i, const T &val) {
+    *(GetMutablePointer(i)) = val;
+  }
+
+  void CopyFromSpanImpl(flatbuffers::true_type,
+                        flatbuffers::span<const T, length> src) {
+    // Use std::memcpy() instead of std::copy() to avoid performance degradation
+    // due to aliasing if T is char or unsigned char.
+    // The size is known at compile time, so memcpy would be inlined.
+    std::memcpy(data(), src.data(), length * sizeof(T));
+  }
+
+  // Copy data from flatbuffers::span with endian conversion.
+  void CopyFromSpanImpl(flatbuffers::false_type,
+                        flatbuffers::span<const T, length> src) {
+    for (size_type k = 0; k < length; k++) { Mutate(k, src[k]); }
+  }
+
+  // This class is only used to access pre-existing data. Don't ever
+  // try to construct these manually.
+  // 'constexpr' allows us to use 'size()' at compile time.
+  // @note Must not use 'FLATBUFFERS_CONSTEXPR' here, as const is not allowed on
+  //  a constructor.
+#if defined(__cpp_constexpr)
+  constexpr Array();
+#else
+  Array();
+#endif
+
+  uint8_t data_[length * sizeof(T)];
+
+ private:
+  // This class is a pointer. Copying will therefore create an invalid object.
+  // Private and unimplemented copy constructor.
+  Array(const Array &);
+  Array &operator=(const Array &);
+};
+
+// Specialization for Array[struct] with access using Offset<void> pointer.
+// This specialization used by idl_gen_text.cpp.
+template<typename T, uint16_t length> class Array<Offset<T>, length> {
+  static_assert(flatbuffers::is_same<T, void>::value, "unexpected type T");
+
+ public:
+  typedef const void *return_type;
+
+  const uint8_t *Data() const { return data_; }
+
+  // Make idl_gen_text.cpp::PrintContainer happy.
+  return_type operator[](uoffset_t) const {
+    FLATBUFFERS_ASSERT(false);
+    return nullptr;
+  }
+
+ private:
+  // This class is only used to access pre-existing data.
+  Array();
+  Array(const Array &);
+  Array &operator=(const Array &);
+
+  uint8_t data_[1];
+};
+
+template<class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<U, N> make_span(Array<U, N> &arr)
+    FLATBUFFERS_NOEXCEPT {
+  static_assert(
+      Array<U, N>::is_span_observable,
+      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
+  return span<U, N>(arr.data(), N);
+}
+
+template<class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const U, N> make_span(
+    const Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+  static_assert(
+      Array<U, N>::is_span_observable,
+      "wrong type U, only plain struct, LE-scalar, or byte types are allowed");
+  return span<const U, N>(arr.data(), N);
+}
+
+template<class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<uint8_t, sizeof(U) * N>
+make_bytes_span(Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+  static_assert(Array<U, N>::is_span_observable,
+                "internal error, Array<T> might hold only scalars or structs");
+  return span<uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
+}
+
+template<class U, uint16_t N>
+FLATBUFFERS_CONSTEXPR_CPP11 flatbuffers::span<const uint8_t, sizeof(U) * N>
+make_bytes_span(const Array<U, N> &arr) FLATBUFFERS_NOEXCEPT {
+  static_assert(Array<U, N>::is_span_observable,
+                "internal error, Array<T> might hold only scalars or structs");
+  return span<const uint8_t, sizeof(U) * N>(arr.Data(), sizeof(U) * N);
+}
+
+// Cast a raw T[length] to a raw flatbuffers::Array<T, length>
+// without endian conversion. Use with care.
+// TODO: move these Cast-methods to `internal` namespace.
+template<typename T, uint16_t length>
+Array<T, length> &CastToArray(T (&arr)[length]) {
+  return *reinterpret_cast<Array<T, length> *>(arr);
+}
+
+template<typename T, uint16_t length>
+const Array<T, length> &CastToArray(const T (&arr)[length]) {
+  return *reinterpret_cast<const Array<T, length> *>(arr);
+}
+
+template<typename E, typename T, uint16_t length>
+Array<E, length> &CastToArrayOfEnum(T (&arr)[length]) {
+  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
+  return *reinterpret_cast<Array<E, length> *>(arr);
+}
+
+template<typename E, typename T, uint16_t length>
+const Array<E, length> &CastToArrayOfEnum(const T (&arr)[length]) {
+  static_assert(sizeof(E) == sizeof(T), "invalid enum type E");
+  return *reinterpret_cast<const Array<E, length> *>(arr);
+}
+
+}  // namespace flatbuffers
+
+#endif  // FLATBUFFERS_ARRAY_H_