[RUNTIME][uTVM] AutoTVM + uTVM for Cortex-M7

CMakeLists.txt

@@ -304,12 +304,15 @@ include(cmake/modules/contrib/TFLite.cmake)
 include(cmake/modules/contrib/TF_TVMDSOOP.cmake)
 include(cmake/modules/contrib/CoreML.cmake)
 
+include(CheckCXXCompilerFlag)
 if(NOT MSVC)
-  include(CheckCXXCompilerFlag)
   check_cxx_compiler_flag("-std=c++14" SUPPORT_CXX14)
-  message(STATUS "Build with c++14")
   set(CMAKE_CXX_FLAGS "-std=c++14 ${CMAKE_CXX_FLAGS}")
   set(CMAKE_CUDA_STANDARD 14)
+else()
+  check_cxx_compiler_flag("/std:c++14" SUPPORT_CXX14)
+  set(CMAKE_CXX_FLAGS "/std:c++14 ${CMAKE_CXX_FLAGS}")
+  set(CMAKE_CUDA_STANDARD 14)
 endif()
 
 add_library(tvm SHARED ${COMPILER_SRCS} ${RUNTIME_SRCS})

Makefile

@@ -73,7 +73,8 @@ build/libtvm_web_runtime.js: build/libtvm_web_runtime.bc
 cpplint:
 	python3 3rdparty/dmlc-core/scripts/lint.py vta cpp vta/include vta/src
 	python3 3rdparty/dmlc-core/scripts/lint.py topi cpp topi/include;
-	python3 3rdparty/dmlc-core/scripts/lint.py tvm cpp include src \
+	python3 3rdparty/dmlc-core/scripts/lint.py tvm cpp \
+	 include src \
 	 examples/extension/src examples/graph_executor/src
 
 pylint:

include/tvm/tir/stmt.h

@@ -930,6 +930,8 @@ constexpr const char* loop_scope = "loop_scope";
 constexpr const char* reduce_scope = "reduce_scope";
 /*! \brief Mark region is guarded by the pragma extension */
 constexpr const char* pragma_scope_prefix = "pragma_";
+/*! \brief Import C source or file into the final code gen module */
+constexpr const char* pragma_import_c = "pragma_import_c";
 /*! \brief Import llvm source or file into the final code gen module */
 constexpr const char* pragma_import_llvm = "pragma_import_llvm";
 /*! \brief Try to modify the AST to support Tensor Core */

python/tvm/autotvm/measure/local_executor.py

@@ -145,6 +145,7 @@ def submit(self, func, *args, **kwargs):
         if not self.do_fork:
             return LocalFutureNoFork(func(*args, **kwargs))
 
+        # TODO why they choose a queue size of 2? add a comment
         queue = Queue(2)
         process = Process(target=call_with_timeout,
                           args=(queue, self.timeout, func, args, kwargs))

python/tvm/autotvm/measure/measure_methods.py

@@ -245,6 +245,8 @@ def get_build_kwargs(self):
 
             if 'cuda' in self.task.target.keys:
                 kwargs["cuda_arch"] = "sm_" + "".join(ctx.compute_version.split('.'))
+        if self.task.target.device_name == 'micro_dev':
+            kwargs.setdefault('build_option', {})['disable_vectorize'] = True
 
         return kwargs
 
@@ -273,8 +275,9 @@ def run(self, measure_inputs, build_results):
                 if isinstance(res, Exception):   # executor error or timeout
                     results.append(MeasureResult((str(res),), MeasureErrorNo.RUN_TIMEOUT,
                                                  self.timeout, time.time()))
-                else:
-                    results.append(res)
+                    raise Exception(f'encountered exception during measurement: {results}')
+
+                results.append(res)
 
         return results
 

python/tvm/autotvm/task/relay_integration.py

