mlonmcu 0.3.0.dev0__3-none-any.whl

resources/platforms/zephyr/project/cmake/backends/tvmrt.cmake

@@ -0,0 +1,8 @@
+IF("${MLONMCU_FRAMEWORK}" STREQUAL "")
+    SET(MLONMCU_FRAMEWORK "tvm")
+ENDIF()
+
+SET(TVM_REQUIRED_COMPONENTS a b c)
+
+SET(TVM_LIB tvm_graph_rt)
+SET(TVM_WRAPPER_FILENAME rt_wrapper.c)

resources/platforms/zephyr/project/cmake/extras.cmake

@@ -0,0 +1,9 @@
+IF(DEFINED DEBUG_ARENA_USAGE)
+    IF(DEBUG_ARENA_USAGE)
+        SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG_ARENA_USAGE=1")
+        SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG_ARENA_USAGE=1")
+    ELSE()
+        SET(CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG} -DDEBUG_ARENA_USAGE=0")
+        SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DDEBUG_ARENA_USAGE=0")
+    ENDIF()
+ENDIF()

resources/platforms/zephyr/project/cmake/features/auto_vectorize_gcc.cmake

@@ -0,0 +1,65 @@
+IF(NOT RISCV_VEXT)
+    MESSAGE(FATAL_ERROR "RISCV_AUTO_VECTORIZE requires RISCV_VEXT")
+ENDIF()
+IF(RISCV_RVV_VLEN)
+    SET(VLEN ${RISCV_RVV_VLEN})
+ELSE()
+    SET(VLEN "?")
+ENDIF()
+SET(CMAKE_CXX_FLAGS_RELEASE
+    "${CMAKE_CXX_FLAGS_RELEASE} \
+    -ftree-vectorize \
+    -mriscv-vector-bits=${VLEN} \
+"
+)
+SET(CMAKE_C_FLAGS_RELEASE
+    "${CMAKE_C_FLAGS_RELEASE} \
+    -ftree-vectorize \
+    -mriscv-vector-bits=${VLEN} \
+"
+)
+IF(DEFINED RISCV_AUTO_VECTORIZE_LOOP)
+    IF(NOT RISCV_AUTO_VECTORIZE_LOOP)
+        SET(CMAKE_CXX_FLAGS_RELEASE
+            "${CMAKE_CXX_FLAGS_RELEASE} \
+            -fno-tree-loop-vectorize \
+        "
+        )
+        SET(CMAKE_C_FLAGS_RELEASE
+            "${CMAKE_C_FLAGS_RELEASE} \
+            -fno-tree-loop-vectorize \
+        "
+        )
+    ENDIF()
+ENDIF()
+IF(DEFINED RISCV_AUTO_VECTORIZE_SLP)
+    IF(NOT RISCV_AUTO_VECTORIZE_SLP)
+        SET(CMAKE_CXX_FLAGS_RELEASE
+            "${CMAKE_CXX_FLAGS_RELEASE} \
+            -fno-tree-slp-vectorize \
+        "
+        )
+        SET(CMAKE_C_FLAGS_RELEASE
+            "${CMAKE_C_FLAGS_RELEASE} \
+            -fno-tree-slp-vectorize \
+        "
+        )
+    ENDIF()
+ENDIF()
+# Also interesting:
+# -mriscv-vector-lmul=<lmul>  Set the vf using lmul in auto-vectorization
+# -fsimd-cost-model=[unlimited|dynamic|cheap|very-cheap] Specifies the vectorization cost model for code marked with a simd directive
+IF(RISCV_AUTO_VECTORIZE_VERBOSE)
+    SET(CMAKE_CXX_FLAGS_RELEASE
+        "${CMAKE_CXX_FLAGS_RELEASE} \
+        -fopt-info-vec \
+        -fopt-info-vec-missed \
+    "
+    )
+    SET(CMAKE_C_FLAGS_RELEASE
+        "${CMAKE_C_FLAGS_RELEASE} \
+        -fopt-info-vec \
+        -fopt-info-vec-missed \
+    "
+    )
+ENDIF()

