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

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/conv2d_float.h

@@ -0,0 +1,155 @@
+#ifndef _conv2d_float_h_
+#define _conv2d_float_h_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** Function that calculates a fully connected.
+ *
+ * @param  outputs              pointer to the output data, the output data will
+ * be stored as an array [out_features]
+ * @param  inputs               pointer to the input data, the input data must
+ * be stored as an array [input_features]
+ * @param  kernels              pointer to the kernels, the kernels
+ *                              must be stored as an array
+ *                              [out_features][input_features]
+ * @param  out_features         dimension 1 of the output array
+ * @param  input_features       dimension 1 of the input array
+ * @returns                     number of MACCs
+ */
+extern int xc_fc_float_ref(float *outputs, float *inputs, float *kernels,
+                           int out_features, int input_features);
+
+/** Optimized function that calculates a fully connected.
+ *
+ * @param  outputs              pointer to the output data, the output data will
+ * be stored as an array [out_features]
+ * @param  inputs               pointer to the input data, the input data must
+ * be stored as an array [input_features]
+ * @param  kernels              pointer to the kernels, the kernels
+ *                              must be stored as an array
+ *                              [out_features][input_features]
+ * @param  out_features         dimension 1 of the output array
+ * @param  input_features       dimension 1 of the input array
+ * @param  out_f_start          output features to start at
+ * @param  out_f_end            output features to end at plus one
+ * @returns                     number of MACCs
+ */
+extern int xc_fc_float_opt(float *outputs, float *inputs, float *kernels,
+                           int out_features, int input_features, int out_f_start,
+                           int out_f_end);
+
+/** Function that calculates a convolution with a 5x2 filter with stride 2
+ * over dimension 2 of a tensor over a tensor.
+ *
+ * @param  outputs     pointer to the output data, the output data will be
+ *                     stored as an array [out_w][out_h][out_depth]
+ * @param  inputs      pointer to the input data, the input data must be
+ *                     stored as an array [input_w][input_h][input_depth]
+ * @param  kernels     pointer to the kernels, the kernels
+ *                     must be stored as an array
+ *                     [out_depth][5][2][depth]
+ * @param  bias        pointer to the biases, the bias must be stored as an
+ * array [out_depth]
+ * @param  out_w       dimension 2 of the output array
+ * @param  out_h       dimension 1 of the output array
+ * @param  out_depth   dimension 3 of the output array
+ * @param  input_w     dimension 2 of the input array
+ * @param  input_h     dimension 1 of the input array
+ * @param  input_depth dimension 3 of the input array
+ * @returns            number of MACCs
+ */
+extern int xc_conv2d_float_kw5xh2_stride_w3_ref(float *outputs, float *inputs,
+                                                float *kernels, float *biases,
+                                                int out_w, int out_h,
+                                                int out_depth, int input_w,
+                                                int input_h, int input_depth);
+
+/** Optimised function that calculates a convolution with a 5x2 filter with
+ * stride 2 over dimension 2 of a tensor. For parallel usage, supply
+ * multiple invocations with different values of out_depth_start and
+ * out_depth_end so that the whole output depth is covered between all of
+ * them.
+ *
+ * @param  outputs     pointer to the output data, the output data will be
+ *                     stored as an array [out_w][out_h][out_depth]
+ * @param  inputs      pointer to the input data, the input data must be
+ *                     stored as an array [input_w][input_h][input_depth]
+ * @param  kernels     pointer to the kernels, the kernels
+ *                     must be stored as an array
+ *                     [out_depth][5][2][depth]
+ * @param  bias        pointer to the biases, the bias must be stored as an
+ * array [out_depth]
+ * @param  out_w       dimension 2 of the output array
+ * @param  out_h       dimension 1 of the output array
+ * @param  out_depth   dimension 3 of the output array
+ * @param  input_w     dimension 2 of the input array
+ * @param  input_h     dimension 1 of the input array
+ * @param  input_depth dimension 3 of the input array
+ * @param  out_depth_start output depth to start at
+ * @param  out_depth_end output depth to end at plus one
+ */
+extern void xc_conv2d_float_kw5xh2_stride_w3_opt(
+    float *outputs, float *inputs, float *kernels, float *biases, int out_w,
+    int out_h, int out_depth, int input_w, int input_h, int input_depth,
+    int out_depth_start, int out_depth_end);
+
+/** Function that calculates a transposed convolution with a 5x2 filter with
+ * stride 3 in dimension 2 over a tensor.
+ *
+ * @param  outputs     pointer to the output data, the output data will be
+ *                     stored as an array [out_w][out_h][out_depth]
+ * @param  inputs      pointer to the input data, the input data must be
+ *                     stored as an array [input_w][input_h][input_depth]
+ * @param  kernels     pointer to the kernels, the kernels
+ *                     must be stored as an array
+ *                     [out_depth][5][2][depth]
+ * @param  bias        pointer to the biases, the bias must be stored as an
+ * array [out_depth]
+ * @param  out_w       dimension 2 of the output array
+ * @param  out_h       dimension 1 of the output array
+ * @param  out_depth   dimension 3 of the output array
+ * @param  input_w     dimension 2 of the input array
+ * @param  input_h     dimension 1 of the input array
+ * @param  input_depth dimension 3 of the input array
+ * @returns            number of MACCs
+ */
+extern int xc_transpose_conv2d_float_kw5xh2_stride_h3_ref(
+    float *outputs, float *inputs, float *kernels, float *biases, int out_w,
+    int out_h, int out_depth, int input_w, int input_h, int input_depth);
+
+/** Optimised function that calculates a transposed convolution with a 5x2
+ * filter with stride 3 over dimension 2 of a tensor. For parallel usage,
+ * supply multiple invocations with different values of out_depth_start and
+ * out_depth_end so that the whole output depth is covered between all of
+ * them.
+ *
+ * @param  outputs     pointer to the output data, the output data will be
+ *                     stored as an array [out_w][out_h][out_depth]
+ * @param  inputs      pointer to the input data, the input data must be
+ *                     stored as an array [input_w][input_h][input_depth]
+ * @param  kernels     pointer to the kernels, the kernels
+ *                     must be stored as an array
+ *                     [out_depth][5][2][depth]
+ * @param  bias        pointer to the biases, the bias must be stored as an
+ * array [out_depth]
+ * @param  out_w       dimension 2 of the output array
+ * @param  out_h       dimension 1 of the output array
+ * @param  out_depth   dimension 3 of the output array
+ * @param  input_w     dimension 2 of the input array
+ * @param  input_h     dimension 1 of the input array
+ * @param  input_depth dimension 3 of the input array
+ * @param  out_depth_start output depth to start at
+ * @param  out_depth_end output depth to end at plus one
+ */
+extern void xc_transpose_conv2d_float_kw5xh2_stride_h3_opt(
+    float *outputs, float *inputs, float *kernels, float *biases, int out_w,
+    int out_h, int out_depth, int input_w, int input_h, int input_depth,
+    int out_depth_start, int out_depth_end);
+
+#ifdef __cplusplus
+};
+#endif
+
+#endif

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_custom_options.h

