xmos-ai-tools 1.2.1.dev24__py3-none-win_amd64.whl → 1.3.2.dev180__py3-none-win_amd64.whl

xmos_ai_tools/__init__.py

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

xmos_ai_tools/io_server/__init__.py

@@ -1,151 +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)
+# 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

@@ -1,13 +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")
+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

@@ -1,8 +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_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

@@ -26,9 +26,8 @@ typedef struct flash {
 typedef enum flash_command {
   FLASH_READ_PARAMETERS =
       0, ///< Read a set of parameters.   // TODO: share with lib_tflite_micro
-  FLASH_READ_MODEL = 1, ///< Read a whole model.
-  FLASH_READ_OPERATORS =
-      2, ///< Read the binary for an operator - future extension
+  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,

xmos_ai_tools/runtime/include/lib_nn/api/nn_layers.h

@@ -109,50 +109,6 @@ typedef struct padding_sizes_t {
   int32_t right;
 } padding_sizes_t;
 
-/**
- * @brief Execute @oper{pad_prepare} function.
- *
- * `plan` points to the output vector @tensor{y} with length @math{N}.
- *
- * `p` struct describing the padding to be applied to the input tensor.
- *
- * `x` parameters describing the input tensor to be padded.
- *
- * `bytes_per_pixel` the bytes per pixel for tensor x.
- *
- * @param plan             [out]  The output vector @tensor{y}
- * @param p                [in]   The input vector @tensor{x}
- * @param x                [in]   Look-up table @tensor{T}
- * @param bytes_per_pixel  [in]   Length @math{N} of input and output vectors
- */
-C_API void pad_prepare(nn_pad_plan_t *plan, const padding_sizes_t *p,
-                       const nn_image_params_t *x,
-                       const unsigned bytes_per_pixel);
-
-/**
- * @brief Execute @oper{pad_run} job.
- *
- * See @oper_ref{pad_run} for more details about the @oper{requantize_16_to_8}
- * operator.
- *
- * `Y` points to the output vector @tensor{y}.
- *
- * `X` points to the input vector @tensor{x}.
- *
- * `plan` points to the (initialized) plan.
- *
- * @requires_word_alignment{Y,X}
- *
- * @param y   [out]    The output vector @tensor{y}
- * @param x   [in]     The input vector @tensor{x}
- * @param plan [in]    The prameters describing how to pad.
- */
-void pad_run(char *y, char *x, const nn_pad_plan_t *p, uint32_t pad_value);
-
-void pad_ref(char *y, char *x, const padding_sizes_t *p,
-             const nn_image_params_t *xp, const unsigned bytes_per_pixel,
-             uint32_t pad_value);
-
 /**
  * Func to calculate n_3
  */
@@ -336,12 +292,16 @@ void softmax_generate_exp_lut(int zero_point, float scale, float *lut);
 void softmax_ref(int8_t *Y, const int8_t *X, const float zero_point,
                  const float scale, const int length);
 
-void slice_memcpy(int8_t *dst, int8_t *src, int32_t *in_offsets,
-                  int32_t *out_offsets, int32_t *begin, int32_t *end,
-                  void (*memcpy_func)(void *, void *, size_t));
+void softmax_single(int8_t *Y, const int8_t *X, const float *lut,
+                    const int offset);
+
+void mean_int8(const int8_t *input, int8_t *output, const int start_dim_size,
+               const int mean_dim_size, const int end_dim_size,
+               const float in_zero_point, const float out_zero_point,
+               const float scale_mul);
+
+void mean_int16(const int16_t *input, int16_t *output, const int start_dim_size,
+                const int mean_dim_size, const int end_dim_size,
+                const float scale_mul);
 
-void slice_memcpy_get_params(int *begin_dst, int *end_dst, int *in_offsets,
-                             int *out_offsets, int *shape_dst, const int *begin,
-                             const int *size, const int *shape,
-                             const int dtype_size, const int rank);
 #endif // LAYERS_H_

xmos_ai_tools/runtime/include/lib_nn/api/nn_op_utils.h

@@ -8,6 +8,9 @@
 
 #include "xs3_vpu.h"
 
+C_API int calculateAlignedThreadSplit(int tc, int split_size, int split_start[], int split_end[]);
+C_API int calculateThreadSplit(int tc, int split_size, int split_start[], int split_end[], int alignment);
+
 #ifdef __XC__
 extern "C" {
 #endif

xmos_ai_tools/runtime/include/lib_nn/api/quadratic_approximation.h

@@ -78,5 +78,6 @@ C_API float approximation_function_tanh(float x);
 C_API float approximation_function_logistics(float x);
 C_API float approximation_function_elu(float x);
 C_API float approximation_function_relu(float x);
+C_API float approximation_function_relu6(float x);
 
 #endif

xmos_ai_tools/runtime/include/lib_nn/api/version.h

@@ -1,11 +1,11 @@
-// Copyright (c) 2020, XMOS Ltd, All rights reserved
+// Copyright (c) 2024, XMOS Ltd, All rights reserved
 #ifndef LIB_NN_VERSION_H_
 #define LIB_NN_VERSION_H_
 
 namespace lib_nn {
 
 static const unsigned major_version = 0;
-static const unsigned minor_version = 3;
+static const unsigned minor_version = 4;
 static const unsigned patch_version = 0;
 
 }  // namespace lib_nn

xmos_ai_tools/runtime/include/lib_nn/api/vpu_memmove_word_aligned.h

@@ -0,0 +1,15 @@
+#ifndef _vpu_memmove_word_aligned_h_
+#define _vpu_memmove_word_aligned_h_
+
+/**
+ * Function that copies a block of memory. Both source and destination
+ * address must be word aligned. Any number of bytes can be copied. There
+ * may be an overlap between the destination and source.
+ *
+ * @param     dst         Destination address, must be word aligned.
+ * @param     src         Source address, must be word aligned.
+ * @param     byte_count  Number of bytes to copy - may be zero
+ */
+void vpu_memmove_word_aligned(void * dst, const void * src, unsigned int byte_count);
+
+#endif

xmos_ai_tools/runtime/include/lib_nn/api/vpu_memset_256.h

@@ -0,0 +1,55 @@
+#include <stdint.h>
+
+#ifndef _vpu_memset_256_h_
+#define _vpu_memset_256_h_
+
+/**
+ * Function that replicates a vector. The source address must be word
+ * aligned, the destination address is assumed to be aligned with the
+ * replication pattern in the source. Any number of bytes can be copied.
+ * There should not be an overlap between the destination and source.
+ *
+ * It is assumed that the source address contains 32 replicated bytes (if
+ * the destination address is byte aligned), or that it contains 16
+ * replicated shorts (if the destination address is 16-bit aligned), or
+ * that it contains 8 replicated ints.
+ *
+ * broadcast_32_to_256() and BROADCAST_8_TO_32() cane be used to
+ * create the source vector
+ *
+ * @param     dst         Destination address
+ * @param     src         Source address, must be word aligned.
+ * @param     byte_count  Number of bytes to copy - may be zero
+ */
+void vpu_memset_256(void *dst, const void *src, unsigned int byte_count);
+
+/**
+ * Function that replicates an int over a vector. The vector must be
+ * aligned on an 8-byte boundary. In order to replicate a byte or short over
+ * a vector, combine this with a call to BROADCAST_8_TO_32() or
+ * BROADCAST_16_TO_32(). Declare the vector as a uint64_t x[] in order to
+ * guarantee 8-byte alignement.
+ *
+ * @param     dst         Destination address, must be 8-byte aligned
+ * @param     from        Value to be replicated
+ */
+void broadcast_32_to_256(void *dst, uint32_t from);
+
+/**
+ * Macro that replicates a byte over an int.
+ * Use with broadcast_32_to_256() in order to replicate a byte over a vector
+ */
+#define BROADCAST_8_TO_32(f) (((uint8_t)f) * 0x01010101)
+
+/**
+ * Macro that replicates a short over an int
+ * Use with broadcast_32_to_256() in order to replicate a short over a vector
+ */
+#define BROADCAST_16_TO_32(f) (((uint16_t)f) * 0x00010001)
+
+/**
+ * Macro that replicates a byte over a short
+ */
+#define BROADCAST_8_TO_16(f) (((uint8_t)f) * 0x00000101)
+
+#endif

xmos_ai_tools/runtime/include/lib_tflite_micro/api/fast_flash.h

@@ -3,6 +3,7 @@
 
 #include <quadflash.h>
 
+#ifdef __XC__
 /** Fast flash library.
  * Before calling any of the functions in here, lib_quad_flash must be initialised as normal by using
  * fl_connectToDevice(qspi, flash_spec, n_flash_spec).
@@ -44,4 +45,9 @@ int fast_flash_init(fl_QSPIPorts &qspi);
  */
 void fast_flash_read(fl_QSPIPorts &qspi, unsigned addr, unsigned word_count, unsigned read_data[], chanend ?c_data_out);
 
+#else
+int fast_flash_init(fl_QSPIPorts *qspi);
+void fast_flash_read(fl_QSPIPorts *qspi, unsigned addr, unsigned word_count, unsigned read_data[], chanend_t c_data_out);
+#endif
+
 #endif

xmos_ai_tools/runtime/include/lib_tflite_micro/api/inference_engine.h

@@ -38,15 +38,15 @@
  * must therefore be allocated inside a C++ source file.
  */
 struct tflite_micro_objects {
-  tflite::micro::xcore::XCoreErrorReporter error_reporter;
-  tflite::micro::xcore::XCoreProfiler xcore_profiler;
+  tflite_micro::micro::xcore::XCoreErrorReporter error_reporter;
+  tflite_micro::micro::xcore::XCoreProfiler xcore_profiler;
   uint64_t interpreter_buffer
-      [(sizeof(tflite::micro::xcore::XCoreInterpreter) + sizeof(uint64_t) - 1) /
+      [(sizeof(tflite_micro::micro::xcore::XCoreInterpreter) + sizeof(uint64_t) - 1) /
        sizeof(uint64_t)]; // This needs to be aligned on a double word boundary
-  tflite::MicroMutableOpResolver<XTFLM_OPERATORS> resolver;
+  tflite_micro::MicroMutableOpResolver<XTFLM_OPERATORS> resolver;
 
-  tflite::micro::xcore::XCoreInterpreter *interpreter;
-  const tflite::Model *model;
+  tflite_micro::micro::xcore::XCoreInterpreter *interpreter;
+  const tflite_micro::Model *model;
 };
 #endif
 
@@ -122,8 +122,8 @@ typedef struct inference_engine {
  *                                                     &s0);
  *        resolver->AddAdd();
  *        resolver->AddConv2D();
- *        resolver->AddCustom(tflite::ops::micro::xcore::Conv2D_V2_OpCode,
- *                   tflite::ops::micro::xcore::Register_Conv2D_V2());
+ *        resolver->AddCustom(tflite_micro::ops::micro::xcore::Conv2D_V2_OpCode,
+ *                   tflite_micro::ops::micro::xcore::Register_Conv2D_V2());
  *    [...]
  *
  * Note that when tensorflow lite for micro is disabled this function will not
@@ -146,7 +146,7 @@ typedef struct inference_engine {
  * structures. Must be allocated by the caller.
  *
  */
-tflite::MicroMutableOpResolver<XTFLM_OPERATORS> *inference_engine_initialize(
+tflite_micro::MicroMutableOpResolver<XTFLM_OPERATORS> *inference_engine_initialize(
     inference_engine_t *UNSAFE ie, uint32_t memory_primary[],
     uint32_t n_memory_primary, uint32_t memory_secondary[],
     uint32_t n_secondary, struct tflite_micro_objects *UNSAFE xtflmo);
@@ -175,17 +175,17 @@ void inference_engine_unload_model(inference_engine_t *UNSAFE ie);
  * \param ie           pointer to inference engine.
  * \param model_bytes  Number of bytes in the model
  * \param model_data   Pointer to the model (one of data_model or
- * data_tensor_arena passed above) \param c_flash      Optional channel to flash
- * server, to be used for fetching parameter blocks
+ * data_tensor_arena passed above) \param c_flash_or_tile      Optional channel to flash
+ * or tile server
  *
  * \returns            non zero indicates an error
  */
 #ifdef __XC__
-    int inference_engine_load_model(inference_engine_t * UNSAFE ie, uint32_t model_bytes, uint32_t * UNSAFE model_data, chanend ?c_flash);
+    int inference_engine_load_model(inference_engine_t * UNSAFE ie, uint32_t model_bytes, uint32_t * UNSAFE model_data, chanend ?c_flash_or_tile);
 #else
 int inference_engine_load_model(inference_engine_t *UNSAFE ie,
                                 uint32_t model_bytes,
-                                uint32_t *UNSAFE model_data, void *flash_data);
+                                uint32_t *UNSAFE model_data, void *weights_data_ptr);
 #endif
 
     /** Function that invokes the inference engine. This function will create an