mlonmcu 0.3.0.dev0__3-none-any.whl

mlonmcu/target/arm/corstone300.py

@@ -0,0 +1,235 @@
+#
+# 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 Corstone300 Target definitions"""
+
+import os
+import re
+from pathlib import Path
+
+from mlonmcu.logging import get_logger
+from mlonmcu.feature.features import SUPPORTED_TVM_BACKENDS
+from mlonmcu.config import str2bool
+from mlonmcu.target import Target
+from mlonmcu.target.common import cli, execute
+from mlonmcu.target.metrics import Metrics
+from .util import resolve_cpu_features
+
+logger = get_logger()
+
+
+class Corstone300Target(Target):
+    """Target using an ARM FVP (fixed virtual platform) based on a Cortex M55 with EthosU support"""
+
+    FEATURES = ["ethosu", "arm_mvei", "arm_dsp"]
+
+    DEFAULTS = {
+        **Target.DEFAULTS,
+        "model": "cortex-m55",  # Options: cortex-m{0,0plus,1,3,4,7,23,33,35p,55} (Frequency is fixed at 25MHz)
+        # Warning: FVP is still M55 based!
+        "timeout_sec": 0,  # disabled
+        "enable_ethosu": False,
+        "enable_fpu": True,
+        "enable_mvei": False,  # unused
+        "enable_dsp": False,  # unused
+        "ethosu_num_macs": 256,
+        "extra_args": "",
+    }
+    REQUIRED = [
+        "corstone300.exe",
+        "cmsisnn.dir",
+        "arm_gcc.install_dir",
+    ]  # Actually cmsisnn.dir points to the root CMSIS_5 directory
+
+    def __init__(self, name="corstone300", features=None, config=None):
+        super().__init__(name, features=features, config=config)
+
+    @property
+    def model(self):
+        return self.config["model"]
+
+    @property
+    def enable_ethosu(self):
+        value = self.config["enable_ethosu"]
+        return str2bool(value) if not isinstance(value, (bool, int)) else value
+
+    @property
+    def enable_fpu(self):
+        value = self.config["enable_fpu"]
+        return str2bool(value) if not isinstance(value, (bool, int)) else value
+
+    @property
+    def enable_mvei(self):
+        value = self.config["enable_mvei"]
+        return str2bool(value) if not isinstance(value, (bool, int)) else value
+
+    @property
+    def enable_dsp(self):
+        value = self.config["enable_dsp"]
+        return str2bool(value) if not isinstance(value, (bool, int)) else value
+
+    @property
+    def ethosu_num_macs(self):
+        return int(self.config["ethosu_num_macs"])
+
+    @property
+    def fvp_exe(self):
+        return Path(self.config["corstone300.exe"])
+
+    @property
+    def gcc_prefix(self):
+        return str(self.config["arm_gcc.install_dir"])
+
+    @property
+    def cmsisnn_dir(self):
+        return Path(self.config["cmsisnn.dir"])
+
+    @property
+    def extra_args(self):
+        return str(self.config["extra_args"])
+
+    @property
+    def timeout_sec(self):
+        # 0 = off
+        return int(self.config["timeout_sec"])
+
+    def get_default_fvp_args(self):
+        return [
+            "-C",
+            "mps3_board.visualisation.disable-visualisation=1",
+            "-C",
+            "mps3_board.telnetterminal0.start_telnet=0",
+            "-C",
+            'mps3_board.uart0.out_file="-"',
+            "-C",
+            "mps3_board.uart0.unbuffered_output=1",
+            "-C",
+            'mps3_board.uart0.shutdown_tag="EXITTHESIM"',
+            "-C",
+            "cpu0.CFGDTCMSZ=15",  # ?
+            "-C",
+            "cpu0.CFGITCMSZ=15",  # ?
+            "-C",
+            f"cpu0.FPU={int(self.enable_fpu)}",
+            "-C",
+            "cpu0.MVE={}".format(
+                2 if self.enable_mvei and self.enable_fpu else (1 if self.enable_mvei and not self.enable_fpu else 0)
+            ),
+        ]
+
+    def get_ethosu_fvp_args(self):
+        return [
+            "-C",
+            f"ethosu.num_macs={self.ethosu_num_macs}",
+            "-C",
+            'ethosu.extra_args="--fast"',
+        ]
+
+    def exec(self, program, *args, cwd=os.getcwd(), **kwargs):
+        """Use target to execute a executable with given arguments"""
+        fvp_args = []
+        fvp_args.extend(self.get_default_fvp_args())
+        if self.enable_ethosu:
+            fvp_args.extend(self.get_ethosu_fvp_args())
+        if self.timeout_sec > 0:
+            fvp_args.extend(["--timelimit", str(self.timeout_sec)])
+        if len(self.extra_args) > 0:
+            fvp_args.extend(self.extra_args.split(" "))
+
+        if "ethosu" in [feature.name for feature in self.features]:  # TODO: remove this
+            raise NotImplementedError
+
+        ret = execute(
+            self.fvp_exe.resolve(),
+            *fvp_args,
+            program,
+            *args,
+            cwd=cwd,
+            **kwargs,
+        )
+        return ret
+
+    def parse_stdout(self, out, handle_exit=None):
+        exit_match = re.search(r"Application exit code: (.*)\.", out)
+        if exit_match:
+            exit_code = int(exit_match.group(1))
+            if handle_exit is not None:
+                exit_code = handle_exit(exit_code)
+            if exit_code != 0:
+                logger.error("Execution failed - " + out)
+                raise RuntimeError(f"unexpected exit code: {exit_code}")
+        cpu_cycles = re.search(r"Total Cycles: (.*)", out)
+
+        if not cpu_cycles:
+            if exit == 0:
+                logger.warning("unexpected script output (cycles)")
+            cycles = None
+        else:
+            cycles = int(float(cpu_cycles.group(1)))
+        # mips = None  # TODO: parse mips?
+        return cycles
+
+    def get_metrics(self, elf, directory, *args, handle_exit=None):
+        out = ""
+        if self.print_outputs:
+            out += self.exec(elf, *args, cwd=directory, live=True, handle_exit=handle_exit)
+        else:
+            out += self.exec(
+                elf, *args, cwd=directory, live=False, print_func=lambda *args, **kwargs: None, handle_exit=handle_exit
+            )
+        cycles = self.parse_stdout(out, handle_exit=handle_exit)
+
+        metrics = Metrics()
+        metrics.add("Cycles", cycles)
+
+        return metrics, out, []
+
+    def get_platform_defs(self, platform):
+        ret = super().get_platform_defs(platform)
+        ret["CMSIS_PATH"] = self.cmsisnn_dir
+        ret["ARM_COMPILER_PREFIX"] = self.gcc_prefix
+        cpu, float_abi, fpu = resolve_cpu_features(
+            self.model, enable_fp=self.enable_fpu, enable_dsp=self.enable_dsp, enable_mve=self.enable_mvei
+        )
+        ret["ARM_CPU"] = cpu
+        ret["ARM_FLOAT_ABI"] = float_abi
+        ret["ARM_FPU"] = fpu
+        return ret
+
+    def get_arch(self):
+        return "arm"  # TODO: use proper mapping (v6, v7, v8, v8.1...)
+
+    def get_backend_config(self, backend):
+        if backend in SUPPORTED_TVM_BACKENDS:
+            ret = {
+                "target_device": "arm_cpu",
+                # "target_march": self.get_arch(),
+                "target_model": "unknown",
+                "target_mtriple": "arm-none-eabi",
+                "target_mcpu": self.model,
+                # "target_mattr": "?",
+                # "target_mabi": self.abi,
+            }
+            if self.enable_dsp:
+                ret.update({"desired_layout": "NHWC:HWOI"})  # Not yet supported by upstream TVMC
+            return ret
+        return {}
+
+
+if __name__ == "__main__":
+    cli(target=Corstone300Target)