@@ -0,0 +1,28 @@
+#ifndef XCORE_CUSTOM_OPTIONS_H_
+#define XCORE_CUSTOM_OPTIONS_H_
+
+#include "flatbuffers/flexbuffers.h"
+#include "xcore_ops.h"
+
+namespace tflite_micro {
+namespace ops {
+namespace micro {
+namespace xcore {
+
+class CustomOptionParser {
+private:
+  flexbuffers::TypedVector keys_;
+  flexbuffers::Vector values_;
+
+public:
+  CustomOptionParser(const flexbuffers::Map &map);
+  CustomOptionParser(const char *buffer, size_t buffer_length);
+  flexbuffers::Reference parseNamedCustomOption(const char *name) const;
+};
+
+} // namespace xcore
+} // namespace micro
+} // namespace ops
+} // namespace tflite_micro
+
+#endif // XCORE_CUSTOM_OPTIONS_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_error_reporter.h

@@ -0,0 +1,32 @@
+// Copyright (c) 2019, XMOS Ltd, All rights reserved
+
+#ifndef XCORE_ERROR_REPORTER_H_
+#define XCORE_ERROR_REPORTER_H_
+
+#include "tensorflow/lite/micro/compatibility.h"
+#include "tensorflow/lite/micro/tflite_bridge/micro_error_reporter.h"
+
+namespace tflite_micro {
+namespace micro {
+namespace xcore {
+
+class XCoreErrorReporter : public tflite_micro::MicroErrorReporter {
+public:
+  explicit XCoreErrorReporter(){};
+  ~XCoreErrorReporter() override = default;
+  void Init(char *debugBuffer, int debugBufferLength);
+  void Log(const char *format, va_list args);
+  int Report(const char *format, va_list args) override;
+
+private:
+  char *buffer;
+  int max_len;
+  int len = 0;
+  TF_LITE_REMOVE_VIRTUAL_DELETE
+};
+
+} // namespace xcore
+} // namespace micro
+} // namespace tflite_micro
+
+#endif // XCORE_ERROR_REPORTER_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_interpreter.h

