mlonmcu 0.3.0.dev0__3-none-any.whl

mlonmcu/setup/tasks/__init__.py

@@ -0,0 +1,40 @@
+#
+# 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 .common import get_task_factory
+
+__all__ = ["get_task_factory"]
+
+from .arm_gcc import *  # noqa: F401, F403
+from .cmsisnn import *  # noqa: F401, F403
+from .corstone300 import *  # noqa: F401, F403
+from .espidf import *  # noqa: F401, F403
+from .etiss import *  # noqa: F401, F403
+from .llvm import *  # noqa: F401, F403
+from .mlif import *  # noqa: F401, F403
+from .muriscvnn import *  # noqa: F401, F403
+from .riscv_gcc import *  # noqa: F401, F403
+from .spike import *  # noqa: F401, F403
+from .tflite import *  # noqa: F401, F403
+from .tflmc import *  # noqa: F401, F403
+from .tf import *  # noqa: F401, F403
+from .tvm import *  # noqa: F401, F403
+from .utvmcg import *  # noqa: F401, F403
+from .zephyr import *  # noqa: F401, F403
+from .pulp import *  # noqa: F401, F403

mlonmcu/setup/tasks/arm_gcc.py

@@ -0,0 +1,58 @@
+#
+# 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.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import multiprocessing
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import _validate_gcc, get_task_factory
+from .corstone300 import _validate_corstone300
+
+logger = get_logger()
+Tasks = get_task_factory()
+
+
+def _validate_arm_gcc(context: MlonMcuContext, params=None):
+    return _validate_corstone300(context, params=params) and _validate_gcc(context, params=params)
+
+
+@Tasks.provides(["arm_gcc.install_dir"])
+@Tasks.validate(_validate_corstone300)
+@Tasks.register(category=TaskType.TARGET)
+def install_arm_gcc(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Download and install GNU compiler toolchain from ARM."""
+    armName = utils.makeDirName("arm_gcc")
+    armInstallDir = context.environment.paths["deps"].path / "install" / armName
+    user_vars = context.environment.vars
+    if "arm_gcc.install_dir" in user_vars:  # TODO: also check command line flags?
+        # armInstallDir = user_vars["riscv_gcc.install_dir"]
+        return False
+    else:
+        if not utils.is_populated(armInstallDir):
+            armUrl = "https://developer.arm.com/-/media/Files/downloads/gnu/11.2-2022.02/binrel/"
+            armFileName = "gcc-arm-11.2-2022.02-x86_64-arm-none-eabi"
+            armArchive = armFileName + ".tar.xz"
+            utils.download_and_extract(armUrl, armArchive, armInstallDir, progress=verbose)
+    context.cache["arm_gcc.install_dir"] = armInstallDir

mlonmcu/setup/tasks/cmsisnn.py

@@ -0,0 +1,151 @@
+#
+# 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.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import os
+import multiprocessing
+from pathlib import Path
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import get_task_factory
+
+logger = get_logger()
+
+Tasks = get_task_factory()
+
+
+def _validate_cmsisnn(context: MlonMcuContext, params=None):
+    if not (context.environment.has_feature("cmsisnn") or context.environment.has_feature("cmsisnnbyoc")):
+        return False
+    mvei = params.get("mvei", False)
+    dsp = params.get("dsp", False)
+    target_arch = params.get("target_arch", None)
+    if target_arch == "arm":
+        if dsp and not context.environment.has_feature("arm_dsp"):
+            return False
+        if mvei and not context.environment.has_feature("arm_mvei"):
+            return False
+    else:
+        if mvei or dsp:
+            return False
+    return True
+
+
+def _validate_cmsis(context: MlonMcuContext, params=None):
+    return _validate_cmsisnn(context, params=params) or context.environment.has_target("corstone300")
+
+
+@Tasks.provides(["cmsisnn.dir"])
+@Tasks.validate(_validate_cmsis)
+@Tasks.register(category=TaskType.MISC)
+def clone_cmsis(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """CMSIS repository."""
+    cmsisName = utils.makeDirName("cmsis")
+    cmsisSrcDir = Path(context.environment.paths["deps"].path) / "src" / cmsisName
+    # TODO: allow to skip this if cmsisnn.dir+cmsisnn.lib are provided by the user and corstone is not used
+    # -> move those checks to validate?
+    if rebuild or not utils.is_populated(cmsisSrcDir):
+        cmsisRepo = context.environment.repos["cmsis"]
+        utils.clone(cmsisRepo.url, cmsisSrcDir, branch=cmsisRepo.ref, refresh=rebuild)
+    context.cache["cmsisnn.dir"] = cmsisSrcDir
+
+
+@Tasks.needs(["cmsisnn.dir"])
+@Tasks.optional(["riscv_gcc.install_dir", "riscv_gcc.name", "arm_gcc.install_dir"])
+@Tasks.provides(["cmsisnn.lib"])
+@Tasks.param("dbg", [False, True])
+# @Tasks.param("target_arch", ["x86", "riscv", "arm"])
+@Tasks.param("target_arch", ["x86"])  # Arm/riscv currently broken
+@Tasks.param("mvei", [False, True])
+@Tasks.param("dsp", [False, True])
+@Tasks.validate(_validate_cmsisnn)
+@Tasks.register(category=TaskType.OPT)  # TODO: rename to TaskType.FEATURE?
+def build_cmsisnn(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    target_arch = params["target_arch"]
+    mvei = params["mvei"]
+    dsp = params["dsp"]
+    dbg = params["dbg"]
+    flags = utils.makeFlags(
+        (True, target_arch),
+        (mvei, "mvei"),
+        (dsp, "dsp"),
+        (dbg, "dbg"),
+    )
+    cmsisnnName = utils.makeDirName("cmsisnn", flags=flags)
+    cmsisnnBuildDir = context.environment.paths["deps"].path / "build" / cmsisnnName
+    cmsisnnInstallDir = context.environment.paths["deps"].path / "install" / cmsisnnName
+    cmsisnnLib = cmsisnnInstallDir / "libcmsis-nn.a"
+    cmsisSrcDir = Path(context.cache["cmsisnn.dir"])
+    cmsisnnSrcDir = cmsisSrcDir / "CMSIS" / "NN"
+    if rebuild or not utils.is_populated(cmsisnnBuildDir) or not cmsisnnLib.is_file():
+        utils.mkdirs(cmsisnnBuildDir)
+        cmakeArgs = []
+        env = os.environ.copy()
+        # utils.cmake("-DTF_SRC=" + str(tfSrcDir), str(tflmcSrcDir), debug=params["dbg"], cwd=tflmcBuildDir)
+        if params["target_arch"] == "arm":
+            toolchainFile = cmsisSrcDir / "CMSIS" / "DSP" / "gcc.cmake"
+            armCpu = "cortex-m55"  # TODO: make this variable?
+            cmakeArgs.append(f"-DARM_CPU={armCpu}")
+            cmakeArgs.append(f"-DCMAKE_TOOLCHAIN_FILE={toolchainFile}")  # Why does this not set CMAKE_C_COMPILER?
+            armBinDir = Path(context.cache["arm_gcc.install_dir"]) / "bin"
+            cmakeArgs.append("-DCMAKE_TRY_COMPILE_TARGET_TYPE=STATIC_LIBRARY")
+            # Warning: this does not work!
+            if dsp:
+                cmakeArgs.append("-DARM_MATH_DSP=ON")
+            if mvei:
+                cmakeArgs.append("-DARM_MATH_MVEI=ON")
+            old = env["PATH"]
+            env["PATH"] = f"{armBinDir}:{old}"
+        elif params["target_arch"] == "riscv":
+            riscvPrefix = context.cache["riscv_gcc.install_dir"]
+            riscvBasename = context.cache["riscv_gcc.name"]
+            cmakeArgs.append(f"-DCMAKE_C_COMPILER={riscvPrefix}/bin/{riscvBasename}-gcc")
+            # cmakeArgs.append("-DCMAKE_CXX_COMPILER={riscvprefix}/bin/{riscvBasename}-g++")
+            # cmakeArgs.append("-DCMAKE_ASM_COMPILER={riscvprefix}/bin/{riscvBasename}-gcc")
+            # cmakeArgs.append("-DCMAKE_EXE_LINKER_FLAGS=\"'-march=rv32gc' '-mabi=ilp32d'\"")  # TODO: How about vext?
+            # cmakeArgs.append("-E env LDFLAGS=\"-march=rv32gc -mabi=ilp32d\"")
+            # cmakeArgs.append("-E env LDFLAGS=\"-march=rv32gc -mabi=ilp32d\"")
+            env["LDFLAGS"] = "-march=rv32gc -mabi=ilp32d"
+            cmakeArgs.append("-DCMAKE_SYSTEM_NAME=Generic")
+            # TODO: how about linker, objcopy, ar?
+        elif params["target_arch"] == "x86":
+            pass
+        else:
+            raise ValueError(f"Target architecture '{target_arch}' is not supported")
+
+        utils.cmake(
+            *cmakeArgs,
+            str(cmsisnnSrcDir),
+            debug=dbg,
+            cwd=cmsisnnBuildDir,
+            live=verbose,
+            env=env,
+        )
+        utils.make(cwd=cmsisnnBuildDir, threads=threads, live=verbose)
+        utils.mkdirs(cmsisnnInstallDir)
+        utils.move(cmsisnnBuildDir / "Source" / "libcmsis-nn.a", cmsisnnLib)
+    context.cache["cmsisnn.lib", flags] = cmsisnnLib

mlonmcu/setup/tasks/common.py

@@ -0,0 +1,36 @@
+#
+# 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.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+
+from mlonmcu.setup.task import TaskFactory
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.logging import get_logger
+
+logger = get_logger()
+
+Tasks = TaskFactory()
+
+
+def get_task_factory():
+    return Tasks
+
+
+def _validate_gcc(context: MlonMcuContext, params=None):
+    return context.environment.has_toolchain("gcc")

mlonmcu/setup/tasks/corstone300.py

@@ -0,0 +1,64 @@
+#
+# 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.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import multiprocessing
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import _validate_gcc, get_task_factory
+
+logger = get_logger()
+
+Tasks = get_task_factory()
+
+
+def _validate_corstone300(context: MlonMcuContext, params=None):
+    return context.environment.has_target("corstone300") and _validate_gcc(context, params=params)
+
+
+@Tasks.provides(["corstone300.exe"])
+@Tasks.validate(_validate_corstone300)
+@Tasks.register(category=TaskType.TARGET)
+def install_corstone300(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Download and install corstone300 FVP from ARM."""
+    fvpName = utils.makeDirName("corstone300")
+    fvpInstallDir = context.environment.paths["deps"].path / "install" / fvpName
+    fvpSubDir = fvpInstallDir / "fvp"
+    fvpExe = fvpSubDir / "models" / "Linux64_GCC-6.4" / "FVP_Corstone_SSE-300_Ethos-U55"
+    user_vars = context.environment.vars
+    if "corstone300.exe" in user_vars:  # TODO: also check command line flags?
+        # fvpExe = user_vars["corstone300.exe"]
+        return False
+    else:
+        if not fvpExe.is_file():
+            fvpUrl = "https://developer.arm.com/-/media/Arm%20Developer%20Community/Downloads/OSS/FVP/Corstone-300/"
+            fvpFileName = "FVP_Corstone_SSE-300_11.16_26"
+            fvpArchive = fvpFileName + ".tgz"
+            utils.download_and_extract(fvpUrl, fvpArchive, fvpInstallDir, progress=verbose)
+            fvpScript = fvpInstallDir / "FVP_Corstone_SSE-300.sh"
+            utils.exec_getout(
+                fvpScript, "--i-agree-to-the-contained-eula", "--no-interactive", "-d", fvpSubDir, print_output=False
+            )
+    context.cache["corstone300.exe"] = fvpExe

mlonmcu/setup/tasks/espidf.py

@@ -0,0 +1,87 @@
+#
+# 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.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import os
+import multiprocessing
+from pathlib import Path
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import get_task_factory
+
+logger = get_logger()
+
+Tasks = get_task_factory()
+
+
+def _validate_espidf(context: MlonMcuContext, params=None):
+    return context.environment.has_platform("espidf")
+
+
+@Tasks.provides(["espidf.src_dir"])
+@Tasks.validate(_validate_espidf)
+@Tasks.register(category=TaskType.PLATFORM)
+def clone_espidf(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Clone the ESP-IDF repository."""
+    espidfName = utils.makeDirName("espidf")
+    espidfSrcDir = context.environment.paths["deps"].path / "src" / espidfName
+    user_vars = context.environment.vars
+    if "espidf.src_dir" in user_vars:  # TODO: also check command line flags?
+        return False
+    if rebuild or not utils.is_populated(espidfSrcDir):
+        espidfRepo = context.environment.repos["espidf"]
+        utils.clone(espidfRepo.url, espidfSrcDir, branch=espidfRepo.ref, refresh=rebuild, recursive=True)
+    context.cache["espidf.src_dir"] = espidfSrcDir
+
+
+@Tasks.needs(["espidf.src_dir"])
+@Tasks.provides(["espidf.install_dir"])
+@Tasks.validate(_validate_espidf)
+@Tasks.register(category=TaskType.PLATFORM)
+def install_espidf(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Download and install target support for ESP-IDF toolchain."""
+    espidfName = utils.makeDirName("espidf")
+    espidfInstallDir = context.environment.paths["deps"].path / "install" / espidfName
+    espidfSrcDir = context.cache["espidf.src_dir"]  # TODO: This will fail if the espidf.src_dir is user-supplied
+    user_vars = context.environment.vars
+    if "espidf.install_dir" in user_vars:  # TODO: also check command line flags?
+        return False
+    boards = ["all"]
+    if "espidf.boards" in user_vars:
+        boards = user_vars["espidf.boards"]
+    if not isinstance(boards, str):
+        assert isinstance(boards, list)
+        boards = ",".join(boards)
+    if not utils.is_populated(espidfInstallDir) or rebuild:
+        # Using idf_tools.py directory instead of ./install.sh because we
+        # don't want to use espe-idfs python environment
+        espidfInstallScript = Path(espidfSrcDir) / "tools" / "idf_tools.py"
+        espidfInstallArgs = ["install", f"--targets={boards}"]
+        env = os.environ.copy()
+        env["IDF_TOOLS_PATH"] = str(espidfInstallDir)
+        utils.python(espidfInstallScript, *espidfInstallArgs, print_output=False, live=verbose, env=env)
+    context.cache["espidf.install_dir"] = espidfInstallDir

mlonmcu/setup/tasks/etiss.py

@@ -0,0 +1,147 @@
+#
+# 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.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import os
+import multiprocessing
+from pathlib import Path
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import get_task_factory
+
+logger = get_logger()
+
+Tasks = get_task_factory()
+
+
+def _validate_etiss(context: MlonMcuContext, params={}):
+    if "dbg" in params:
+        dbg = params["dbg"]
+        if dbg:
+            if not context.environment.has_feature("etissdbg"):
+                return False
+    return context.environment.has_target("etiss_pulpino")
+
+
+@Tasks.provides(["etiss.src_dir"])
+@Tasks.validate(_validate_etiss)
+@Tasks.register(category=TaskType.TARGET)
+def clone_etiss(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Clone the ETISS repository."""
+    etissName = utils.makeDirName("etiss")
+    user_vars = context.environment.vars
+    if "etiss.src_dir" in user_vars:
+        etissSrcDir = Path(user_vars["etiss.src_dir"])
+        rebuild = False
+    else:
+        etissSrcDir = context.environment.paths["deps"].path / "src" / etissName
+    if rebuild or not utils.is_populated(etissSrcDir):
+        etissRepo = context.environment.repos["etiss"]
+        utils.clone(etissRepo.url, etissSrcDir, branch=etissRepo.ref)
+    context.cache["etiss.src_dir"] = etissSrcDir
+
+
+# @Tasks.needs(["etiss.src_dir", "llvm.install_dir"])
+@Tasks.needs(["etiss.src_dir"])
+@Tasks.provides(["etiss.build_dir", "etiss.install_dir"])
+@Tasks.param("dbg", [False, True])
+@Tasks.validate(_validate_etiss)
+@Tasks.register(category=TaskType.TARGET)
+def build_etiss(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Build the ETISS simulator."""
+    if not params:
+        params = {}
+    flags = utils.makeFlags((params["dbg"], "dbg"))
+    etissName = utils.makeDirName("etiss", flags=flags)
+    etissBuildDir = context.environment.paths["deps"].path / "build" / etissName
+    etissInstallDir = context.environment.paths["deps"].path / "install" / etissName
+    # llvmInstallDir = context.cache["llvm.install_dir"]
+    user_vars = context.environment.vars
+    if "etiss.build_dir" in user_vars or "etiss.install_dir" in user_vars:
+        return False
+    if rebuild or not utils.is_populated(etissBuildDir):
+        utils.mkdirs(etissBuildDir)
+        env = os.environ.copy()
+        # env["LLVM_DIR"] = str(llvmInstallDir)
+        utils.cmake(
+            context.cache["etiss.src_dir"],
+            "-DCMAKE_INSTALL_PREFIX=" + str(etissInstallDir),
+            cwd=etissBuildDir,
+            debug=params["dbg"],
+            env=env,
+            live=verbose,
+        )
+        utils.make(cwd=etissBuildDir, threads=threads, live=verbose)
+    context.cache["etiss.build_dir", flags] = etissBuildDir
+    context.cache["etiss.install_dir", flags] = etissInstallDir
+
+
+@Tasks.needs(["etiss.build_dir"])
+@Tasks.provides(["etiss.install_dir", "etissvp.exe", "etissvp.script"])
+@Tasks.param("dbg", [False, True])
+@Tasks.validate(_validate_etiss)
+@Tasks.register(category=TaskType.TARGET)
+def install_etiss(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Install ETISS."""
+    if not params:
+        params = {}
+    user_vars = context.environment.vars
+    if "etiss.install_dir" in user_vars and "etissvp.exe" in user_vars and "etissvp.script" in user_vars:
+        return False
+    flags = utils.makeFlags((params["dbg"], "dbg"))
+    # etissName = utils.makeDirName("etiss", flags=flags)
+    etissBuildDir = context.cache["etiss.build_dir", flags]
+    etissInstallDir = context.cache["etiss.install_dir", flags]
+    etissvpExe = etissInstallDir / "bin" / "bare_etiss_processor"
+    etissvpScript = etissInstallDir / "bin" / "run_helper.sh"
+    if rebuild or not utils.is_populated(etissInstallDir) or not etissvpExe.is_file():
+        utils.make("install", cwd=etissBuildDir, threads=threads, live=verbose)
+    context.cache["etiss.install_dir", flags] = etissInstallDir
+    context.cache["etissvp.exe", flags] = etissvpExe
+    context.cache["etissvp.script", flags] = etissvpScript
+
+
+def _validate_microtvm_etissvp(context: MlonMcuContext, params=None):
+    return context.environment.has_target("microtvm_etissvp")
+
+
+@Tasks.provides(["microtvm_etissvp.src_dir", "microtvm_etissvp.template"])
+@Tasks.validate(_validate_microtvm_etissvp)
+@Tasks.register(category=TaskType.FEATURE)
+def clone_microtvm_etissvp(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Clone the microtvm-etissvp-template repository."""
+    name = utils.makeDirName("microtvm_etissvp")
+    srcDir = context.environment.paths["deps"].path / "src" / name
+    if rebuild or not utils.is_populated(srcDir):
+        repo = context.environment.repos["microtvm_etissvp"]
+        utils.clone(repo.url, srcDir, branch=repo.ref, refresh=rebuild)
+    context.cache["microtvm_etissvp.src_dir"] = srcDir
+    context.cache["microtvm_etissvp.template"] = srcDir / "template_project"

mlonmcu/setup/tasks/llvm.py

@@ -0,0 +1,67 @@
+#
+# 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.
+#
+"""Definition of tasks used to dynamically install MLonMCU dependencies"""
+
+import multiprocessing
+
+from mlonmcu.setup.task import TaskType
+from mlonmcu.context.context import MlonMcuContext
+from mlonmcu.setup import utils
+from mlonmcu.logging import get_logger
+
+from .common import get_task_factory
+
+logger = get_logger()
+
+Tasks = get_task_factory()
+
+
+def _validate_llvm(context: MlonMcuContext, params=None):
+    if context.environment.has_toolchain("llvm"):
+        return True
+    if context.environment.has_framework("tvm"):
+        user_vars = context.environment.vars
+        if "tvm.use_tlcpack" in user_vars and not user_vars["tvm.use_tlcpack"]:
+            return True
+
+
+@Tasks.provides(["llvm.install_dir"])
+@Tasks.validate(_validate_llvm)
+@Tasks.register(category=TaskType.MISC)
+def install_llvm(
+    context: MlonMcuContext, params=None, rebuild=False, verbose=False, threads=multiprocessing.cpu_count()
+):
+    """Download and install LLVM."""
+    llvmName = utils.makeDirName("llvm")
+    llvmInstallDir = context.environment.paths["deps"].path / "install" / llvmName
+    user_vars = context.environment.vars
+    if "llvm.install_dir" in user_vars:  # TODO: also check command line flags?
+        # TODO: WARNING
+        llvmInstallDir = user_vars["llvm.install_dir"]
+    else:
+        llvmVersion = user_vars.get("llvm.version", "14.0.0")
+        llvmDist = user_vars.get("llvm.distribution", "x86_64-linux-gnu-ubuntu-18.04")
+        llvmUrl = f"https://github.com/llvm/llvm-project/releases/download/llvmorg-{llvmVersion}/"
+        llvmFileName = f"clang+llvm-{llvmVersion}-{llvmDist}"
+        llvmArchive = llvmFileName + ".tar.xz"
+        # if rebuild or not utils.is_populated(llvmInstallDir):
+        # rebuild should only be triggered if the version/url changes but we can not detect that at the moment
+        if not utils.is_populated(llvmInstallDir):
+            utils.download_and_extract(llvmUrl, llvmArchive, llvmInstallDir, progress=verbose)
+    context.cache["llvm.install_dir"] = llvmInstallDir