resources/platforms/zephyr/project/cmake/features/auto_vectorize_llvm.cmake

@@ -0,0 +1,20 @@
+IF(NOT RISCV_VEXT)
+    MESSAGE(FATAL_ERROR "RISCV_AUTO_VECTORIZE requires RISCV_VEXT")
+ENDIF()
+IF(RISCV_RVV_VLEN)
+    SET(VLEN ${RISCV_RVV_VLEN})
+ELSE()
+    SET(VLEN "?")
+ENDIF()
+ SET(CMAKE_CXX_FLAGS_RELEASE
+     "${CMAKE_CXX_FLAGS_RELEASE} \
+     -mllvm \
+     --riscv-v-vector-bits-min=${VLEN} \
+ "
+ )
+ SET(CMAKE_C_FLAGS_RELEASE
+     "${CMAKE_C_FLAGS_RELEASE} \
+     -mllvm \
+     --riscv-v-vector-bits-min=${VLEN} \
+ "
+ )

resources/platforms/zephyr/project/cmake/features/cmsisnn.cmake

@@ -0,0 +1,86 @@
+IF(NOT CMSISNN_DIR)
+    MESSAGE(FATAL_ERROR "Missing value: CMSISNN_DIR")
+ENDIF()
+
+IF(NOT ARM_MVEI)
+    SET(USE_MVEI OFF)
+ELSE()
+    SET(USE_MVEI ON)
+ENDIF()
+
+IF(NOT ARM_DSP)
+    SET(USE_DSP OFF)
+ELSE()
+    SET(USE_DSP ON)
+ENDIF()
+
+SET(BUILD_FLAGS "")
+# IF(USE_MVEI) SET(BUILD_FLAGS "${BUILD_FLAGS} -D__ARM_FEATURE_MVE=1 -DARM_MATH_MVEI=1") ENDIF() IF(USE_DSP)
+# SET(BUILD_FLAGS "${BUILD_FLAGS} -D__ARM_FEATURE_DSP=1 -DARM_MATH_DSP=1") ENDIF()
+
+SET(CMSISNN_INCLUDE_DIRS ${CMSISNN_DIR} ${CMSISNN_DIR}/CMSIS/Core/Include ${CMSISNN_DIR}/CMSIS/NN/Include
+                         ${CMSISNN_DIR}/CMSIS/DSP/Include
+)
+
+# TODO: propagarting all toolchain specific vars does not scale well
+
+MESSAGE(STATUS "ARM_CPU=${ARM_CPU}")
+INCLUDE(ExternalProject)
+EXTERNALPROJECT_ADD(
+    cmsisnn
+    PREFIX cmsisnn
+    SOURCE_DIR ${CMSISNN_DIR}/CMSIS/NN/
+    CMAKE_ARGS -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+               -DCMAKE_C_FLAGS:STRING=${BUILD_FLAGS}
+               -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE}
+               -DTC_PREFIX=${TC_PREFIX}
+               -DEXE_EXT=${EXE_EXT}
+               -DARM_CPU=${ARM_CPU}
+               -DARM_FLOAT_ABI=${ARM_FLOAT_ABI}
+               -DARM_FPU=${ARM_FPU}
+               -DRISCV_ARCH=${RISCV_ARCH}
+               -DRISCV_ABI=${RISCV_ABI}
+    BUILD_COMMAND "${CMAKE_COMMAND}" --build .
+    INSTALL_COMMAND ""
+)
+
+EXTERNALPROJECT_GET_PROPERTY(cmsisnn BINARY_DIR)
+SET(CMSISNN_LIB ${BINARY_DIR}/Source/libcmsis-nn.a)
+
+# TFLite integration
+IF(TFLM_OPTIMIZED_KERNEL_LIB)
+    LIST(APPEND TFLM_OPTIMIZED_KERNEL_LIB ${CMSISNN_LIB})
+ELSE()
+    SET(TFLM_OPTIMIZED_KERNEL_LIB ${CMSISNN_LIB})
+ENDIF()
+
+IF(TFLM_OPTIMIZED_KERNEL_INCLUDE_DIR)
+    LIST(APPEND TFLM_OPTIMIZED_KERNEL_INCLUDE_DIR ${CMSISNN_INCLUDE_DIRS})
+ELSE()
+    SET(TFLM_OPTIMIZED_KERNEL_INCLUDE_DIR ${CMSISNN_INCLUDE_DIRS})
+ENDIF()
+
+IF(TFLM_OPTIMIZED_KERNEL_DEPS)
+    LIST(APPEND TFLM_OPTIMIZED_KERNEL_DEPS cmsisnn)
+ELSE()
+    SET(TFLM_OPTIMIZED_KERNEL_DEPS cmsisnn)
+ENDIF()
+
+# TVM integration
+IF(TVM_EXTRA_LIBS)
+    LIST(APPEND TVM_EXTRA_LIBS ${CMSISNN_LIB})
+ELSE()
+    SET(TVM_EXTRA_LIBS ${CMSISNN_LIB})
+ENDIF()
+
+IF(TVM_EXTRA_INCS)
+    LIST(APPEND TVM_EXTRA_INCS ${CMSISNN_INCLUDE_DIRS})
+ELSE()
+    SET(TVM_EXTRA_INCS ${CMSISNN_INCLUDE_DIRS})
+ENDIF()
+
+IF(TVM_EXTRA_DEPS)
+    LIST(APPEND TVM_EXTRA_DEPS cmsisnn)
+ELSE()
+    SET(TVM_EXTRA_DEPS cmsisnn)
+ENDIF()