@@ -0,0 +1,49 @@
+// Copyright (c) 2020, XMOS Ltd, All rights reserved
+#ifndef XCORE_INTERPRETER_H_
+#define XCORE_INTERPRETER_H_
+
+#include "tensorflow/lite/micro/memory_planner/greedy_memory_planner.h"
+#include "tensorflow/lite/micro/memory_planner/micro_memory_planner.h"
+#include "tensorflow/lite/micro/micro_allocator.h"
+#include "tensorflow/lite/micro/micro_interpreter.h"
+#include "xcore_profiler.h"
+
+namespace tflite_micro {
+namespace micro {
+namespace xcore {
+
+class XCoreInterpreter : public tflite_micro::MicroInterpreter {
+public:
+  XCoreInterpreter(const tflite_micro::Model *model,
+                   const tflite_micro::MicroOpResolver &resolver,
+                   tflite_micro::MicroAllocator *allocator,
+                   bool use_curent_thread = true,
+                   XCoreProfiler *profiler = nullptr);
+
+  static XCoreInterpreter *
+  Create(uint8_t interpreter_buffer[], const tflite_micro::Model *model,
+         const tflite_micro::MicroOpResolver &resolver, uint8_t *arena,
+         size_t arena_size, bool use_current_thread, XCoreProfiler *profiler);
+
+  void PrintMemoryPlan();
+  TfLiteTensor *tensor(size_t tensor_index);
+  const char *node_name(int sub_idx, int i);
+
+  TfLiteStatus GetTensorDetails(size_t tensor_index, char *name, int name_len,
+                                int *shape, int *type, float *scale,
+                                int32_t *zero_point);
+
+  TfLiteStatus GetTensorDetailsBufferSizes(size_t tensor_index, size_t *dims,
+                                           size_t *scales, size_t *zero_points);
+
+  size_t input_tensor_index(size_t input_index);
+  size_t output_tensor_index(size_t output_index);
+  const Model *model__;
+  MicroAllocator *allocator_;
+};
+
+} // namespace xcore
+} // namespace micro
+} // namespace tflite_micro
+
+#endif // XCORE_INTERPRETER_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_ops.h

