mlonmcu 0.3.0.dev0__3-none-any.whl

mlonmcu/platform/microtvm/microtvm_target.py

@@ -0,0 +1,189 @@
+#
+# Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+#
+# This file is part of MLonMCU.
+# See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+import re
+import os
+
+from mlonmcu.target.target import Target
+from mlonmcu.target.metrics import Metrics
+
+from mlonmcu.logging import get_logger
+
+from .microtvm_zephyr_target import ZephyrMicroTvmPlatformTarget
+from .microtvm_arduino_target import ArduinoMicroTvmPlatformTarget
+from .microtvm_espidf_target import EspidfMicroTvmPlatformTarget
+from .microtvm_host_target import HostMicroTvmPlatformTarget
+from .microtvm_etissvp_target import EtissvpMicroTvmPlatformTarget
+from .microtvm_spike_target import SpikeMicroTvmPlatformTarget
+
+logger = get_logger()
+
+
+def name2template(name):
+    return name.replace("microtvm_", "")
+
+
+MICROTVM_PLATFORM_TARGET_REGISTRY = {}
+
+
+def register_microtvm_platform_target(target_name, t, override=False):
+    global MICROTVM_PLATFORM_TARGET_REGISTRY
+
+    if target_name in MICROTVM_PLATFORM_TARGET_REGISTRY and not override:
+        raise RuntimeError(f"MicroTVM platform target {target_name} is already registered")
+    MICROTVM_PLATFORM_TARGET_REGISTRY[target_name] = t
+
+
+def get_microtvm_platform_targets():
+    return MICROTVM_PLATFORM_TARGET_REGISTRY
+
+
+register_microtvm_platform_target("microtvm_zephyr", ZephyrMicroTvmPlatformTarget)
+register_microtvm_platform_target("microtvm_arduino", ArduinoMicroTvmPlatformTarget)
+register_microtvm_platform_target("microtvm_host", HostMicroTvmPlatformTarget)
+register_microtvm_platform_target("microtvm_etissvp", EtissvpMicroTvmPlatformTarget)
+register_microtvm_platform_target("microtvm_espidf", EspidfMicroTvmPlatformTarget)
+register_microtvm_platform_target("microtvm_spike", SpikeMicroTvmPlatformTarget)
+
+
+def create_microtvm_platform_target(name, platform, base=Target):
+    class MicroTvmPlatformTarget(base):
+        FEATURES = base.FEATURES + []
+
+        DEFAULTS = {
+            **base.DEFAULTS,
+            "timeout_sec": 0,  # disabled
+        }
+        REQUIRED = base.REQUIRED + []
+
+        def __init__(self, features=None, config=None):
+            super().__init__(name=name, features=features, config=config)
+            self.platform = platform
+            self.template = name2template(name)
+
+        @property
+        def timeout_sec(self):
+            return int(self.config["timeout_sec"])
+
+        @property
+        def repeat(self):
+            return None  # This is handled at the platform level
+
+        def exec(self, program, *args, cwd=os.getcwd(), **kwargs):
+            """Use target to execute a executable with given arguments"""
+            if len(args) > 0:
+                raise RuntimeError("Program arguments are not supported for real hardware devices")
+
+            assert self.platform is not None, "TVM targets need a platform to execute programs"
+
+            if self.timeout_sec > 0:
+                raise NotImplementedError
+
+            ret = self.platform.run(program, self)
+            return ret
+
+        def parse_stdout(self, out):
+            mean_ms = None
+            median_ms = None
+            max_ms = None
+            min_ms = None
+            std_ms = None
+            found = False
+            for line in out.split("\n"):
+                if found:
+                    match = re.compile(r"\s+(\d*\.\d+)\s+(\d*\.\d+)\s+(\d*\.\d+)\s+(\d*\.\d+)\s+(\d*\.\d+)").findall(
+                        line
+                    )
+                    assert len(match) == 1
+                    groups = match[0]
+                    mean_ms, median_ms, max_ms, min_ms, std_ms = (
+                        float(groups[0]),
+                        float(groups[1]),
+                        float(groups[2]),
+                        float(groups[3]),
+                        float(groups[4]),
+                    )
+                    break
+                if re.compile(r"\s+mean \(ms\)\s+median \(ms\)\s+max \(ms\)\s+min \(ms\)\s+std \(ms\)").match(line):
+                    found = True
+            return mean_ms, median_ms, max_ms, min_ms, std_ms
+
+        def get_metrics(self, elf, directory, handle_exit=None):
+            if self.print_outputs:
+                out = self.exec(elf, cwd=directory, live=True, handle_exit=handle_exit)
+            else:
+                out = self.exec(
+                    elf,
+                    cwd=directory,
+                    live=False,
+                    print_func=lambda *args, **kwargs: None,
+                    handle_exit=handle_exit,
+                )
+            mean_ms, _, _, _, _ = self.parse_stdout(out)
+
+            metrics = Metrics()
+            time_s = mean_ms / 1e3 if mean_ms is not None else mean_ms
+            if time_s:
+                metrics.add("Runtime [s]", time_s)
+
+            if self.platform.profile:
+                print("out", out)
+                headers = None
+                skip = False
+                lines = out.split("\n")
+                extracted = []
+
+                def extract_cols(line):
+                    x = re.compile(r"(([^\s\[\]]+)(\s\S+)*)(\[.*\])?").findall(line)
+                    return [y[0] for y in x]
+
+                for line in lines:
+                    print("line", line)
+                    if skip:
+                        skip = False
+                        continue
+                    if headers is None:
+                        if "Name" in line:
+                            headers = extract_cols(line)
+                            print("headers", headers)
+                            skip = True
+                            continue
+                    else:
+                        if len(line.strip()) == 0:
+                            break
+                        cols = extract_cols(line)
+                        data = {headers[i]: val for i, val in enumerate(cols)}
+                        extracted.append(data)
+                        if "Total_time" in line:
+                            break
+                assert len(extracted) > 0
+                metrics = {"default": metrics}
+                for item in extracted:
+                    if item["Node Name"] == "Total_time":
+                        metrics["default"].add("Runtime [s]", float(item["Time(us)"]) / 1e6)
+                    else:
+                        metrics_ = Metrics()
+                        metrics_.add("Runtime [s]", float(item["Time(us)"]) / 1e6)
+                        metrics[item["Node Name"]] = metrics_
+
+            return metrics, out, []
+
+        def get_arch(self):
+            return "unkwown"
+
+    return MicroTvmPlatformTarget

