Merge branch 'develop' into perk-kernel

test/simplify_reshapes_test.cpp

@@ -1141,6 +1141,38 @@ TEST_CASE(transpose_contiguous_reshape_binary_broadcast)
     EXPECT(m1 == m2);
 }
 
+TEST_CASE(transpose_unsqueeze_concat)
+{
+    migraphx::module m1;
+    {
+        auto l0 = m1.add_parameter("0", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
+        auto lt0 =
+            m1.add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), l0);
+        auto l1 = m1.add_parameter("1", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
+        auto lt1 =
+            m1.add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), l1);
+        auto l2 = m1.add_parameter("2", migraphx::shape{migraphx::shape::float_type, {1, 2, 1, 1}});
+        auto lt2 =
+            m1.add_instruction(migraphx::make_op("transpose", {{"permutation", {0, 2, 3, 1}}}), l2);
+        std::vector<migraphx::instruction_ref> args{lt0, lt1, lt2};
+        std::vector<migraphx::instruction_ref> unsqueezed_args;
+        int64_t axis = 3;
+
+        std::transform(
+            args.begin(),
+            args.end(),
+            std::back_inserter(unsqueezed_args),
+            [&](migraphx::instruction_ref arg) {
+                return m1.add_instruction(migraphx::make_op("unsqueeze", {{"axes", {axis}}}), arg);
+            });
+        m1.add_instruction(migraphx::make_op("concat", {{"axis", axis}}), unsqueezed_args);
+    }
+    // TODO: This could be simplified to a single transpose after concat
+    migraphx::module m2 = m1;
+    run_pass(m1);
+    EXPECT(m1 == m2);
+}
+
 TEST_CASE(transpose_slice)
 {
     migraphx::module m1;

test/sqlite.cpp

+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+#include <migraphx/sqlite.hpp>
+#include <migraphx/tmp_dir.hpp>
+#include <test.hpp>
+
+TEST_CASE(read_write)
+{
+    const std::string create_table = R"__migraphx__(
+    CREATE TABLE IF NOT EXISTS test_db (
+    id INTEGER PRIMARY KEY ASC,
+    data TEXT NOT NULL
+    );
+    INSERT INTO test_db (id, data) VALUES (1, "a");
+    )__migraphx__";
+
+    const std::string select_all = R"__migraphx__(
+    SELECT * FROM test_db;
+    )__migraphx__";
+
+    migraphx::tmp_dir td{};
+    auto db_path = td.path / "test.db";
+    {
+        auto db = migraphx::sqlite::write(db_path);
+        db.execute(create_table);
+    }
+    {
+        auto db   = migraphx::sqlite::read(db_path);
+        auto rows = db.execute(select_all);
+        EXPECT(rows.size() == 1);
+        auto row = rows.front();
+        EXPECT(row.at("data") == "a");
+        EXPECT(row.at("id") == "1");
+    }
+}
+
+int main(int argc, const char* argv[]) { test::run(argc, argv); }

test/verify/run_verify.cpp