@@ -0,0 +1,79 @@
+#ifndef XCORE_OPS_H_
+#define XCORE_OPS_H_
+
+#include "tensorflow/lite/micro/micro_mutable_op_resolver.h"
+
+namespace tflite_micro {
+namespace ops {
+namespace micro {
+namespace xcore {
+
+constexpr const char *XC_beta_activationf32_OpCode = "XC_beta_activationf32";
+constexpr const char *XC_beta_concatf32_OpCode = "XC_beta_concatf32";
+constexpr const char *XC_beta_convf32_OpCode = "XC_beta_convf32";
+constexpr const char *XC_beta_transposeconvf32_OpCode =
+    "XC_beta_transposeconvf32";
+constexpr const char *XC_beta_fcf32_OpCode = "XC_beta_fcf32";
+
+constexpr const char *XC_binaryi16_OpCode = "XC_binaryi16";
+constexpr const char *XC_unaryi16_OpCode = "XC_unaryi16";
+
+constexpr const char *XC_conv2d_v2_OpCode = "XC_conv2d_v2";
+constexpr const char *XC_maxpool2d_OpCode = "XC_maxpool2d";
+constexpr const char *XC_softmax_OpCode = "XC_softmax";
+constexpr const char *XC_batched_softmax_OpCode = "XC_batched_softmax";
+constexpr const char *XC_ld_weights_OpCode = "XC_ld_weights";
+constexpr const char *XC_ld_weights_wait_OpCode = "XC_ld_weights_wait";
+constexpr const char *XC_add_OpCode = "XC_add";
+constexpr const char *XC_slice_OpCode = "XC_slice";
+constexpr const char *XC_broadcast_OpCode = "XC_broadcast";
+constexpr const char *XC_lookup_OpCode = "XC_lookup";
+constexpr const char *XC_pad_OpCode = "XC_pad";
+constexpr const char *XC_concat_OpCode = "XC_concat";
+constexpr const char *XC_transpose_OpCode = "XC_transpose";
+constexpr const char *XC_pad_3_to_4_OpCode = "XC_pad_3_to_4";
+constexpr const char *XC_mul_OpCode = "XC_mul";
+constexpr const char *XC_mean_OpCode = "XC_mean";
+constexpr const char *XC_meani16_OpCode = "XC_meani16";
+constexpr const char *XC_expand_8_to_16_OpCode = "XC_expand_8_to_16";
+// Binarized ops
+constexpr const char *XC_bsign_8_OpCode = "XC_bsign_8";
+
+TFLMRegistration *Register_XC_beta_activationf32();
+TFLMRegistration *Register_XC_beta_concatf32();
+TFLMRegistration *Register_XC_beta_convf32();
+TFLMRegistration *Register_XC_beta_transposeconvf32();
+TFLMRegistration *Register_XC_beta_fcf32();
+
+TFLMRegistration *Register_XC_binaryi16();
+TFLMRegistration *Register_XC_unaryi16();
+
+TFLMRegistration *Register_XC_conv2d_v2();
+TFLMRegistration *Register_XC_maxpool2d();
+TFLMRegistration *Register_XC_softmax();
+TFLMRegistration *Register_XC_batched_softmax();
+TFLMRegistration *Register_XC_ld_weights();
+TFLMRegistration *Register_XC_ld_weights_wait();
+TFLMRegistration *Register_XC_add();
+TFLMRegistration *Register_XC_slice();
+TFLMRegistration *Register_XC_broadcast();
+TFLMRegistration *Register_XC_lookup();
+TFLMRegistration *Register_XC_pad();
+TFLMRegistration *Register_XC_concat();
+TFLMRegistration *Register_XC_transpose();
+TFLMRegistration *Register_XC_pad_3_to_4();
+TFLMRegistration *Register_XC_mul();
+TFLMRegistration *Register_XC_mean();
+TFLMRegistration *Register_XC_meani16();
+TFLMRegistration *Register_XC_expand_8_to_16();
+// Binarized ops
+TFLMRegistration *Register_XC_bsign_8();
+
+void RegisterXCOps(tflite_micro::MicroOpResolver *res);
+
+} // namespace xcore
+} // namespace micro
+} // namespace ops
+} // namespace tflite_micro
+
+#endif // XCORE_OPS_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_profiler.h