mlonmcu/platform/microtvm/microtvm_template_target.py

@@ -0,0 +1,55 @@
+#
+# Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+#
+# This file is part of MLonMCU.
+# See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+from mlonmcu.target.target import Target
+
+from mlonmcu.logging import get_logger
+
+logger = get_logger()
+
+
+class TemplateMicroTvmPlatformTarget(Target):
+    FEATURES = Target.FEATURES + []
+
+    DEFAULTS = {
+        **Target.DEFAULTS,
+    }
+    REQUIRED = Target.REQUIRED + ["tvm.build_dir"]
+
+    def __init__(self, name=None, features=None, config=None):
+        super().__init__(name=name, features=features, config=config)
+        self.template_path = None
+        self.option_names = []
+
+    def get_project_options(self):
+        def _bool_helper(x):
+            return str(x).lower() if isinstance(x, bool) else x
+
+        def _filter_none(x):
+            return {key: value for key, value in x.items() if value is not None}
+
+        return _filter_none(
+            {
+                key: _bool_helper(getattr(self, key) if hasattr(self, key) else self.config.get(key, None))
+                for key in self.option_names
+            }
+        )
+
+    def update_environment(self, env):
+        pass

mlonmcu/platform/microtvm/microtvm_zephyr_target.py

@@ -0,0 +1,91 @@
+#
+# Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+#
+# This file is part of MLonMCU.
+# See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+from pathlib import Path
+
+from mlonmcu.target.target import Target
+
+from mlonmcu.logging import get_logger
+from .microtvm_template_target import TemplateMicroTvmPlatformTarget
+
+logger = get_logger()
+
+
+class ZephyrMicroTvmPlatformTarget(TemplateMicroTvmPlatformTarget):
+    FEATURES = Target.FEATURES + []
+
+    DEFAULTS = {
+        **Target.DEFAULTS,
+        "extra_files_tar": None,
+        "project_type": "host_driven",
+        "zephyr_board": "",
+        # "zephyr_base": "?",
+        # "west_cmd": "?",
+        "verbose": False,
+        "warning_as_error": True,
+        "compile_definitions": "",
+        # "config_main_stack_size": None,
+        "config_main_stack_size": "16384",
+        "gdbserver_port": None,
+        "nrfjprog_snr": None,
+        "openocd_serial": None,
+        "port": None,  # Workaround to overwrite esptool detection
+    }
+    REQUIRED = Target.REQUIRED + ["zephyr.install_dir", "zephyr.sdk_dir"]
+
+    def __init__(self, name=None, features=None, config=None):
+        super().__init__(name=name, features=features, config=config)
+        self.template_path = None
+        self.option_names = [
+            "extra_files_tar",
+            "project_type",
+            "zephyr_board",
+            # "verbose",
+            "warning_as_error",
+            "compile_definitions",
+            "config_main_stack_size",
+            "gdbserver_port",
+            "nrfjprog_snr",
+            "openocd_serial",
+        ]
+        # self.platform = platform
+        # self.template = name2template(name)
+
+    @property
+    def zephyr_install_dir(self):
+        return Path(self.config["zephyr.install_dir"])
+
+    @property
+    def port(self):
+        return self.config["port"]
+
+    @property
+    def zephyr_sdk_dir(self):
+        return Path(self.config["zephyr.sdk_dir"])
+
+    def get_project_options(self):
+        ret = super().get_project_options()
+        ret.update({"zephyr_base": self.zephyr_install_dir / "zephyr"})
+        return ret
+
+    def update_environment(self, env):
+        super().update_environment(env)
+        env["ZEPHYR_BASE"] = str(self.zephyr_install_dir / "zephyr")
+        env["ZEPHYR_SDK_INSTALL_DIR"] = str(self.zephyr_sdk_dir)
+        if self.port:
+            env["ESPTOOL_PORT"] = self.port