mlonmcu/target/arm/util.py

@@ -0,0 +1,109 @@
+#
+# 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 ARM Cortex-M utilities"""
+
+DSP_TARGETS = ["cortex-m4", "cortex-m7", "cortex-m33", "cortex-m35p", "cortex-m55"]
+
+MVE_TARGETS = ["cortex-m55"]
+
+FP_TARGETS = ["cortex-m4", "cortex-m7", "cortex-m33", "cortex-m35p", "cortex-m55"]
+FP_DP_TARGETS = ["cortex-m7", "cortex-m55"]
+
+ALLOWED_ATTRS = {
+    "cortex-m0": [],
+    "cortex-m0plus": [],
+    "cortex-m1": [],
+    "cortex-m3": [],
+    "cortex-m4": ["+nofp"],
+    "cortex-m7": ["+nofp", "+nofp.dp"],
+    "cortex-m23": [],
+    "cortex-m33": ["+nodsp", "+nofp"],
+    "cortex-m35p": ["+nodsp", "+nofp"],
+    "cortex-m55": ["+nomve", "+nomve.fp", "+nodsp", "+nofp"],
+}
+
+
+def resolve_cpu_features(model, enable_fp=None, enable_fp_dp=None, enable_dsp=None, enable_mve=None):
+    cpu = model
+    fpu = "auto"
+
+    splitted = cpu.split("+")
+    base = splitted[0]
+    attrs = [f"+{attr}" for attr in splitted[1:]]
+
+    if enable_fp is None:
+        enable_fp = base in FP_TARGETS and ("+nofp" not in ALLOWED_ATTRS[base] or "+nofp" not in attrs)
+    if enable_fp_dp is None:
+        if enable_fp:
+            enable_fp_dp = base in FP_DP_TARGETS and ("+nofp.dp" not in ALLOWED_ATTRS[base] or "+nofp.dp" not in attrs)
+        else:
+            enable_fp_dp = False
+    if enable_dsp is None:
+        enable_dsp = base in DSP_TARGETS and ("+nodsp" not in ALLOWED_ATTRS[base] or "+nodsp" not in attrs)
+    if enable_mve is None:
+        enable_mve = base in MVE_TARGETS and ("+nomve" not in ALLOWED_ATTRS[base] or "+nomve" not in attrs)
+
+    float_abi = "hard" if enable_fp else "soft"
+
+    if enable_fp_dp:
+        assert enable_fp, "ARM double precision floating point supports requires fp extension"
+    if enable_mve:
+        assert enable_dsp, "ARM MVEI extension implies DSP extension"
+
+    if len(attrs) > 0:
+        # User defined features explicitly, check for validity
+        if enable_fp and ("+nofp" not in ALLOWED_ATTRS[base] or "+nofp" not in attrs):
+            assert base in FP_TARGETS, f"Chosen cpu '{cpu}' does not support floating point"
+        if enable_fp_dp and ("+nofp.dp" not in ALLOWED_ATTRS[base] or "+nofp.dp" not in attrs):
+            assert base in FP_DP_TARGETS, f"Chosen cpu '{cpu}' does not support double precison floating point"
+        if enable_dsp and ("+nodsp" not in ALLOWED_ATTRS[base] or "+nodsp" not in attrs):
+            assert base in DSP_TARGETS, f"Chosen cpu '{cpu}' does not support dsp instructions"
+        if enable_mve and ("+nomve" not in ALLOWED_ATTRS[base] or "+nomve" not in attrs):
+            assert base in MVE_TARGETS, f"Chosen cpu '{cpu}' does not support mve (helium) instructions"
+    else:
+        # Define features automatically
+        if enable_fp:
+            assert base in FP_TARGETS, f"Chosen cpu '{cpu}' does not support floating point"
+        else:
+            if base in FP_TARGETS:
+                assert "+nofp" in ALLOWED_ATTRS[base], f"Floating point support can not be turned off for cpu '{cpu}'"
+                attrs.append("+nofp")
+        if enable_fp_dp:
+            assert base in FP_DP_TARGETS, f"Chosen cpu '{cpu}' does not support double precision floating point"
+        else:
+            if base in FP_DP_TARGETS and enable_fp:
+                assert (
+                    "+nofp.dp" in ALLOWED_ATTRS[base]
+                ), f"Double precision floating point support can not be turned off for cpu '{cpu}'"
+                attrs.append("+nofp.dp")
+        if enable_dsp:
+            assert base in DSP_TARGETS, f"Chosen cpu '{cpu}' does not support dsp instructions"
+        else:
+            if base in DSP_TARGETS:
+                assert "+nodsp" in ALLOWED_ATTRS[base], f"DSP extension can not be turned off for cpu '{cpu}'"
+                attrs.append("+nodsp")
+        if enable_mve:
+            assert base in MVE_TARGETS, f"Chosen cpu '{cpu}' does not support mve (helium) instructions"
+        else:
+            if base in MVE_TARGETS:
+                assert "+nomve" in ALLOWED_ATTRS[base], f"MVE (helium) extension can not be turned of for cpu '{cpu}'"
+                attrs.append("+nomve")
+
+    cpu = "".join([base] + attrs)
+    return cpu, float_abi, fpu