resources/platforms/zephyr/project/cmake/features/muriscvnn.cmake

@@ -0,0 +1,87 @@
+IF(NOT MURISCVNN_DIR)
+    MESSAGE(FATAL_ERROR "Missing value: MURISCVNN_DIR")
+ENDIF()
+
+IF(NOT RISCV_VEXT)
+    SET(USE_VEXT OFF)
+ELSE()
+    SET(USE_VEXT ON)
+ENDIF()
+
+IF(NOT RISCV_PEXT)
+    SET(USE_PEXT OFF)
+ELSE()
+    SET(USE_PEXT ON)
+ENDIF()
+
+IF(NOT MURISCVNN_TOOLCHAIN)
+    SET(MURISCVVN_TOOLCHAIN GCC)
+    # SET(MURISCVVN_TOOLCHAIN NONE)
+ENDIF()
+
+SET(MURISCVNN_INCLUDE_DIRS ${MURISCVNN_DIR}/Include ${MURISCVNN_DIR}/Include/CMSIS/NN/Include)
+
+# TODO: propagarting all toolchain specific vars does not scale well
+
+INCLUDE(ExternalProject)
+EXTERNALPROJECT_ADD(
+    muriscvnn
+    PREFIX muriscvnn
+    SOURCE_DIR ${MURISCVNN_DIR}
+    CMAKE_ARGS -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE}
+               -DUSE_VEXT=${USE_VEXT}
+               -DUSE_PEXT=${USE_PEXT}
+               -DTOOLCHAIN=${MURISCVNN_TOOLCHAIN}
+               -DCMAKE_TOOLCHAIN_FILE=${TOOLCHAIN_FILE}
+               -DENABLE_TESTS=OFF
+               -DTC_PREFIX=${TC_PREFIX}
+               -DEXE_EXT=${EXE_EXT}
+               -DRISCV_ARCH=${RISCV_ARCH}
+               -DRISCV_ABI=${RISCV_ABI}
+               -DARM_CPU=${ARM_CPU}
+               -DARM_FLOAT_ABI=${ARM_FLOAT_ABI}
+               -DARM_FPU=${ARM_FPU}
+    BUILD_COMMAND "${CMAKE_COMMAND}" --build .
+    INSTALL_COMMAND ""
+)
+
+EXTERNALPROJECT_GET_PROPERTY(muriscvnn BINARY_DIR)
+SET(MURISCVNN_LIB ${BINARY_DIR}/Source/libmuriscv_nn.a)
+
+# TFLite integration
+IF(TFLM_OPTIMIZED_KERNEL_LIB)
+    LIST(APPEND TFLM_OPTIMIZED_KERNEL_LIB ${MURISCVNN_LIB})
+ELSE()
+    SET(TFLM_OPTIMIZED_KERNEL_LIB ${MURISCVNN_LIB})
+ENDIF()
+
+IF(TFLM_OPTIMIZED_KERNEL_INCLUDE_DIR)
+    LIST(APPEND TFLM_OPTIMIZED_KERNEL_INCLUDE_DIR ${MURISCVNN_INCLUDE_DIRS})
+ELSE()
+    SET(TFLM_OPTIMIZED_KERNEL_INCLUDE_DIR ${MURISCVNN_INCLUDE_DIRS})
+ENDIF()
+
+IF(TFLM_OPTIMIZED_KERNEL_DEPS)
+    LIST(APPEND TFLM_OPTIMIZED_KERNEL_DEPS muriscvnn)
+ELSE()
+    SET(TFLM_OPTIMIZED_KERNEL_DEPS muriscvnn)
+ENDIF()
+
+# TVM integration
+IF(TVM_EXTRA_LIBS)
+    LIST(APPEND TVM_EXTRA_LIBS ${MURISCVNN_LIB})
+ELSE()
+    SET(TVM_EXTRA_LIBS ${MURISCVNN_LIB})
+ENDIF()
+
+IF(TVM_EXTRA_INCS)
+    LIST(APPEND TVM_EXTRA_INCS ${MURISCVNN_INCLUDE_DIRS})
+ELSE()
+    SET(TVM_EXTRA_INCS ${MURISCVNN_INCLUDE_DIRS})
+ENDIF()
+
+IF(TVM_EXTRA_DEPS)
+    LIST(APPEND TVM_EXTRA_DEPS muriscvnn)
+ELSE()
+    SET(TVM_EXTRA_DEPS muriscvnn)
+ENDIF()

