Cleanup and sync micro tvm prototype.

Makefile

@@ -73,7 +73,10 @@ 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 \
+	# Note: exclude src/runtime/micro/host_driven becuase it contains C99 files.
+	python3 3rdparty/dmlc-core/scripts/lint.py tvm cpp \
+	 --exclude_path=src/runtime/micro/host_driven \
+	 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/measure_methods.py

@@ -245,11 +245,12 @@ 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
 
     def run(self, measure_inputs, build_results):
-        print('[RPCRunner.run]')
         results = []
         remote_args = (self.key, self.host, self.port, self.priority, self.timeout)
 
@@ -274,10 +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()))
-                    #raise Exception(f'encountered exception during measurement: {results}')
-                else:
-                    print(f'  got a result: {res}')
-                    results.append(res)
+                    raise Exception(f'encountered exception during measurement: {results}')
+
+                results.append(res)
 
         return results
 
@@ -511,8 +511,7 @@ def run_through_rpc(measure_input, build_result,
             msg = msg[:msg.index("Stack trace returned")]
         if "CUDA Source" in msg:
             msg = msg[:msg.index("CUDA Source")]
-        #costs = (RuntimeError(msg[:1024]),)
-        costs = (RuntimeError(msg),)
+        costs = (RuntimeError(msg[:1024]),)
         errno = MeasureErrorNo.RUNTIME_DEVICE
     tstamp = time.time()
     time.sleep(cooldown_interval)

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/task/space.py

@@ -544,10 +544,8 @@ def apply(self, sch, op, axes, axis_lens=None,
                 if ann == 'none':
                     pass
                 elif ann == 'unroll':
-                    #if max_unroll and axis_lens[i] > max_unroll:
-                    #    cfg.raise_error("Too large factor for unrolling")
-                    #if max_unroll and axis_lens[i] < max_unroll:
-                    #    cfg.raise_error("Too large factor for unrolling")
+                    if max_unroll and axis_lens[i] > max_unroll:
+                        cfg.raise_error("Too large factor for unrolling")
                     sch[op].unroll(axes[i])
                 elif ann == 'vec':
                     if vec_size and axis_lens[i] not in vec_size:

python/tvm/autotvm/tuner/callback.py

@@ -149,7 +149,7 @@ def _callback(tuner, inputs, results):
             if res.error_no == 0:
                 flops = inp.task.flop / np.mean(res.costs)
 
-        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/model_based_tuner.py

@@ -263,7 +263,6 @@ def update(self, inputs, results):
         # if we have enough new training samples
         if len(self.xs) >= self.plan_size * (self.train_ct + 1) \
                 and self.flops_max > 1e-6:
-            import pdb; pdb.set_trace()
             self.cost_model.fit(self.xs, self.ys, self.plan_size)
             if self.diversity_filter_ratio:
                 candidate = self.model_optimizer.find_maximums(

python/tvm/autotvm/tuner/tuner.py

@@ -150,13 +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)
 
+            num_successes = 0
             for result in results:
                 if isinstance(result.costs[0], float):
-                    i += 1
-                else:
-                    print('[Tuner.tune]')
-                    print('  not counting failure towards trial count')
-            #i += len(results)
+                    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

@@ -72,80 +72,6 @@
 }}
 """
 
-def run_cmd(cmd):
-    """Runs `cmd` in a subprocess and awaits its completion.
-
-    Parameters
-    ----------
-    cmd : List[str]
-        list of command-line arguments
-
-    Returns
-    -------
-    output : str
-        resulting stdout capture from the subprocess
-    """
-    proc = subprocess.Popen(
-        cmd,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT)
-    (output, _) = proc.communicate()
-    output = output.decode('utf-8')
-    if proc.returncode != 0:
-        cmd_str = ' '.join(cmd)
-        msg = f'error while running command \"{cmd_str}\":\n{output}'
-        raise RuntimeError(msg)
-    return output
-
-
-RELOCATION_LD_SCRIPT_TEMPLATE = """
-/* linker symbol for use in UTVMInit */
-_utvm_stack_pointer_init = 0x{stack_pointer_init:x};
-
-SECTIONS
-{{
-  . = 0x{text_start:x};
-  . = ALIGN({word_size});
-  .text :
-  {{
-    . = ALIGN({word_size});
-    KEEP(*(.text))
-    KEEP(*(.text*))
-    . = ALIGN({word_size});
-  }}
-
-  . = 0x{rodata_start:x};
-  . = ALIGN({word_size});
-  .rodata :
-  {{
-    . = ALIGN({word_size});
-    KEEP(*(.rodata))
-    KEEP(*(.rodata*))
-    . = ALIGN({word_size});
-  }}
-
-  . = 0x{data_start:x};
-  . = ALIGN({word_size});
-  .data :
-  {{
-    . = ALIGN({word_size});
-    KEEP(*(.data))
-    KEEP(*(.data*))
-    . = ALIGN({word_size});
-  }}
-
-  . = 0x{bss_start:x};
-  . = ALIGN({word_size});
-  .bss :
-  {{
-    . = ALIGN({word_size});
-    KEEP(*(.bss))
-    KEEP(*(.bss*))
-    . = ALIGN({word_size});
-  }}
-}}
-"""
-
 def run_cmd(cmd):
     """Runs `cmd` in a subprocess and awaits its completion.
 
@@ -236,11 +162,11 @@ 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
-    # TODO remove this arbitrary addition once we figure out why section sizes
-    # are being undercalculated.
-    # maybe stop relying on `*size` to give us the size and instead read the
-    # section with `*objcopy` and count the bytes.
-    return section_size + 8
+
+    # 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
 
 
 @tvm._ffi.register_func("tvm_callback_relocate_binary")
@@ -315,17 +241,18 @@ def tvm_callback_relocate_binary(
     with open(rel_obj_path, 'rb') as f:
         rel_bin = bytearray(f.read())
 
-    gdb_init_dir = os.environ['MICRO_GDB_INIT_DIR']
-    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))
+    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

@@ -122,9 +122,10 @@ def server_shutdown():
                               '--utvm-dev-config-args is specified.'))
     parser.add_argument('--utvm-dev-config-args', type=str,
                         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."))
+                              '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).'))