mlonmcu/target/common.py

@@ -0,0 +1,194 @@
+#
+# 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.
+#
+"""Helper functions used by MLonMCU targets"""
+
+import subprocess
+import argparse
+from typing import List, Callable
+
+from mlonmcu.cli.helper.parse import extract_feature_names, extract_config
+from mlonmcu.feature.type import FeatureType
+from mlonmcu.feature.features import get_available_features
+from mlonmcu.logging import get_logger
+
+logger = get_logger()
+
+
+# TODO: merge together with mlonmcu.setup.utils.exec_getout
+def execute(
+    *args: List[str],
+    ignore_output: bool = False,
+    live: bool = False,
+    print_func: Callable = print,
+    handle_exit=None,
+    err_func: Callable = logger.error,
+    **kwargs,
+) -> str:
+    """Wrapper for running a program in a subprocess.
+
+    Parameters
+    ----------
+    args : list
+        The actual command.
+    ignore_output : bool
+        Do not get the stdout and stderr or the subprocess.
+    live : bool
+        Print the output line by line instead of only at the end.
+    print_func : Callable
+        Function which should be used to print sysout messages.
+    err_func : Callable
+        Function which should be used to print errors.
+    kwargs: dict
+        Arbitrary keyword arguments passed through to the subprocess.
+
+    Returns
+    -------
+    out : str
+        The command line output of the command
+    """
+    logger.debug("- Executing: %s", str(args))
+    if ignore_output:
+        assert not live
+        subprocess.run(args, **kwargs, check=True)
+        return None
+
+    out_str = ""
+    if live:
+        with subprocess.Popen(
+            args,
+            **kwargs,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+        ) as process:
+            for line in process.stdout:
+                new_line = line.decode(errors="replace")
+                out_str = out_str + new_line
+                print_func(new_line.replace("\n", ""))
+            exit_code = None
+            while exit_code is None:
+                exit_code = process.poll()
+            if handle_exit is not None:
+                exit_code = handle_exit(exit_code)
+            assert exit_code == 0, "The process returned an non-zero exit code {}! (CMD: `{}`)".format(
+                exit_code, " ".join(list(map(str, args)))
+            )
+    else:
+        p = subprocess.Popen([i for i in args], **kwargs, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        out_str = p.communicate()[0].decode(errors="replace")
+        exit_code = p.poll()
+        print_func(out_str)
+        if handle_exit is not None:
+            exit_code = handle_exit(exit_code)
+        if exit_code != 0:
+            err_func(out_str)
+        assert exit_code == 0, "The process returned an non-zero exit code {}! (CMD: `{}`)".format(
+            exit_code, " ".join(list(map(str, args)))
+        )
+
+    return out_str
+
+
+def add_common_options(parser: argparse.ArgumentParser, target):
+    """Add a set of common options to a command line parser.
+
+    Parameters
+    ----------
+    parser : argparse.ArgumentParser
+        The command line parser
+    """
+    target_group = parser.add_argument_group("target options")
+    target_group.add_argument(
+        "-f",
+        "--feature",
+        type=str,
+        metavar="FEATURE",
+        action="append",
+        choices=target.FEATURES,  # TODO: get from selected target?
+        help="Enabled features for target (Choices: %(choices)s)",
+    )
+    target_group.add_argument(
+        "-c",
+        "--config",
+        metavar="KEY=VALUE",
+        nargs="+",
+        action="append",
+        help="Custom target config as key-value pairs",
+    )
+
+
+def init_target_features(names, config):
+    features = []
+    for name in names:
+        feature_classes = get_available_features(feature_type=FeatureType.TARGET, feature_name=name)
+        for feature_class in feature_classes:
+            features.append(feature_class(config=config))
+    return features
+
+
+def cli(target, args: List[str] = None):
+    """Utility to handle the command line api for targets.
+
+    Parameters
+    ----------
+    target : Target
+        The target to be used.
+    args : list
+        Interface to pass arguments to the command line parser from test functions.
+    """
+    parser = argparse.ArgumentParser(description="ML on MCU Target")
+    subparsers = parser.add_subparsers(dest="subcommand")
+    exec_parser = subparsers.add_parser("exec", description="Run program with target")
+
+    def _handle_execute(args):
+        config, _ = extract_config(args)
+        feature_names, _ = extract_feature_names(args)
+        features = init_target_features(feature_names, config)
+        target_inst = target(features=features, config=config)
+        target_inst.exec(args.program, *args.extra_args, live=True)
+
+    exec_parser.set_defaults(func=_handle_execute)
+    add_common_options(exec_parser, target)
+    exec_group = exec_parser.add_argument_group("Exec options")
+    exec_group.add_argument("program", metavar="EXE", type=str, help="The program which should be executed")
+    exec_group.add_argument("extra_args", metavar="ARG", nargs="*", help="Additional arguments")
+    inspect_parser = subparsers.add_parser("inspect", description="Inspect program with target")
+
+    def _handle_inspect(args):
+        config, _ = extract_config(args)
+        feature_names, _ = extract_feature_names(args)
+        features = init_target_features(feature_names, config)
+        target_inst = target(features=features, config=config)
+        target_inst.inspect(args.program)
+
+    inspect_parser.set_defaults(func=_handle_inspect)
+    add_common_options(inspect_parser, target)
+    inspect_group = inspect_parser.add_argument_group("Inspect options")
+    inspect_group.add_argument("program", metavar="EXE", type=str, help="The program which should be inspected")
+    if args:
+        args = parser.parse_args(args)
+    else:
+        args = parser.parse_args()
+    if hasattr(args, "func"):
+        args.func(args)
+    else:
+        raise RuntimeError("Invalid command. For usage details use '--help'!")
+
+    # Argparge
+    # Env Vars
+    # MLONMCU Context (can be disabled via --plain)