resources/platforms/zephyr/project/cmake/frameworks/tflm.cmake

@@ -0,0 +1 @@
+

resources/platforms/zephyr/project/cmake/frameworks/tflm_mlif.cmake

@@ -0,0 +1,8 @@
+SET(TF_OUT_DIR ${CONFIG_MLONMCU_CODEGEN_DIR}/)
+SET(GEN_SRC ${TF_OUT_DIR}/model.cc)
+GET_FILENAME_COMPONENT(GEN_SRC ${GEN_SRC} REALPATH)
+GET_FILENAME_COMPONENT(EXTRA_INC ${GEN_SRC} DIRECTORY)
+SET(EXTRA_SRC ml_interface_tflm.cc ${GEN_SRC})
+SET(EXTRA_LIBS tflm)
+SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DTFLMC_DEBUG_ALLOCATIONS")
+LIST(APPEND EXTRA_LIBS ${CUSTOM_OPS_LIBS})

resources/platforms/zephyr/project/cmake/frameworks/tvm.cmake

@@ -0,0 +1 @@
+

resources/platforms/zephyr/project/cmake/frameworks/tvm_mlif.cmake

@@ -0,0 +1,37 @@
+SET(TVM_OUT_DIR ${CONFIG_MLONMCU_CODEGEN_DIR}/codegen/host/)
+SET(EXTRA_SRC ml_interface_tvm.c)
+
+FILE(GLOB TVM_SRCS ${TVM_OUT_DIR}/src/*_lib*.c ${TVM_OUT_DIR}/src/*_lib*.cc)
+
+IF(NOT TVM_SRCS)
+    MESSAGE(STATUS "NO SOURCES")
+    FILE(GLOB TVM_OBJS ${TVM_OUT_DIR}/lib/*_lib*.o)
+    MESSAGE(STATUS "TVM_OBJS=${TVM_OBJS}")
+    ADD_LIBRARY(tvm_extension OBJECT IMPORTED)
+
+    SET_PROPERTY(TARGET tvm_extension PROPERTY
+        IMPORTED_OBJECTS ${TVM_OBJS}
+    )
+ELSE()
+    # Need this in extra target to avoid circular dependency .
+    ADD_LIBRARY(tvm_extension STATIC ${TVM_SRCS})
+    TARGET_INCLUDE_DIRECTORIES(tvm_extension PUBLIC ${TVM_HEADERS} ${TVM_OUT_DIR}/include ${CONFIG_MLONMCU_CODEGEN_DIR})
+    TARGET_LINK_LIBRARIES(tvm_extension PUBLIC m)
+    TARGET_LINK_LIBRARIES(tvm_extension PUBLIC ${TVM_LIB})
+ENDIF()
+
+SET(EXTRA_SRC ${EXTRA_SRC} ${CONFIG_MLONMCU_CODEGEN_DIR}/${TVM_WRAPPER_FILENAME})
+TARGET_LINK_LIBRARIES(${TVM_LIB} PUBLIC tvm_extension)
+SET(EXTRA_INC ${TVM_OUT_DIR}/include ${CONFIG_MLONMCU_CODEGEN_DIR})
+
+SET(EXTRA_LIBS tvm_extension ${TVM_LIB})
+
+FOREACH(ENTRY ${CONFIG_TVM_EXTRA_LIBS})
+    TARGET_LINK_LIBRARIES(tvm_extension PUBLIC ${ENTRY})
+ENDFOREACH()
+FOREACH(ENTRY ${CONFIG_TVM_EXTRA_INCS})
+    TARGET_INCLUDE_DIRECTORIES(tvm_extension PUBLIC ${ENTRY})
+ENDFOREACH()
+FOREACH(ENTRY ${CONFIG_TVM_EXTRA_DEPS})
+    ADD_DEPENDENCIES(tvm_extension ${ENTRY})
+ENDFOREACH()

resources/platforms/zephyr/project/lib/CMakeLists.txt

@@ -0,0 +1,13 @@
+PROJECT(target_sw_lib)
+
+ADD_SUBDIRECTORY(support)
+ADD_SUBDIRECTORY(ml_interface)
+
+SET(TARGET_LIB_SOURCE targets/${TARGET_SYSTEM}.c)
+IF(NOT EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${TARGET_LIB_SOURCE})
+    SET(TARGET_LIB_SOURCE targets/default.c)
+ENDIF()
+
+ADD_LIBRARY(${PROJECT_NAME} STATIC drivers/fake_input.c ${TARGET_LIB_SOURCE})
+TARGET_INCLUDE_DIRECTORIES(${PROJECT_NAME} PUBLIC lib/drivers lib/targets)
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} PUBLIC support ml_interface)

resources/platforms/zephyr/project/lib/drivers/fake_input.c

@@ -0,0 +1,10 @@
+#include "fake_input.h"
+#include <stdint.h>
+
+void FakeInput_GetData(void *out, size_t len) {
+  volatile uint8_t *p = 0xc0000000;
+
+  for (size_t i = 0; i < len; i++) {
+    *(uint8_t *)out = *(p + i);
+  }
+}

resources/platforms/zephyr/project/lib/drivers/fake_input.h

@@ -0,0 +1,8 @@
+#ifndef DRIVER_FAKE_INPUT_H
+#define DRIVER_FAKE_INPUT_H
+
+#include <stddef.h>
+
+void FakeInput_GetData(void *out, size_t len);
+
+#endif

resources/platforms/zephyr/project/lib/ml_interface/CMakeLists.txt

@@ -0,0 +1,31 @@
+PROJECT(ml_interface)
+
+INCLUDE(extras)
+
+INCLUDE(frameworks/${CONFIG_MLONMCU_FRAMEWORK}_mlif)
+
+IF(CONFIG_MODEL_DIR)
+    GET_FILENAME_COMPONENT(MODEL_SUPPORT_DIR ${CONFIG_MODEL_DIR}/support REALPATH)
+    GET_FILENAME_COMPONENT(MODEL_NAME ${CONFIG_MODEL_DIR} NAME)
+ENDIF()
+
+IF(MODEL_SUPPORT_DIR AND EXISTS ${MODEL_SUPPORT_DIR})
+    ADD_SUBDIRECTORY(${MODEL_SUPPORT_DIR} model_support_bin_${MODEL_NAME})
+ELSE()
+    ADD_SUBDIRECTORY(default_model_support)
+ENDIF()
+
+IF(NOT CONFIG_DATA_SRC)
+    SET(CONFIG_DATA_SRC "default_data.c")
+ENDIF()
+
+ADD_LIBRARY(${PROJECT_NAME}_base STATIC ${CONFIG_DATA_SRC})
+TARGET_LINK_LIBRARIES(${PROJECT_NAME}_base PUBLIC support ${EXTRA_LIBS})
+TARGET_INCLUDE_DIRECTORIES(${PROJECT_NAME}_base PUBLIC . ${EXTRA_INC})
+
+ADD_LIBRARY(${PROJECT_NAME} STATIC ml_interface.c ${EXTRA_SRC})
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} PUBLIC ${PROJECT_NAME}_base model_support)
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} PUBLIC ${PROJECT_NAME}_base model_support zephyr)
+IF(CONFIG_NUM_RUNS)
+    TARGET_COMPILE_DEFINITIONS(${PROJECT_NAME} PUBLIC NUM_RUNS=${CONFIG_NUM_RUNS})
+ENDIF()

resources/platforms/zephyr/project/lib/ml_interface/default_data.c

@@ -0,0 +1,8 @@
+#include "ml_interface.h"
+#include <stddef.h>
+const int num_data_buffers_in = 0;
+const int num_data_buffers_out = 0;
+const unsigned char *const data_buffers_in[] = {};
+const unsigned char *const data_buffers_out[] = {};
+const size_t data_size_in[] = {};
+const size_t data_size_out[] = {};

resources/platforms/zephyr/project/lib/ml_interface/default_model_support/CMakeLists.txt

@@ -0,0 +1,2 @@
+ADD_LIBRARY(model_support STATIC process_input.c process_output.c)
+TARGET_LINK_LIBRARIES(model_support PUBLIC ml_interface_base)

resources/platforms/zephyr/project/lib/ml_interface/default_model_support/process_input.c

@@ -0,0 +1,17 @@
+#include <stdlib.h>
+#include <memory.h>
+
+#include "printing.h"
+#include "exit.h"
+
+void mlif_process_input(const void *in_data, size_t in_size, void *model_input_ptr, size_t model_input_sz) {
+  if (in_size != 0) {
+    if (in_size != model_input_sz) {
+      DBGPRINTF("MLIF: Given input size (%lu) does not match model input buffer size (%lu)!\n", in_size,
+                model_input_sz);
+      exit(EXIT_MLIF_INVALID_SIZE);
+    }
+  }
+
+  memcpy(model_input_ptr, in_data, in_size);
+}

resources/platforms/zephyr/project/lib/ml_interface/default_model_support/process_output.c

@@ -0,0 +1,27 @@
+#include <stdlib.h>
+#include <memory.h>
+
+#include "printing.h"
+#include "exit.h"
+
+void mlif_process_output(void *model_output_ptr, size_t model_output_sz, const void *expected_out_data,
+                         size_t expected_out_size) {
+#ifdef _DEBUG
+  if (model_output_sz >= 4) {
+    DBGPRINTF("MLIF: First float of output: %f\n", *(float *)model_output_ptr);
+  }
+  DBGPRINTF("MLIF: Model output data: ");
+  for (size_t i = 0; i < model_output_sz; i++) {
+    DBGPRINTF("\\x%02X", ((unsigned char *)model_output_ptr)[i]);
+    fflush(0);
+  }
+  DBGPRINTF("\n");
+#endif
+
+  if (model_output_sz == expected_out_size && memcmp(model_output_ptr, expected_out_data, model_output_sz) == 0) {
+    DBGPRINTF("MLIF: Output data matches expected data\n");
+  } else {
+    DBGPRINTF("MLIF: Wrong output data!\n");
+    exit(EXIT_MLIF_MISSMATCH);
+  }
+}

resources/platforms/zephyr/project/lib/ml_interface/ml_interface.c

@@ -0,0 +1,36 @@
+#include "ml_interface.h"
+#include "printing.h"
+
+#include <string.h>
+#include <stdlib.h>
+
+__attribute__((weak)) bool mlif_request_input(void *model_input_ptr, size_t model_input_sz) {
+  static int num_done = 0;
+  if (num_done == num_data_buffers_in) {
+    static bool run_once = true;
+    if (num_data_buffers_in == 0 && run_once) {
+      // Minimal run. Just run the model without data.
+      run_once = false;
+      return true;
+    }
+    return false;
+  }
+
+  mlif_process_input(data_buffers_in[num_done], data_size_in[num_done], model_input_ptr, model_input_sz);
+  num_done++;
+  return true;
+}
+
+__attribute__((weak)) void mlif_handle_result(void *model_output_ptr, size_t model_output_sz) {
+  static int num_done = 0;
+
+  if (num_data_buffers_out == 0) {
+    return;
+  }
+
+  if (num_done < num_data_buffers_out) {
+    mlif_process_output(model_output_ptr, model_output_sz, data_buffers_out[num_done], data_size_out[num_done]);
+  }
+
+  num_done++;
+}

resources/platforms/zephyr/project/lib/ml_interface/ml_interface.h

@@ -0,0 +1,47 @@
+#ifndef TARGETLIB_ML_INTERFACE_H
+#define TARGETLIB_ML_INTERFACE_H
+
+#include <stddef.h>
+#include <stdbool.h>
+
+#ifndef NUM_RUNS
+#define NUM_RUNS 1
+#endif /* NUM_RUNS */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// This runs the ML model using the callbacks above.
+// The default implementation will run with garbage data.
+void mlif_run();
+
+// These can be overridden by use code.
+
+// Provides input data for the model. The default implementation retrieves input from
+// the global variables below and fills the model input with mlif_process_input.
+bool mlif_request_input(void *model_input_ptr, size_t model_input_sz);
+// Is called when the output data is available. The default implementation
+void mlif_handle_result(void *model_output_ptr, size_t model_output_sz);
+
+// Callback for any preprocessing on the input data. Responsible for copying the data.
+void mlif_process_input(const void *in_data, size_t in_size, void *model_input_ptr, size_t model_input_sz);
+// Callback for any postprocessing on the output data. The default implementation prints
+// the output and verifies consistency with the expected output.
+void mlif_process_output(void *model_output_ptr, size_t model_output_sz, const void *expected_out_data,
+                         size_t expected_out_size);
+
+extern const int num_data_buffers_in;
+extern const int num_data_buffers_out;
+extern const unsigned char *const data_buffers_in[];
+extern const unsigned char *const data_buffers_out[];
+extern const size_t data_size_in[];
+extern const size_t data_size_out[];
+
+extern const int num;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

resources/platforms/zephyr/project/lib/ml_interface/ml_interface_tflm.cc

@@ -0,0 +1,22 @@
+#include "ml_interface.h"
+
+#include "model.cc.h"
+
+void mlif_run() {
+  model_init();
+
+  size_t input_num = 0;
+  size_t remaining = NUM_RUNS;
+  while (mlif_request_input(model_input_ptr(input_num), model_input_size(input_num)) || remaining) {
+    if (input_num == model_inputs() - 1) {
+      model_invoke();
+      for (size_t i = 0; i < model_outputs(); i++) {
+        mlif_handle_result(model_output_ptr(i), model_output_size(i));
+      }
+      input_num = 0;
+      remaining = remaining > 0 ? remaining - 1 : 0;
+    } else {
+      input_num++;
+    }
+  }
+}

resources/platforms/zephyr/project/lib/ml_interface/ml_interface_tvm.c

@@ -0,0 +1,22 @@
+#include "ml_interface.h"
+#include "tvm_wrapper.h"
+
+void mlif_run() {
+  TVMWrap_Init();
+
+  size_t input_num = 0;
+  size_t remaining = NUM_RUNS;
+  // inout data will only be applied in the first run!
+  while (mlif_request_input(TVMWrap_GetInputPtr(input_num), TVMWrap_GetInputSize(input_num)) || remaining) {
+    if (input_num == TVMWrap_GetNumInputs() - 1) {
+      TVMWrap_Run();
+      for (size_t i = 0; i < TVMWrap_GetNumOutputs(); i++) {
+        mlif_handle_result(TVMWrap_GetOutputPtr(i), TVMWrap_GetOutputSize(i));
+      }
+      input_num = 0;
+      remaining = remaining > 0 ? remaining - 1 : 0;
+    } else {
+      input_num++;
+    }
+  }
+}

resources/platforms/zephyr/project/lib/support/CMakeLists.txt

@@ -0,0 +1,2 @@
+ADD_LIBRARY(support STATIC dummy.c)
+TARGET_INCLUDE_DIRECTORIES(support PUBLIC .)

resources/platforms/zephyr/project/lib/support/exit.h

@@ -0,0 +1,8 @@
+#ifndef SUPPORT_EXIT_H
+#define SUPPORT_EXIT_H
+
+#define EXIT_MLIF_BASE (0x10)
+#define EXIT_MLIF_INVALID_SIZE (EXIT_MLIF_BASE + 1)
+#define EXIT_MLIF_MISSMATCH (EXIT_MLIF_BASE + 2)
+
+#endif  // SUPPORT_EXIT_H

resources/platforms/zephyr/project/lib/support/printing.h

@@ -0,0 +1,11 @@
+#ifndef SUPPORT_PRINTING_H
+#define SUPPORT_PRINTING_H
+
+#ifdef _DEBUG
+#include <stdio.h>
+#define DBGPRINTF(format, ...) printf(format, ##__VA_ARGS__)
+#else
+#define DBGPRINTF(format, ...)
+#endif
+
+#endif

resources/platforms/zephyr/project/lib/support/quantize.h

@@ -0,0 +1,23 @@
+#ifndef SUPPORT_QUANTIZE_H
+#define SUPPORT_QUANTIZE_H
+
+#include <stdint.h>
+#include <limits.h>
+#include <math.h>
+
+inline float DequantizeInt8ToFloat(int8_t value, float scale, int zero_point) {
+  return static_cast<float>(value - zero_point) * scale;
+}
+
+inline int8_t QuantizeFloatToInt8(float value, float scale, int zero_point) {
+  int32_t result = round(value / scale) + zero_point;
+  if (result < INT8_MIN) {
+    result = INT8_MIN;
+  }
+  if (result > INT8_MAX) {
+    result = INT8_MAX;
+  }
+  return static_cast<int8_t>(result);
+}
+
+#endif