@@ -168,7 +168,8 @@ void run_verify::verify(const std::string& name, const migraphx::program& p) con
     std::vector<std::string> target_names;
     for(const auto& tname : migraphx::get_targets())
     {
-        if(tname == "ref")
+        // TODO(varunsh): once verify tests can run, remove fpga
+        if(tname == "ref" || tname == "fpga")
             continue;
 
         // if tests disabled, skip running it

tools/accuracy/README.md

+# AMD MIGraphX Accuracy checker
+## Instructions
+First ensure requirements and MIGraphX's python library are installed. Refer to MIGraphX instructions at the root directory to install the python library.
+Use the command below to install remaining dependencies:
+```
+pip install -r requirements.txt
+```
+The accuracy checker will compare outputs from MIGraphX and onnx runtime. Therefore, an onnx file is required argument.
+Example usage is below:
+```
+python accuracy_checker.py --onnx [path to onnx_file]
+```
+
+The output of the checker will either report as `PASSED` or `FAILED`. For detailed information,
+the `--verbose` flag can be passed in to the command line which shows the mismatched elements between MIGraphX and onnx runtime.
+
+By default, the tolerance is set to `1e-3`, but this can be changed by passing in `--tolerance [tolerance]`.
+If the tolerance value is increased, then less accurate results from MIGraphX will be accepted.
+
+For models that support variable batch sizes, use `--batch [batch_size]` to modify the batch size.
+
+Random values are assigned to the model's inputs. However, they can be set to only contain 1s if the `--fill1` flag is passed in.
+This is useful for verifying models such as bert which use integer datatypes.
+
+By default, the CPU Execution Provider is used when running onnx runtime. If building onnx runtime with a different version, specify the provider using `--provider`.

tools/accuracy/accuracy_checker.py

+#####################################################################################
+# The MIT License (MIT)
+#
+# Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#####################################################################################
+import argparse
+import numpy as np
+import migraphx
+import onnxruntime as ort
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description=
+        'MIGraphX accuracy checker. Use to verify onnx files to ensure MIGraphX\'s output \
+                                                  is within tolerance of onnx runtime\'s expected output.'
+    )
+    req_args = parser.add_argument_group(title='required arguments')
+    req_args.add_argument('--onnx',
+                          type=str,
+                          required=True,
+                          help='path to onnx file')
+    req_args.add_argument('--provider',
+                          type=str,
+                          default='CPUExecutionProvider',
+                          help='execution provider for onnx runtime \
+                                (default = CPUExecutionProvider)')
+    parser.add_argument('--batch',
+                        type=int,
+                        default=1,
+                        help='batch size (if specified in onnx file)')
+    parser.add_argument('--fill1',
+                        action='store_true',
+                        help='fill all arguments with a value of 1')
+    parser.add_argument('--verbose',
+                        action='store_true',
+                        help='show verbose information (for debugging)')
+    parser.add_argument('--tolerance',
+                        type=float,
+                        default=1e-3,
+                        help='accuracy tolerance (default = 1e-3)')
+    args = parser.parse_args()
+
+    return args
+
+
+# taken from ../test_runner.py
+def check_correctness(gold_outputs,
+                      outputs,
+                      rtol=1e-3,
+                      atol=1e-3,
+                      verbose=False):
+    if len(gold_outputs) != len(outputs):
+        print('Number of outputs {} is not equal to expected number {}'.format(
+            len(outputs), len(gold_outputs)))
+        return False
+
+    out_num = len(gold_outputs)
+    ret = True
+    for i in range(out_num):
+        if not np.allclose(gold_outputs[i], outputs[i], rtol, atol):
+            ret = False
+            if verbose:
+                print('\nOutput {} is incorrect ...'.format(i))
+                print('Expected value: \n{}'.format(gold_outputs[i]))
+                print('......')
+                print('Actual value: \n{}\n'.format(outputs[i]))
+            else:
+                print('Outputs do not match')
+                break
+
+    return ret
+
+
+def get_np_datatype(in_type):
+    datatypes = {
+        'double_type': np.float64,
+        'float_type': np.float32,
+        'half_type': np.half,
+        'int64_type': np.int64,
+        'uint64_type': np.uint64,
+        'int32_type': np.int32,
+        'uint32_type': np.uint32,
+        'int16_type': np.int16,
+        'uint16_type': np.uint16,
+        'int8_type': np.int8,
+        'uint8_type': np.uint8,
+        'bool_type': np.bool_
+    }
+    return datatypes[in_type]
+
+
+def main():
+    args = parse_args()
+
+    model_name = args.onnx
+    batch = args.batch
+
+    model = migraphx.parse_onnx(model_name, default_dim_value=batch)
+
+    model.compile(migraphx.get_target('gpu'), offload_copy=False)
+
+    params = {}
+    test_inputs = {}
+    for name, shape in model.get_parameter_shapes().items():
+        if args.verbose:
+            print('Parameter {} -> {}'.format(name, shape))
+        in_shape = shape.lens()
+        in_type = shape.type_string()
+        if not args.fill1:
+            test_input = np.random.rand(*(in_shape)).astype(
+                get_np_datatype(in_type))
+        else:
+            test_input = np.ones(in_shape).astype(get_np_datatype(in_type))
+        test_inputs[name] = test_input
+        params[name] = migraphx.to_gpu(migraphx.argument(test_input))
+
+    pred_migx = np.array(migraphx.from_gpu(model.run(params)[-1]))
+
+    sess = ort.InferenceSession(model_name, providers=[args.provider])
+
+    ort_params = {}
+    for input in sess.get_inputs():
+        ort_params[input.name] = test_inputs[input.name]
+
+    pred_ort = sess.run(None, ort_params)[-1]
+
+    is_correct = check_correctness(pred_ort, pred_migx, args.tolerance,
+                                   args.tolerance, args.verbose)
+    verbose_string = ' Rerun with --verbose for detailed information.' \
+            if not args.verbose else ''
+    if is_correct:
+        print('PASSED: MIGraphX meets tolerance')
+    else:
+        print('FAILED: MIGraphX is not within tolerance.' + verbose_string)
+
+
+if __name__ == '__main__':
+    main()