mlonmcu/platform/mlif/__init__.py

@@ -0,0 +1,25 @@
+#
+# Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+#
+# This file is part of MLonMCU.
+# See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""MLonMCU MLIF platform"""
+
+# pylint: disable=wildcard-import, redefined-builtin
+
+from .mlif import MlifPlatform
+
+__all__ = ["MlifPlatform"]

mlonmcu/platform/mlif/mlif.py

@@ -0,0 +1,300 @@
+#
+# Copyright (c) 2022 TUM Department of Electrical and Computer Engineering.
+#
+# This file is part of MLonMCU.
+# See https://github.com/tum-ei-eda/mlonmcu.git for further info.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""MLIF Platform"""
+import tempfile
+
+from pathlib import Path
+
+from mlonmcu.config import str2bool
+from mlonmcu.setup import utils  # TODO: Move one level up?
+from mlonmcu.artifact import Artifact, ArtifactFormat
+from mlonmcu.logging import get_logger
+from mlonmcu.target import get_targets
+from mlonmcu.target.target import Target
+from mlonmcu.models.utils import get_data_source
+
+from ..platform import CompilePlatform, TargetPlatform
+from .mlif_target import get_mlif_platform_targets, create_mlif_platform_target
+
+logger = get_logger()
+
+
+class MlifPlatform(CompilePlatform, TargetPlatform):
+    """Model Library Interface Platform class."""
+
+    FEATURES = (
+        CompilePlatform.FEATURES
+        + TargetPlatform.FEATURES
+        + [
+            "validate",
+            "muriscvnn",
+            "cmsisnn",
+            "muriscvnnbyoc",
+            "cmsisnnbyoc",
+            "vext",
+            "pext",
+            "arm_mvei",
+            "arm_dsp",
+            "auto_vectorize",
+            "benchmark",
+            "xpulp",
+        ]  # TODO: allow Feature-Features with automatic resolution of initialization order
+    )
+
+    DEFAULTS = {
+        **CompilePlatform.DEFAULTS,
+        **TargetPlatform.DEFAULTS,
+        "ignore_data": True,
+        "fail_on_error": False,  # Prefer to add acolum with validation results instead of raising a RuntimeError
+        "model_support_dir": None,
+        "toolchain": "gcc",
+        "prebuild_lib_path": None,
+        "optimize": None,  # values: 0,1,2,3,s
+        "input_data_path": None,
+        "output_data_path": None,
+        "mem_only": False,
+    }
+
+    REQUIRED = ["mlif.src_dir"]
+    OPTIONAL = ["llvm.install_dir"]
+
+    def __init__(self, features=None, config=None):
+        super().__init__(
+            "mlif",
+            features=features,
+            config=config,
+        )
+        self.tempdir = None
+        self.build_dir = None
+        self.goal = "generic_mlif"
+
+    def gen_data_artifact(self):
+        in_paths = self.input_data_path
+        if not isinstance(in_paths, list):
+            in_paths = [in_paths]
+        in_paths_new = []
+        for in_path in in_paths:
+            if in_path.is_file():
+                raise NotImplementedError
+            elif in_path.is_dir():
+                in_paths_new.extend([f for f in Path(in_path).iterdir() if f.is_file()])
+            else:
+                logger.warning("TODO")
+                return None
+        in_paths = in_paths_new
+        out_paths = self.output_data_path
+        if not isinstance(out_paths, list):
+            out_paths = [out_paths]
+        out_paths_new = []
+        for out_path in out_paths:
+            if out_path.is_file():
+                raise NotImplementedError
+            elif out_path.is_dir():
+                out_paths_new.extend([f for f in Path(out_path).iterdir() if f.is_file()])
+            else:
+                logger.warning("TODO")
+                return None
+        out_paths = out_paths_new
+        if len(in_paths) == 0 or len(out_paths) == 0:
+            logger.warning("TODO")
+            return None
+        data_src = get_data_source(in_paths, out_paths)
+        return Artifact("data.c", content=data_src, fmt=ArtifactFormat.SOURCE)
+
+    def init_directory(self, path=None, context=None):
+        if self.build_dir is not None:
+            self.build_dir.mkdir(exist_ok=True)
+            logger.debug("Build directory already initialized")
+            return
+        dir_name = self.name
+        if path is not None:
+            self.build_dir = Path(path)
+        elif self.config["build_dir"]:
+            self.build_dir = Path(self.config["build_dir"])
+        else:
+            if context:
+                assert "temp" in context.environment.paths
+                self.build_dir = (
+                    context.environment.paths["temp"].path / dir_name
+                )  # TODO: Need to lock this for parallel builds
+            else:
+                logger.debug(
+                    "Creating temporary directory because no context was available "
+                    "and 'mlif.build_dir' was not supplied"
+                )
+                self.tempdir = tempfile.TemporaryDirectory()
+                self.build_dir = Path(self.tempdir.name) / dir_name
+                logger.info("Temporary build directory: %s", self.build_dir)
+        self.build_dir.mkdir(exist_ok=True)
+
+    def create_target(self, name):
+        assert name in self.get_supported_targets(), f"{name} is not a valid MLIF target"
+        targets = get_targets()
+        if name in targets:
+            base = targets[name]
+        else:
+            base = Target
+        return create_mlif_platform_target(name, self, base=base)
+
+    @property
+    def mlif_dir(self):
+        return Path(self.config["mlif.src_dir"])
+
+    @property
+    def llvm_dir(self):
+        return self.config["llvm.install_dir"]
+
+    @property
+    def ignore_data(self):
+        value = self.config["ignore_data"]
+        return str2bool(value) if not isinstance(value, (bool, int)) else value
+
+    @property
+    def fail_on_error(self):
+        value = self.config["fail_on_error"]
+        return str2bool(value) if not isinstance(value, (bool, int)) else value
+
+    @property
+    def validate_outputs(self):
+        return not self.ignore_data
+
+    @property
+    def toolchain(self):
+        return str(self.config["toolchain"])
+
+    @property
+    def model_support_dir(self):
+        return self.config["model_support_dir"]
+
+    @property
+    def prebuild_lib_dir(self):
+        return self.config["prebuild_lib_dir"]
+
+    @property
+    def optimize(self):
+        return self.config["optimize"]
+
+    @property
+    def input_data_path(self):
+        return self.config["input_data_path"]
+
+    @property
+    def output_data_path(self):
+        return self.config["output_data_path"]
+
+    @property
+    def mem_only(self):
+        value = self.config["mem_only"]
+        return str2bool(value) if not isinstance(value, (bool, int)) else value
+
+    def get_supported_targets(self):
+        target_names = get_mlif_platform_targets()
+        return target_names
+
+    def close(self):
+        if self.tempdir:
+            self.tempdir.cleanup()
+
+    def get_common_cmake_args(self):
+        args = []
+        args.append(f"-DTOOLCHAIN={self.toolchain}")
+        if self.toolchain == "llvm" and self.llvm_dir is None:
+            raise RuntimeError("Missing config variable: llvm.install_dir")
+        else:
+            args.append(f"-DLLVM_DIR={self.llvm_dir}")
+        if self.optimize:
+            args.append(f"-DOPTIMIZE={self.optimize}")
+        return args
+
+    def prepare(self):
+        self.init_directory()
+
+    def configure(self, target, src, _model):
+        del target
+        if not isinstance(src, Path):
+            src = Path(src)
+        cmakeArgs = []
+        definitions = self.definitions
+        if self.mem_only:
+            definitions["QUIET"] = True
+        for key, value in definitions.items():
+            if isinstance(value, bool):
+                value = "ON" if value else "OFF"
+            cmakeArgs.append(f"-D{key}={value}")
+        cmakeArgs.extend(self.get_common_cmake_args())
+        cmakeArgs.append("-DCMAKE_VERBOSE_MAKEFILE:BOOL=ON")  # TODO for debug, should be removed
+        if self.model_support_dir:
+            cmakeArgs.append(f"-DMODEL_SUPPORT_DIR={self.model_support_dir}")
+        else:
+            pass
+        if src.is_file():
+            src = src.parent  # TODO deal with directories or files?
+        if src.is_dir():
+            cmakeArgs.append("-DSRC_DIR=" + str(src))
+        else:
+            raise RuntimeError("Unable to find sources!")
+        if self.ignore_data:
+            cmakeArgs.append("-DDATA_SRC=")
+            artifacts = []
+        else:
+            data_artifact = self.gen_data_artifact()
+            data_file = self.build_dir / data_artifact.name
+            data_artifact.export(data_file)
+            cmakeArgs.append("-DDATA_SRC=" + str(data_file))
+            artifacts = [data_artifact]
+        utils.mkdirs(self.build_dir)
+        out = utils.cmake(
+            self.mlif_dir,
+            *cmakeArgs,
+            cwd=self.build_dir,
+            debug=self.debug,
+            live=self.print_outputs,
+        )
+        return out, artifacts
+
+    def compile(self, target, src=None, model=None, data_file=None):
+        out = ""
+        if src:
+            configure_out, artifacts = self.configure(target, src, model)
+            out += configure_out
+        out += utils.make(
+            self.goal,
+            cwd=self.build_dir,
+            threads=self.num_threads,
+            live=self.print_outputs,
+        )
+        return out, artifacts
+
+    def generate_elf(self, src, target, model=None):
+        out, artifacts = self.compile(target, src=src, model=model)
+        elf_file = self.build_dir / "bin" / "generic_mlif"
+        # TODO: just use path instead of raw data?
+        with open(elf_file, "rb") as handle:
+            data = handle.read()
+            artifact = Artifact("generic_mlif", raw=data, fmt=ArtifactFormat.RAW)
+            artifacts.insert(0, artifact)  # First artifact should be the ELF
+        metrics = self.get_metrics(elf_file)
+        content = metrics.to_csv(include_optional=True)  # TODO: store df instead?
+        metrics_artifact = Artifact("metrics.csv", content=content, fmt=ArtifactFormat.TEXT)
+        artifacts.append(metrics_artifact)
+        stdout_artifact = Artifact(
+            "mlif_out.log", content=out, fmt=ArtifactFormat.TEXT
+        )  # TODO: rename to tvmaot_out.log?
+        artifacts.append(stdout_artifact)
+        self.artifacts = {"default": artifacts}