@@ -48,6 +48,7 @@ def _lower(mod,
                 grc = graph_runtime_codegen.GraphRuntimeCodegen(None, target)
                 grc.codegen(mod["main"])
                 return
+
     # default case
     # Try graph codegen first to extract autotvm tasks.
     # If failed to compile, then fallback to use VM compiler.

python/tvm/autotvm/tuner/callback.py

@@ -144,12 +144,12 @@ def __del__(self):
     def _callback(tuner, inputs, results):
         ctx.ct += len(inputs)
 
-        flops = 0
+        flops = float("inf")
         for inp, res in zip(inputs, results):
             if res.error_no == 0:
-                flops = inp.task.flop / np.mean(res.costs)
+                flops = min(inp.task.flop / np.mean(res.costs), flops)
 
-        if logger.level < logging.DEBUG:  # only print progress bar in non-debug mode
+        if logger.level > logging.DEBUG:  # only print progress bar in non-debug mode
             ctx.cur_flops = flops
             ctx.best_flops = tuner.best_flops
 

python/tvm/autotvm/tuner/ga_tuner.py

@@ -50,7 +50,11 @@ def __init__(self, task, pop_size=100, elite_num=3, mutation_prob=0.1):
 
         # space info
         self.space = task.config_space
-        self.dims = [len(x) for x in self.space.space_map.values()]
+        self.dim_keys = []
+        self.dims = []
+        for k, v in self.space.space_map.items():
+            self.dim_keys.append(k)
+            self.dims.append(len(v))
 
         self.visited = set([])
 
@@ -123,7 +127,7 @@ def update(self, inputs, results):
                 if len(self.visited) < len(self.space):
                     while knob2point(tmp_gene, self.dims) in self.visited:
                         j = np.random.randint(len(self.dims))
-                        tmp_gene[j] = np.random.randint(self.dims[j])
+                        tmp_gene[j] = np.random.randint(self.dims[j])  # pylint: disable=invalid-sequence-index
                     next_genes.append(tmp_gene)
                     self.visited.add(knob2point(tmp_gene, self.dims))
                 else:

python/tvm/autotvm/tuner/tuner.py

@@ -150,7 +150,15 @@ def tune(self, n_trial, measure_option, early_stopping=None, callbacks=(), si_pr
                              i + k + 1, si_prefix, format_si_prefix(flops, si_prefix),
                              format_si_prefix(self.best_flops, si_prefix), res, config)
 
-            i += len(results)
+            num_successes = 0
+            for result in results:
+                if isinstance(result.costs[0], float):
+                    num_successes += 1
+            if num_successes != len(results):
+                logger.debug('not counting %d failures towards trial count',
+                             len(results) - num_successes)
+            i += num_successes
+
             self.ttl = min(early_stopping + self.best_iter, n_trial) - i
 
             self.update(inputs, results)

python/tvm/contrib/binutil.py

@@ -21,7 +21,9 @@
 import tvm._ffi
 from . import util
 
+# TODO does this file still belong in `contrib`. is it too µTVM-specific?
 
+# TODO shouldn't need so many `ALIGN` directives
 RELOCATION_LD_SCRIPT_TEMPLATE = """
 /* linker symbol for use in UTVMInit */
 _utvm_stack_pointer_init = 0x{stack_pointer_init:x};
@@ -118,7 +120,7 @@ def tvm_callback_get_section_size(binary_path, section_name, toolchain_prefix):
         size of the section in bytes
     """
     if not os.path.isfile(binary_path):
-        raise RuntimeError("no such file \"{}\"".format(binary_path))
+        raise RuntimeError('no such file "{}"'.format(binary_path))
     # We use the "-A" flag here to get the ".rodata" section's size, which is
     # not included by default.
     size_output = run_cmd(["{}size".format(toolchain_prefix), "-A", binary_path])
@@ -160,6 +162,10 @@ def tvm_callback_get_section_size(binary_path, section_name, toolchain_prefix):
         # padding for most cases, but symbols can be arbitrarily large, so this
         # isn't bulletproof.
         return section_size + 32
+
+    # NOTE: in the past, section_size has been wrong on x86. it may be
+    # inconsistent. TODO: maybe stop relying on `*size` to give us the size and
+    # instead read the section with `*objcopy` and count the bytes.
     return section_size
 
 
@@ -206,11 +212,13 @@ def tvm_callback_relocate_binary(
     rel_bin : bytearray
         the relocated binary
     """
+    assert text_start < rodata_start < data_start < bss_start < stack_end
     stack_pointer_init = stack_end - word_size
     ld_script_contents = ""
     # TODO(weberlo): There should be a better way to configure this for different archs.
+    # TODO is this line even necessary?
     if "riscv" in toolchain_prefix:
-        ld_script_contents += "OUTPUT_ARCH( \"riscv\" )\n\n"
+        ld_script_contents += 'OUTPUT_ARCH( "riscv" )\n\n'
     ld_script_contents += RELOCATION_LD_SCRIPT_TEMPLATE.format(
         word_size=word_size,
         text_start=text_start,
@@ -221,16 +229,31 @@ def tvm_callback_relocate_binary(
 
     tmp_dir = util.tempdir()
     rel_obj_path = tmp_dir.relpath("relocated.obj")
-    rel_ld_script_path = tmp_dir.relpath("relocated.lds")
+    rel_ld_script_path = tmp_dir.relpath("relocate.lds")
     with open(rel_ld_script_path, "w") as f:
         f.write(ld_script_contents)
     run_cmd([
         "{}ld".format(toolchain_prefix),
         binary_path,
         "-T", rel_ld_script_path,
         "-o", rel_obj_path])
+
     with open(rel_obj_path, "rb") as f:
         rel_bin = bytearray(f.read())
+
+    gdb_init_dir = os.environ.get("MICRO_GDB_INIT_DIR")
+    if gdb_init_dir is not None:
+        gdb_init_path = f"{gdb_init_dir}/.gdbinit"
+        with open(gdb_init_path, "r") as f:
+            gdbinit_contents = f.read().split("\n")
+        new_contents = []
+        for line in gdbinit_contents:
+            new_contents.append(line)
+            if line.startswith("target"):
+                new_contents.append(f"add-symbol-file {rel_obj_path}")
+        with open(gdb_init_path, "w") as f:
+            f.write("\n".join(new_contents))
+
     return rel_bin
 
 

python/tvm/exec/rpc_server.py

@@ -20,6 +20,7 @@
 
 import argparse
 import ast
+import json
 import multiprocessing
 import sys
 import logging
@@ -41,7 +42,7 @@ def main(args):
         tracker_addr = (url, port)
         if not args.key:
             raise RuntimeError(
-                "Need key to present type of resource when tracker is available")
+                'Need key to present type of resource when tracker is available')
     else:
         tracker_addr = None
 
@@ -75,8 +76,8 @@ def init_utvm(args):
             dev_config = json.load(dev_conf_file)
     else:
         dev_config_args = ast.literal_eval(args.utvm_dev_config_args)
-        default_config_func = micro.device.get_device_funcs(args.utvm_dev_id)['default_config']
-        dev_config = default_config_func(*dev_config_args)
+        generate_config_func = micro.device.get_device_funcs(args.utvm_dev_id)['generate_config']
+        dev_config = generate_config_func(*dev_config_args)
 
     if args.utvm_dev_config or args.utvm_dev_id:
         # add MicroTVM overrides
@@ -100,27 +101,34 @@ def server_shutdown():
     parser.add_argument('--port-end', type=int, default=9199,
                         help='The end search port of the RPC')
     parser.add_argument('--tracker', type=str,
-                        help="The address of RPC tracker in host:port format. "
-                             "e.g. (10.77.1.234:9190)")
+                        help=('The address of RPC tracker in host:port format. '
+                              'e.g. (10.77.1.234:9190)'))
     parser.add_argument('--key', type=str, default="",
-                        help="The key used to identify the device type in tracker.")
+                        help='The key used to identify the device type in tracker.')
     parser.add_argument('--silent', action='store_true',
-                        help="Whether run in silent mode.")
+                        help='Whether run in silent mode.')
     parser.add_argument('--load-library', type=str,
-                        help="Additional library to load")
+                        help='Additional library to load')
     parser.add_argument('--no-fork', dest='fork', action='store_false',
-                        help="Use spawn mode to avoid fork. This option \
-                         is able to avoid potential fork problems with Metal, OpenCL \
-                         and ROCM compilers.")
+                        help=('Use spawn mode to avoid fork. This option '
+                              'is able to avoid potential fork problems with Metal, OpenCL '
+                              'and ROCM compilers.'))
     parser.add_argument('--custom-addr', type=str,
-                        help="Custom IP Address to Report to RPC Tracker")
+                        help='Custom IP Address to Report to RPC Tracker')
     parser.add_argument('--utvm-dev-config', type=str,
-                        help='JSON config file for the target device (if using MicroTVM)')
-    parser.add_argument('--utvm-dev-id', type=str,
-                        help='Unique ID for the target device (if using MicroTVM)')
+                        help=('JSON config file for the target device (if using MicroTVM). '
+                              'This file should contain serialized output similar to that returned '
+                              "from the device module's generate_config. Can't be specified when "
+                              '--utvm-dev-config-args is specified.'))
     parser.add_argument('--utvm-dev-config-args', type=str,
-                        help=('Python list of literals required to generate a default'
-                              ' MicroTVM config (if --utvm-dev-id is specified)'))
+                        help=("Arguments to the device module's generate_config function. "
+                              'Must be a python literal parseable by literal_eval. If specified, '
+                              "the device configuration is generated using the device module's "
+                              "generate_config. Can't be specified when --utvm-dev-config is "
+                              "specified."))
+    parser.add_argument('--utvm-dev-id', type=str,
+                        help=('Unique ID for the target device (if using MicroTVM). Should '
+                              'match the name of a module underneath tvm.micro.device).'))
 
     parser.set_defaults(fork=True)
     args = parser.parse_args()

python/tvm/micro/__init__.py

@@ -17,6 +17,7 @@
 """MicroTVM module for bare-metal backends"""
 
 from ..contrib import binutil
-from .base import Session, create_micro_mod, cross_compiler
-from .base import LibType, get_micro_host_driven_dir, get_micro_device_dir
+from .base import DEVICE_SECTIONS
+from .base import Session, create_micro_mod, cross_compiler, LibType
+from .base import get_micro_host_driven_dir, get_micro_device_dir
 from . import device