tools/accuracy/requirements.txt

+#####################################################################################
+# The MIT License (MIT)
+#
+# Copyright (c) 2015-2022 Advanced Micro Devices, Inc. All rights reserved.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+#####################################################################################
+numpy==1.18.5
+onnxruntime==1.10.0

tools/api.py

@@ -197,7 +197,8 @@ class Parameter:
                  optional: bool = False,
                  returns: bool = False,
                  virtual: bool = False,
-                 this: bool = False) -> None:
+                 this: bool = False,
+                 hidden: bool = False) -> None:
         self.name = name
         self.type = Type(type)
         self.optional = optional
@@ -211,6 +212,7 @@ class Parameter:
         self.returns = returns
         self.virtual = virtual
         self.this = this
+        self.hidden = hidden
         self.bad_param_check: Optional[BadParam] = None
         self.virtual_read: Optional[List[str]] = None
         self.virtual_write: Optional[str] = None
@@ -744,6 +746,8 @@ void destroy(T* x)
 {
     delete x; // NOLINT
 }
+
+
 // TODO: Move to interface preamble
 template <class C, class D>
 struct manage_generic_ptr
@@ -754,23 +758,24 @@ struct manage_generic_ptr
     {
     }
 
-    manage_generic_ptr(void* pdata, C pcopier, D pdeleter)
-        : data(nullptr), copier(pcopier), deleter(pdeleter)
+    manage_generic_ptr(void* pdata, const char* obj_tname, C pcopier, D pdeleter)
+        : data(nullptr), obj_typename(obj_tname), copier(pcopier), deleter(pdeleter)
     {
         copier(&data, pdata);
     }
 
     manage_generic_ptr(const manage_generic_ptr& rhs)
-        : data(nullptr), copier(rhs.copier), deleter(rhs.deleter)
+        : data(nullptr), obj_typename(rhs.obj_typename), copier(rhs.copier), deleter(rhs.deleter)
     {
         if(copier)
             copier(&data, rhs.data);
     }
 
     manage_generic_ptr(manage_generic_ptr&& other) noexcept
-        : data(other.data), copier(other.copier), deleter(other.deleter)
+        : data(other.data), obj_typename(other.obj_typename), copier(other.copier), deleter(other.deleter)
     {
         other.data    = nullptr;
+        other.obj_typename = "";
         other.copier  = nullptr;
         other.deleter = nullptr;
     }
@@ -778,6 +783,7 @@ struct manage_generic_ptr
     manage_generic_ptr& operator=(manage_generic_ptr rhs)
     {
         std::swap(data, rhs.data);
+        std::swap(obj_typename, rhs.obj_typename);
         std::swap(copier, rhs.copier);
         std::swap(deleter, rhs.deleter);
         return *this;
@@ -790,6 +796,7 @@ struct manage_generic_ptr
     }
 
     void* data = nullptr;
+    const char* obj_typename = "";
     C copier   = nullptr;
     D deleter  = nullptr;
 };
@@ -1042,8 +1049,8 @@ interface_handle_definition = Template('''
 extern "C" struct ${ctype};
 struct ${ctype} {
     template<class... Ts>
-    ${ctype}(void* p, ${copier} c, ${deleter} d, Ts&&... xs)
-    : object_ptr(p, c, d), xobject(std::forward<Ts>(xs)...)
+    ${ctype}(void* p, ${copier} c, ${deleter} d,  const char* obj_typename, Ts&&... xs)
+    : object_ptr(p, obj_typename, c, d), xobject(std::forward<Ts>(xs)...)
     {}
     manage_generic_ptr<${copier}, ${deleter}> object_ptr = nullptr;
     ${cpptype} xobject;
@@ -1057,9 +1064,13 @@ ${return_type} ${name}(${params}) const
     ${output_decls}
     if (${fname} == nullptr)
         throw std::runtime_error("${name} function is missing.");
+    std::array<char, 256> exception_msg;
+    exception_msg.front() = '\\0';
     auto api_error_result = ${fname}(${args});
-    if (api_error_result != ${success})
-        throw std::runtime_error("Error in ${name}.");
+    if (api_error_result != ${success}) {
+        const std::string exception_str(exception_msg.data()); 
+        throw std::runtime_error("Error in ${name} of: " + std::string(object_ptr.obj_typename) + ": " + exception_str);
+    }
     return ${output};
 }
 ''')