@@ -0,0 +1,49 @@
+// Copyright (c) 2019, XMOS Ltd, All rights reserved
+
+#ifndef XCORE_PROFILER_H_
+#define XCORE_PROFILER_H_
+
+#include "tensorflow/lite/micro/compatibility.h"
+#include "tensorflow/lite/micro/micro_allocator.h"
+#include "tensorflow/lite/micro/micro_profiler.h"
+
+#if !defined(XCORE_PROFILER_DEFAULT_MAX_LEVELS)
+#define XCORE_PROFILER_DEFAULT_MAX_LEVELS (64)
+#endif
+
+namespace tflite_micro {
+namespace micro {
+namespace xcore {
+
+class XCoreProfiler : public tflite_micro::MicroProfiler {
+public:
+  explicit XCoreProfiler(){};
+  ~XCoreProfiler() override = default;
+
+  void Init(tflite_micro::MicroAllocator *allocator,
+            size_t max_event_count = XCORE_PROFILER_DEFAULT_MAX_LEVELS);
+
+  void ClearEvents();
+
+  uint32_t BeginEvent(const char *tag) override;
+
+  // Event_handle is ignored since TFLu does not support concurrent events.
+  void EndEvent(uint32_t event_handle) override;
+
+  uint32_t const *GetEventDurations();
+  size_t GetNumEvents();
+
+private:
+  const char *event_tag_;
+  uint32_t event_start_time_;
+  size_t event_count_ = 0;
+  size_t max_event_count_ = 0;
+  uint32_t *event_durations_;
+  TF_LITE_REMOVE_VIRTUAL_DELETE
+};
+
+} // namespace xcore
+} // namespace micro
+} // namespace tflite_micro
+
+#endif // XCORE_PROFILER_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/tflite-xcore-kernels/xcore_utils.h

