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

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

@@ -0,0 +1,19 @@
+#ifndef XCORE_COMMON_H_
+#define XCORE_COMMON_H_
+
+#include <cassert>
+#include <cstdint>
+
+namespace tflite_micro {
+namespace ops {
+namespace micro {
+namespace xcore {
+
+void calculateThreadSplit(int &tc, int split_size, int split_start[], int split_end[]);
+
+} // namespace xcore
+} // namespace micro
+} // namespace ops
+} // namespace tflite_micro
+
+#endif // XCORE_COMMON_H_

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,71 @@
+#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_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_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";
+// 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_add();
+TFLMRegistration *Register_XC_slice();
+TFLMRegistration *Register_XC_broadcast();
+TFLMRegistration *Register_XC_lookup();
+TFLMRegistration *Register_XC_pad();
+TFLMRegistration *Register_XC_concat();
+TFLMRegistration *Register_XC_pad_3_to_4();
+TFLMRegistration *Register_XC_mul();
+TFLMRegistration *Register_XC_mean();
+// 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"
+

xmos_ai_tools/runtime/include/lib_xud/lib_xud/api/legacy/usb_std_descriptors.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_std_descriptors.h"
+

xmos_ai_tools/runtime/include/lib_xud/lib_xud/api/legacy/usb_std_requests.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_std_requests.h"
+