uTVM interfaces (apache#14)

CMakeLists.txt

@@ -36,6 +36,7 @@ tvm_option(USE_RELAY_DEBUG "Building Relay in debug mode..." OFF)
 tvm_option(USE_SGX "Build with SGX" OFF)
 tvm_option(USE_RTTI "Build with RTTI" ON)
 tvm_option(USE_MSVC_MT "Build with MT" OFF)
+tvm_option(USE_MICRO "Build with Micro" OFF)
 tvm_option(INSTALL_DEV "Install compiler infrastructure" OFF)
 tvm_option(HIDE_PRIVATE_SYMBOLS "Compile with -fvisibility=hidden." OFF)
 
@@ -207,6 +208,7 @@ include(cmake/modules/Metal.cmake)
 include(cmake/modules/ROCM.cmake)
 include(cmake/modules/SGX.cmake)
 include(cmake/modules/LLVM.cmake)
+include(cmake/modules/Micro.cmake)
 include(cmake/modules/ANTLR.cmake)
 include(cmake/modules/contrib/BLAS.cmake)
 include(cmake/modules/contrib/Random.cmake)

cmake/config.cmake

@@ -62,6 +62,9 @@ set(USE_VULKAN OFF)
 # Whether enable OpenGL runtime
 set(USE_OPENGL OFF)
 
+# Whether enable Micro runtime
+set(USE_MICRO OFF)
+
 # Whether to enable SGX runtime
 #
 # Possible values for USE_SGX:

cmake/modules/Micro.cmake

@@ -0,0 +1,5 @@
+if(USE_MICRO)
+ message(STATUS "Build with Micro support")
+ file(GLOB RUNTIME_MICRO_SRCS src/runtime/micro/*.cc)
+ list(APPEND RUNTIME_SRCS ${RUNTIME_MICRO_SRCS})
+endif(USE_MICRO)

include/tvm/runtime/c_runtime_api.h

@@ -81,6 +81,7 @@ typedef enum {
  kDLAOCL = 5,
  kDLSDAccel = 6,
  kOpenGL = 11,
+ kDLMicroDev = 13,
  // AddExtraTVMType which is not in DLPack here
 } TVMDeviceExtType;
 

python/tvm/_ffi/runtime_ctypes.py

@@ -143,6 +143,7 @@ class TVMContext(ctypes.Structure):
  10: 'rocm',
  11: 'opengl',
  12: 'ext_dev',
+ 13: 'micro_dev',
  }
  STR2MASK = {
  'llvm': 1,
@@ -163,6 +164,7 @@ class TVMContext(ctypes.Structure):
  'rocm': 10,
  'opengl': 11,
  'ext_dev': 12,
+ 'micro_dev': 13,
  }
  def __init__(self, device_type, device_id):
  super(TVMContext, self).__init__()

src/runtime/micro/allocator_stream.h

@@ -0,0 +1,108 @@
+/*!
+ * Copyright (c) 2019 by Contributors
+ * \file allocator_stream.h
+ * \brief allocator stream utility
+ */
+#ifndef TVM_RUNTIME_MICRO_ALLOCATOR_STREAM_H_
+#define TVM_RUNTIME_MICRO_ALLOCATOR_STREAM_H_
+
+#include <cstring>
+#include <string>
+#include <algorithm>
+#include <vector>
+#include <dmlc/memory_io.h>
+
+namespace tvm {
+namespace runtime {
+/*!
+ * \brief allocation-based stream with bounded buffer size for uTVM args allocation
+ * \note based on dmlc::MemoryStringStream
+ */
+struct AllocatorStream : public dmlc::SeekStream {
+ public:
+ /*!
+ * \brief constructor
+ * \param p_buffer the pointer to the string.
+ */
+ explicit AllocatorStream(std::string *p_buffer)
+ : p_buffer_(p_buffer) {
+ curr_ptr_ = 0;
+ max_ptr_ = 0;
+ }
+
+ /*!
+ * \brief reads size bytes of data starting at ptr
+ * \param ptr address to begin read
+ * \param size number of bytes to be read
+ * \return number of bytes read
+ */
+ size_t Read(void *ptr, size_t size) {
+ CHECK(curr_ptr_ <= p_buffer_->length());
+ CHECK(curr_ptr_ + size <= max_ptr_);
+ size_t nread = std::min(p_buffer_->length() - curr_ptr_, size);
+ if (nread != 0) std::memcpy(ptr, &(*p_buffer_)[0] + curr_ptr_, nread);
+ curr_ptr_ += nread;
+ return nread;
+ }
+
+ /*!
+ * \brief writes size bytes of data starting at ptr
+ * \param ptr address of the buffer to be written
+ * \param size number of bytes to be written
+ */
+ void Write(const void *ptr, size_t size) {
+ if (size == 0) return;
+ CHECK(curr_ptr_ + size <= max_ptr_);
+ if (curr_ptr_ + size > p_buffer_->length()) {
+ p_buffer_->resize(curr_ptr_+size);
+ }
+ std::memcpy(&(*p_buffer_)[0] + curr_ptr_, ptr, size);
+ curr_ptr_ += size;
+ }
+
+ /*!
+ * \brief seek to specified location within internal buffer
+ * \param pos seek position from start in bytes
+ */
+ void Seek(size_t pos) {
+ curr_ptr_ = static_cast<size_t>(pos);
+ }
+
+ /*!
+ * \brief get seek pointer location
+ * \return current seek pointer location from start in bytes
+ */
+ size_t Tell(void) {
+ return curr_ptr_;
+ }
+
+ /*!
+ * \brief allocates an empty region within the stream buffer
+ * \param size size of the allocated region
+ * \return offset bytes of the allocated region from start of the buffer
+ */
+ size_t Allocate(size_t size) {
+ size_t ret = max_ptr_;
+ max_ptr_ += size;
+ return ret;
+ }
+
+ /*!
+ * \brief returns current size of the stream buffer
+ * \return buffer size
+ */
+ size_t GetBufferSize() {
+ return max_ptr_;
+ }
+
+ private:
+ /*! \brief in memory buffer */
+ std::string *p_buffer_;
+ /*! \brief current pointer */
+ size_t curr_ptr_;
+ /*! \brief maximum pointer */
+ size_t max_ptr_;
+};
+} // namespace runtime
+} // namespace tvm
+#endif // TVM_RUNTIME_MICRO_ALLOCATOR_STREAM_H_

src/runtime/micro/device/utvm_runtime.cc

@@ -0,0 +1,20 @@
+/*!
+ * Copyright (c) 2019 by Contributors
+ * \file utvm_runtime.cc
+ * \brief micro device init stub
+ */
+#include "utvm_runtime.h"
+
+// task pointers must be patched before calling a function
+UTVMTask task;
+
+// dummy function to signal execution is finished
+void UTVMDone() {}
+
+// init stub
+int UTVMMain()
+{
+ task.func(task.args, task.arg_type_ids, *task.num_args);
+ UTVMDone();
+ return 0;
+}

src/runtime/micro/device/utvm_runtime.h

@@ -0,0 +1,27 @@
+/*!
+ * Copyright (c) 2019 by Contributors
+ * \file utvm_runtime.h
+ * \brief utvm runtime headers
+ */
+#ifndef UTVM_RUNTIME_H_
+#define UTVM_RUNTIME_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include <stdint.h>
+
+/*!
+ * \brief task structure for uTVM
+ */
+typedef struct {
+ int (*func)(void*, void*, int32_t);
+ void* args;
+ void* arg_type_ids;
+ int32_t* num_args;
+} UTVMTask;
+
+#ifdef __cplusplus
+} // TVM_EXTERN_C
+#endif
+#endif // UTVM_RUNTIME_H_

src/runtime/micro/host_low_level_device.cc

@@ -0,0 +1,50 @@
+/*!
+ * Copyright (c) 2019 by Contributors
+ * \file host_low_level_device.cc
+ * \brief emulated low-level micro device implementation on host machine
+ */
+
+#include "low_level_device.h"
+
+namespace tvm {
+namespace runtime {
+/*!
+ * \brief emulated low-level device on host machine
+ */
+class HostLowLevelDevice final : public LowLevelDevice {
+ public:
+ /*!
+ * \brief constructor to initialize on-host memory region to act as device
+ * \param num_bytes size of the emulated on-device memory region
+ */
+ HostLowLevelDevice(size_t num_bytes);
+
+ /*!
+ * \brief destructor to deallocate on-host device region
+ */
+ ~HostLowLevelDevice();
+
+ void Write(void* offset,
+ void* buf,
+ size_t num_bytes) final;
+
+ void Read(void* offset,
+ void* buf,
+ size_t num_bytes) final;
+
+ void Execute(void* func_addr, void* breakpoint) final;
+
+ const void* base_addr() const final;
+
+ private:
+ /*! \brief base address of the micro device memory region */
+ void* base_addr_;
+ /*! \brief size of memory region */
+ size_t size_;
+};
+
+const std::shared_ptr<LowLevelDevice> HostLowLevelDeviceCreate(size_t num_bytes) {
+ return nullptr;
+}
+} // namespace runtime
+} // namespace tvm

src/runtime/micro/low_level_device.h

@@ -0,0 +1,69 @@
+/*!
+ * Copyright (c) 2019 by Contributors
+ * \file low_level_device.h
+ * \brief Abstract low-level micro device management
+ */
+#ifndef TVM_RUNTIME_LOW_LEVEL_DEVICE_H_
+#define TVM_RUNTIME_LOW_LEVEL_DEVICE_H_
+
+#include <cstddef>
+#include <memory>
+
+namespace tvm {
+namespace runtime {
+/*!
+ * \brief virtual interface for low-level micro device management
+ */
+class LowLevelDevice {
+ public:
+ /*! \brief virtual destructor */
+ virtual ~LowLevelDevice() {}
+
+ /*!
+ * \brief writes num_bytes from buffer to device memory at base_addr + offset
+ * \param offset on-device memory offset pointer to be written to
+ * \param buffer on-host buffer to be written
+ * \param num_bytes number of bytes to be written
+ */
+ virtual void Write(void* offset,
+ void* buffer,
+ size_t num_bytes) = 0;
+
+ /*!
+ * \brief reads num_bytes from device memory at base_addr + offset into buffer
+ * \param offset on-device memory offset pointer to be read from
+ * \param buffer on-host buffer to be read into
+ * \param num_bytes number of bytes to be read
+ */
+ virtual void Read(void* offset,
+ void* buffer,
+ size_t num_bytes) = 0;
+
+ /*!
+ * \brief starts execution of device at offset
+ * \param func_addr address of the init stub function
+ * \param breakpoint breakpoint at which to stop function execution
+ */
+ virtual void Execute(void* func_addr, void* breakpoint) = 0;
+
+ /*!
+ * \brief getter function for base_addr
+ * \return the base address of the device memory region
+ */
+ virtual const void* base_addr() const = 0;
+};
+
+/*!
+ * \brief create a host low-level device
+ * \param num_bytes size of the memory region
+ */
+const std::shared_ptr<LowLevelDevice> HostLowLevelDeviceCreate(size_t num_bytes);
+
+/*!
+ * \brief connect to OpenOCD and create an OpenOCD low-level device
+ * \param port port of the OpenOCD server to connect to
+ */
+const std::shared_ptr<LowLevelDevice> OpenOCDLowLevelDeviceCreate(int port);
+} // namespace runtime
+} // namespace tvm
+#endif // TVM_RUNTIME_LOW_LEVEL_DEVICE_H_

src/runtime/micro/micro_common.cc

@@ -0,0 +1,53 @@
+/*!
+ * Copyright (c) 2019 by Contributors
+ * \file bin_util.cc
+ * \brief binary modification utilities
+ */
+
+#include <stdio.h>
+#include <string>
+#include "micro_session.h"
+#include "micro_common.h"
+
+namespace tvm {
+namespace runtime {
+
+const char* SectionToString(SectionKind section) {
+ switch (section) {
+ case kText: return "text";
+ case kData: return "data";
+ case kBss: return "bss";
+ case kArgs: return "args";
+ case kStack: return "stack";
+ case kHeap: return "heap";
+ case kWorkspace: return "workspace";
+ }
+}
+
+// TODO: implement these in Python using PackedFunc + Registry
+void* GetSymbol(std::unordered_map<std::string, void*> symbol_map,
+ std::string name,
+ void* base_addr) {
+ return nullptr;
+}
+
+std::string RelocateBinarySections(std::string binary_name,
+ void* text,
+ void* data,
+ void* bss) {
+ return "";
+}
+
+std::string ReadSection(std::string binary_name, Section section) {
+ return "";
+}
+
+size_t GetSectionSize(std::string binary_name, Section section) {
+ return 0;
+}
+
+std::unordered_map<std::string, void*> GetSymbolMap(std::string binary) {
+ return nullptr;
+}
+} // namespace runtime
+} // namespace tvm