@@ -1079,7 +1090,9 @@ def generate_virtual_impl(f: Function, fname: str) -> str:
         largs += f.returns.virtual_output_args()
         output = f.returns.virtual_output()
     largs += [arg for p in f.params for arg in p.virtual_arg()]
-    lparams += [p.virtual_param() for p in f.params if not p.this]
+    lparams += [
+        p.virtual_param() for p in f.params if not (p.this or p.hidden)
+    ]
     args = ', '.join(largs)
     params = ', '.join(lparams)
     return c_api_virtual_impl.substitute(locals())
@@ -1126,8 +1139,15 @@ class Interface(Handle):
         # Add this parameter to the function
         this = Parameter('obj', 'void*', this=True)
         this.virtual_read = ['object_ptr.data']
+        exception_msg = Parameter('exception_msg', 'char*', hidden=True)
+        exception_msg.virtual_read = ['${name}.data()']
+        exception_msg_size = Parameter('exception_msg_size',
+                                       'size_t',
+                                       hidden=True)
+        exception_msg_size.virtual_read = ['exception_msg.size()']
         f = Function(name,
-                     params=[this] + (params or []),
+                     params=[this, exception_msg, exception_msg_size] +
+                     (params or []),
                      virtual=True,
                      **kwargs)
         self.ifunctions.append(f)

tools/api/api.cpp

@@ -39,34 +39,47 @@
 #include <migraphx/convert_to_json.hpp>
 #include <algorithm>
 #include <cstdarg>