@@ -0,0 +1,160 @@
+#ifndef XCORE_UTILS_H_
+#define XCORE_UTILS_H_
+
+#include <cassert>
+#include <cstdint>
+#include <utility>
+
+#include "tensorflow/lite/c/common.h"
+#include "tensorflow/lite/micro/kernels/kernel_util.h"
+#include "tensorflow/lite/micro/memory_helpers.h"
+
+namespace tflite_micro {
+namespace ops {
+namespace micro {
+
+struct XCoreOpData {
+  const char *name;
+};
+
+namespace xcore {
+/* Unpack an integer data type from a byte array
+ *  T  data type to unpack
+ *
+ * Example usage:
+ *      int32_t t0 = unpack<int32_t>(&my_buffer[23]);
+ *      int32_t t1 = unpack<int32_t>(&my_buffer[27]);
+ */
+template <class T> T unpack(const uint8_t *buffer) {
+  T retval = 0;
+  for (int i = 0; i < sizeof(T); ++i)
+    retval |= buffer[i] << (8 * i);
+  return retval;
+}
+
+template <typename T>
+static inline T *construct_persistent_object(TfLiteContext *context) {
+  return new (context->AllocatePersistentBuffer(context, sizeof(T))) T;
+}
+
+static inline bool is_ram_address(uintptr_t a) {
+#ifdef XCORE
+  return ((a >= 0x80000) && (a <= 0x100000));
+#else
+  return true;
+#endif
+}
+
+static inline TfLiteStatus request_scratch_if_needed(TfLiteContext *context,
+                                                     const void *source_address,
+                                                     const size_t size,
+                                                     int &scratch_idx) {
+  if (source_address && !is_ram_address((uintptr_t)source_address)) {
+    return context->RequestScratchBufferInArena(context, size, &scratch_idx);
+  }
+  return kTfLiteOk;
+}
+
+static inline TfLiteStatus request_scratch_if_needed(TfLiteContext *context,
+                                                     const TfLiteTensor *tensor,
+                                                     int &scratch_idx) {
+  return request_scratch_if_needed(context, tensor->data.data, tensor->bytes,
+                                   scratch_idx);
+}
+
+extern "C" {
+static inline void memload(void *dest, void *src, size_t size) {
+  // printf("memload dest=%d   src=%d   size=%d\n", (long)dest, (long)src,
+  // size);
+  memcpy(dest, src, size);
+}
+}
+
+size_t FetchBuffer(int8_t **dest, int8_t const *src, size_t size);
+
+template <typename T>
+static inline TfLiteStatus
+fetch_scratch_if_needed(TfLiteContext *context, T *&array,
+                        const TfLiteEvalTensor *tensor, int scratch_idx) {
+  if (scratch_idx >= 0) {
+    array =
+        static_cast<const T *>(context->GetScratchBuffer(context, scratch_idx));
+    const RuntimeShape shape = tflite_micro::micro::GetTensorShape(tensor);
+
+    size_t sizeof_tensor_type;
+    TfLiteTypeSizeOf(tensor->type, &sizeof_tensor_type);
+    FetchBuffer((int8_t **)&array, tflite_micro::micro::GetTensorData<int8_t>(tensor),
+                shape.FlatSize() * sizeof_tensor_type);
+  } else {
+    array = tflite_micro::micro::GetTensorData<T>(tensor);
+  }
+  TF_LITE_ENSURE(context, array);
+  return kTfLiteOk;
+}
+
+template <typename T> class PersistentArray {
+private:
+  size_t max_size_ = 0;
+  size_t size_ = 0;
+  T *data_ = nullptr;
+
+public:
+  // call this only in the Init phase of operators
+  PersistentArray<T> &allocate(TfLiteContext *context,
+                               size_t max_size) noexcept {
+    assert(data_ == nullptr);
+    assert(max_size > 0);
+
+    max_size_ = max_size;
+    data_ = reinterpret_cast<T *>(
+        context->AllocatePersistentBuffer(context, sizeof(T) * max_size));
+
+    return *this;
+  };
+  PersistentArray<T> &initialize() noexcept {
+    assert(size_ == 0);
+    while (size_ < max_size_) {
+      this->append(T());
+    }
+
+    return *this;
+  };
+  // TODO: begin and end would be better if returned an iterator object
+  inline T *begin() noexcept {
+    assert(size_ > 0);
+    return &data_[0];
+  }
+  inline T *end() noexcept {
+    assert(size_ > 0);
+    return &data_[size_];
+  }
+  inline T &operator[](int i) noexcept {
+    assert(i < size_);
+    return data_[i];
+  }
+  inline void append(const T &element) noexcept {
+    assert(size_ < max_size_);
+    data_[size_++] = element;
+  }
+  inline void append(T &&element) noexcept {
+    assert(size_ < max_size_);
+    data_[size_++] = std::move(element);
+  }
+  inline size_t size() noexcept { return size_; }
+  inline size_t max_size() noexcept { return max_size_; }
+};
+
+#ifndef UNSUPPORTED_KERNEL_TYPE
+#define UNSUPPORTED_KERNEL_TYPE(T)                                             \
+  {                                                                            \
+    DebugLog("Unsupported " #T " value");                                      \
+    TFLITE_ABORT;                                                              \
+  }
+#endif /*UNSUPPORTED_KERNEL_TYPE*/
+
+} // namespace xcore
+} // namespace micro
+} // namespace ops
+} // namespace tflite_micro
+
+#endif // XCORE_UTILS_H_

xmos_ai_tools/runtime/include/lib_tflite_micro/src/thread_call.h

@@ -0,0 +1,119 @@
+#if !defined(__micro_thread_library_h__)
+#define __micro_thread_library_h__
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XCORE_MAX_NUM_THREADS 5
+
+#ifdef __XC__
+    #define UNSAFE unsafe
+#else
+    #define UNSAFE /**/
+#endif
+
+typedef struct { // THIS STRUCT MUST BE IN SYNC WITH ASSEMBLY CODE.
+  union {
+    uint64_t id_aligned[2]; // Guarantee 64-bit alignment.
+    uint32_t id[4];         // Actual IDs
+  } thread_ids;             // ids of at most 4 threads - live during invoke
+  uint32_t synchroniser;    // synchroniser for threads - live during invoke
+  uint32_t nstackwords;     // nstackwords per stack   - live after load model
+  void *UNSAFE stacks;      // pointer to top of stack - live after load model
+} thread_info_t;
+
+
+#ifndef __XC__
+
+typedef void (*thread_function_pointer_t)(void * arg0, void * arg1, void * arg2);
+struct inference_engine;
+
+/** Function that creates threads, then calls a interp_invoke_internal,
+ * then destroys threads
+ * This function creates four threads for a total of five threads.
+ * other versions of the functions create 3, 2, 1, or 0 threads.
+ *
+ * \param   ie     Pointer to the inference object to be passed to
+ *                 interp_invoke_internal
+ * \param   ptr    Pointer to a thread_info block. The thread-ids will
+ *                 be stored in this block, and a stack pointer is expected
+ *                 in this block:
+ *                     ptr[0] [out] thread-id-0    (versions with fewer threads
+ *                     ptr[1] [out] thread-id-1     will only use the first few
+ *                     ptr[2] [out] thread-id-2     slots)
+ *                     ptr[3] [out] thread-id-3
+ *                     ptr[4] [out] synchroniser-id
+ *                     ptr[5] [in]  top of stacks
+ *                     ptr[6] [in]  number of words per stack
+ */
+int thread_invoke_5(struct inference_engine *ie, thread_info_t *ptr);
+int thread_invoke_4(struct inference_engine *ie, thread_info_t *ptr);
+int thread_invoke_3(struct inference_engine *ie, thread_info_t *ptr);
+int thread_invoke_2(struct inference_engine *ie, thread_info_t *ptr);
+int thread_invoke_1(struct inference_engine *ie, thread_info_t *ptr);
+
+/** Function that creates threads.
+ * This function creates four threads for a total of five threads.
+ * other versions of the functions create 3, 2, 1, or 0 threads.
+ *
+ * \param   ptr    Pointer to a thread_info block. The thread-ids will
+ *                 be stored in this block, and a stack pointer is expected
+ *                 in this block:
+ *                     ptr[0] [out] thread-id-0    (versions with fewer threads
+ *                     ptr[1] [out] thread-id-1     will only use the first few
+ *                     ptr[2] [out] thread-id-2     slots)
+ *                     ptr[3] [out] thread-id-3
+ *                     ptr[4] [out] synchroniser-id
+ *                     ptr[5] [in]  top of stacks
+ *                     ptr[6] [in]  number of words per stack
+ */
+void thread_init_5(thread_info_t *ptr);
+void thread_init_4(thread_info_t *ptr);
+void thread_init_3(thread_info_t *ptr);
+void thread_init_2(thread_info_t *ptr);
+void thread_init_1(thread_info_t *ptr);
+/** Function that destroys threads. Must be called from the same function that
+ * called an _init_ above.
+ *
+ * \param   ptr    Pointer to a thread_info block.
+ */
+void thread_destroy(thread_info_t *ptr);
+
+/** Function that sets up parameters for one of the client threads
+ * This particular one passes the second and third arguments to the thread.
+ * When the thread function is actually called (through thread_call)
+ * the thread function will be called with those two arguments, 
+ * and the first shared argument provided by thread_call.
+ * Note - we can make versions with more or fewer parameters.
+ * Note - we could pass this function the thread-function itself
+ *
+ * \param arg1      Second argument for the thread function
+ * \param arg2      Third argument for the thread function
+ * \param thread_id The thread_id to initialise; one of ptr[0]..ptr[3] above
+ */
+void thread_variable_setup(void * arg1, void * arg2, uint32_t thread_id);
+
+/** Function that starts all thread functions and runs them until completion.
+ * It is assumed that the variable parts have been set up per thread.
+ * by thread_variable_setup.
+ * This thread will also invoke the function with the given variable arguments.
+ *
+ * \param arg0      First argument shared among all threads (usually the output pointer)
+ * \param arg1      Second argument for the master thread function
+ * \param arg2      Third argument for the master thread function
+ * \param fp        thread function to call on all threads.
+ * \param ptr       Pointer to the thread info block held in the xcore
+ * interpreter.
+ */
+void thread_call(void * arg0, void * arg1, void * arg2,
+                 thread_function_pointer_t fp, thread_info_t *ptr);
+#ifdef __cplusplus
+};
+#endif
+
+#endif // __XC__
+
+#endif // __micro_thread_library_h__

xmos_ai_tools/runtime/include/lib_xud/lib_xud/api/legacy/usb_defs.h

@@ -0,0 +1,4 @@
+// Copyright 2021 XMOS LIMITED.
+// This Software is subject to the terms of the XMOS Public Licence: Version 1.
+#include "XUD_USB_Defines.h"
+

xmos_ai_tools/runtime/include/lib_xud/lib_xud/api/legacy/usb_device.h

@@ -0,0 +1,4 @@
+// Copyright 2021 XMOS LIMITED.
+// This Software is subject to the terms of the XMOS Public Licence: Version 1.
+#include "xud_device.h"
+