-
 namespace migraphx {
 
+static thread_local bool disable_exception_catch = false; // NOLINT
+
+extern "C" void migraphx_test_private_disable_exception_catch(bool b)
+{
+    disable_exception_catch = b;
+}
+
 template <class F>
 migraphx_status try_(F f, bool output = true) // NOLINT
 {
-    try
+    if(disable_exception_catch)
     {
         f();
     }
-    catch(const migraphx::exception& ex)
+    else
     {
-        if(output)
-            std::cerr << "MIGraphX Error: " << ex.what() << std::endl;
-        if(ex.error > 0)
-            return migraphx_status(ex.error);
-        else
+        try
+        {
+            f();
+        }
+        catch(const migraphx::exception& ex)
+        {
+            if(output)
+                std::cerr << "MIGraphX Error: " << ex.what() << std::endl;
+            if(ex.error > 0)
+                return migraphx_status(ex.error);
+            else
+                return migraphx_status_unknown_error;
+        }
+        catch(const std::exception& ex)
+        {
+            if(output)
+                std::cerr << "MIGraphX Error: " << ex.what() << std::endl;
             return migraphx_status_unknown_error;
-    }
-    catch(const std::exception& ex)
-    {
-        if(output)
-            std::cerr << "MIGraphX Error: " << ex.what() << std::endl;
-        return migraphx_status_unknown_error;
-    }
-    catch(...)
-    {
-        return migraphx_status_unknown_error;
+        }
+        catch(...)
+        {
+            return migraphx_status_unknown_error;
+        }
     }
     return migraphx_status_success;
 }

tools/api/migraphx.h

@@ -25,6 +25,7 @@
 #define MIGRAPHX_GUARD_C_API_MIGRAPHX_H
 
 #include <stdlib.h>
+#include <stdbool.h>
 
 // Add new types here
 // clang-format off

tools/include/operation.hpp

@@ -68,8 +68,10 @@ struct operation
      *
      * @param ctx This is the context created by the `target` during compilation. Implementations
      * can use the target's `context` class rather than the `context` interface class.
-     * @param output This is the output shape. It is equivalent to running `compute_shape` with each
-     * `shape` of the `argument`.
+     * @param output Equivalent to running `compute_shape` with each `shape` of the `argument`.
+     * For a fixed shape, the returned argument will have the same shape as `output`.
+     * For a dynamic shape, the returned `argument` will be a fixed shape within the bounds
+     * set in the dynamic shape `output`.
      * @param input This is the `argument` result from the previous instruction's computation.
      * @return Return an `argument` of the result computation. The `shape` of `argument` should be
      * the same the `output` shape.
@@ -137,7 +139,7 @@ auto compute_shape_op(rank<2>, const T& x, const std::vector<shape>& inputs)
     -> decltype(x.normalize_compute_shape(inputs))
 {
     dependent_type<operation, T> y = x;
-    normalize_attributes(y, inputs[0].lens());
+    normalize_attributes(y, inputs[0].max_lens());
     return any_cast<T>(y).normalize_compute_shape(inputs);
 }
 

tools/include/target.hpp

@@ -37,6 +37,8 @@
 #include <migraphx/compile_options.hpp>
 #include <migraphx/argument.hpp>
 #include <migraphx/rank.hpp>
+#include <migraphx/support_metric.hpp>
+#include <migraphx/instruction_ref.hpp>
 
 namespace migraphx {
 inline namespace MIGRAPHX_INLINE_NS {
@@ -61,6 +63,13 @@ struct target
      * @return The context to be used during compilation and execution.
      */
     context get_context() const;
+    /**
+     * @brief Check how well an instruction is supported on a target with the given metric
+     * @param ins Instruction to check if it's supported
+     * @param metric Used to define how the return value should be interpreted
+     * @return The value based on the chosen metric. Negative numbers mean unsupported
+     */
+    float is_supported(T&, instruction_ref ins, support_metric m) const;
     /**
      * @brief copy an argument to the current target.
      *
@@ -105,11 +114,18 @@ argument copy_from_target(T&, const argument& arg)
     return arg;
 }
 
+template <class T>
+float target_is_supported(T&, instruction_ref, support_metric)
+{
+    return 0;
+}
+
 <%
 interface('target',
      virtual('name', returns='std::string', const=True),
      virtual('get_passes', ctx='context&', options='const compile_options&', returns='std::vector<pass>', const=True),
      virtual('get_context', returns='context', const=True),
+     virtual('is_supported', returns='float', ins='instruction_ref', m='support_metric', const=True, default='target_is_supported'),
      virtual('copy_to',
              returns = 'argument',
              input   = 'const argument&',

tools/license_stamper.py

@@ -22,11 +22,14 @@
 #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 #  THE SOFTWARE.
 #####################################################################################
-import subprocess
+import subprocess, os
 
 #Debug flag
 debug = False
 
+__repo_dir__ = os.path.normpath(
+    os.path.join(os.path.realpath(__file__), '..', '..'))
+
 
 # Markdown code blob we should use to insert into notebook files
 def getipynb_markdownBlockAsList():
@@ -222,14 +225,15 @@ def getDelimiter(filename):
 
 def main():
 
-    message = open('LICENSE').read()
+    message = open(os.path.join(__repo_dir__, 'LICENSE')).read()
 
     #Get a list of all the files in our git repo
     #bashCommand = "git ls-files --exclude-standard"
     #print (bashCommand.split())
     proc = subprocess.run("git ls-files --exclude-standard",
                           shell=True,
-                          stdout=subprocess.PIPE)
+                          stdout=subprocess.PIPE,
+                          cwd=__repo_dir__)
     fileList = proc.stdout.decode().split('\n')
     message = message.split('\n')
 
@@ -237,7 +241,8 @@ def main():
         print("Target file list:\n" + str(fileList))
         print("Output Message:\n" + str(message))
 
-    for file in fileList:
+    for rfile in fileList:
+        file = os.path.join(__repo_dir__, rfile)
         #print(file)
         commentDelim = getDelimiter(file)
         if commentDelim is not None:

tools/te.py

@@ -23,7 +23,7 @@
 #####################################################################################
 import string, sys, re
 
-trivial = ['std::size_t', 'instruction_ref']
+trivial = ['std::size_t', 'instruction_ref', 'support_metric']
 
 headers = '''
 #include <algorithm>