[microTVM][Zephyr] Add 'config_main_stack_size' option to API server

apps/microtvm/zephyr/template_project/microtvm_api_server.py

@@ -58,15 +58,16 @@
 
 IS_TEMPLATE = not (API_SERVER_DIR / MODEL_LIBRARY_FORMAT_RELPATH).exists()
 
+
+BOARDS = API_SERVER_DIR / "boards.json"
+
 # Data structure to hold the information microtvm_api_server.py needs
 # to communicate with each of these boards.
-BOARD_PROPERTIES = None
-BOARDS_FILE_NAME = "boards.json"
-
-with open(
-    BOARDS_FILE_NAME,
-) as board_f:
-    BOARD_PROPERTIES = json.load(board_f)
+try:
+    with open(BOARDS) as boards:
+        BOARD_PROPERTIES = json.load(boards)
+except FileNotFoundError:
+    raise FileNotFoundError(f"Board file {{{BOARDS}}} does not exist.")
 
 
 def check_call(cmd_args, *args, **kwargs):
@@ -260,12 +261,7 @@ def _get_nrf_device_args(options):
         help="Name of the Zephyr board to build for.",
     ),
     server.ProjectOption(
-        "zephyr_model",
-        choices=[board["model"] for _, board in BOARD_PROPERTIES.items()],
-        help="Name of the model for each Zephyr board.",
-    ),
-    server.ProjectOption(
-        "main_stack_size",
+        "config_main_stack_size",
         help="Sets CONFIG_MAIN_STACK_SIZE for Zephyr board.",
     ),
 ]
@@ -326,8 +322,8 @@ def _create_prj_conf(self, project_dir, options):
                 f.write("# For models with floating point.\n" "CONFIG_FPU=y\n" "\n")
 
             # Set main stack size, if needed.
-            if options["main_stack_size"] is not None:
-                f.write(f"CONFIG_MAIN_STACK_SIZE={options['main_stack_size']}\n")
+            if options.get("config_main_stack_size") is not None:
+                f.write(f"CONFIG_MAIN_STACK_SIZE={options['config_main_stack_size']}\n")
 
             f.write("# For random number generation.\n" "CONFIG_TEST_RANDOM_GENERATOR=y\n")
 
@@ -355,9 +351,7 @@ def generate_project(self, model_library_format_path, standalone_crt_dir, projec
         shutil.copy2(__file__, project_dir / os.path.basename(__file__))
 
         # Copy boards.json file to generated project.
-        shutil.copy2(
-            pathlib.Path(__file__).parent / BOARDS_FILE_NAME, project_dir / BOARDS_FILE_NAME
-        )
+        shutil.copy2(BOARDS, project_dir / BOARDS.name)
 
         # Place Model Library Format tarball in the special location, which this script uses to decide
         # whether it's being invoked in a template or generated project.

python/tvm/micro/project.py

@@ -103,20 +103,11 @@ def __init__(self, api_client):
 
     def _check_project_options(self, options: dict):
         """Check if options are valid ProjectOptions"""
-        valid_project_options = [item["name"] for item in self.info()["project_options"]]
-        valid = True
-
-        if options is not None:
-            if valid_project_options is None:
-                valie = False
-            else:
-                if not all(element in list(valid_project_options) for element in list(options)):
-                    valid = False
-
-        if not valid:
+        available_options = [option["name"] for option in self.info()["project_options"]]
+        if options and not set(options.keys()).issubset(available_options):
             raise ValueError(
-                f"""options:{list(options)} include none valid ProjectOptions.
-                        Here is a list of valid options:{list(valid_project_options)}."""
+                f"""options:{list(options)} include non valid ProjectOptions.
+                        Here is a list of available options:{list(available_options)}."""
             )
 
     def generate_project_from_mlf(self, model_library_format_path, project_dir, options):

tests/micro/zephyr/conftest.py

@@ -17,68 +17,19 @@
 import datetime
 import os
 import pathlib
-import json
 
 import pytest
 
-from tvm.micro import project
-import tvm.contrib.utils
-import tvm.target.target
+import test_utils
 
-TEMPLATE_PROJECT_DIR = (
-    pathlib.Path(__file__).parent
-    / ".."
-    / ".."
-    / ".."
-    / "apps"
-    / "microtvm"
-    / "zephyr"
-    / "template_project"
-).resolve()
-
-BOARD_JSON_PATH = TEMPLATE_PROJECT_DIR / "boards.json"
-
-
-def zephyr_boards() -> dict:
-    """Returns a dict mapping board to target model"""
-    template = project.TemplateProject.from_directory(TEMPLATE_PROJECT_DIR)
-    project_options = template.info()["project_options"]
-    for option in project_options:
-        if option["name"] == "zephyr_board":
-            boards = option["choices"]
-        if option["name"] == "zephyr_model":
-            models = option["choices"]
-
-    arduino_boards = {boards[i]: models[i] for i in range(len(boards))}
-    return arduino_boards
-
-
-ZEPHYR_BOARDS = zephyr_boards()
-
-
-def qemu_boards(board: str):
-    """Returns True if board is QEMU."""
-    with open(BOARD_JSON_PATH) as f:
-        board_properties = json.load(f)
-
-    qemu_boards = [name for name, board in board_properties.items() if board["is_qemu"]]
-    return board in qemu_boards
-
-
-def has_fpu(board: str):
-    """Returns True if board has FPU."""
-    with open(BOARD_JSON_PATH) as f:
-        board_properties = json.load(f)
-
-    fpu_boards = [name for name, board in board_properties.items() if board["fpu"]]
-    return board in fpu_boards
+from tvm.contrib.utils import tempdir
 
 
 def pytest_addoption(parser):
     parser.addoption(
         "--zephyr-board",
         required=True,
-        choices=ZEPHYR_BOARDS.keys(),
+        choices=test_utils.ZEPHYR_BOARDS.keys(),
         help=("Zephyr board for test."),
     )
     parser.addoption(
@@ -125,4 +76,4 @@ def temp_dir(board):
     if not os.path.exists(board_workspace.parent):
         os.makedirs(board_workspace.parent)
 
-    return tvm.contrib.utils.tempdir(board_workspace)
+    return tempdir(board_workspace)

tests/micro/zephyr/test_utils.py

@@ -0,0 +1,62 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you 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 json
+import pathlib
+
+
+TEMPLATE_PROJECT_DIR = (
+    pathlib.Path(__file__).parent
+    / ".."
+    / ".."
+    / ".."
+    / "apps"
+    / "microtvm"
+    / "zephyr"
+    / "template_project"
+).resolve()
+
+BOARDS = TEMPLATE_PROJECT_DIR / "boards.json"
+
+
+def zephyr_boards() -> dict:
+    """Returns a dict mapping board to target model"""
+    with open(BOARDS) as f:
+        board_properties = json.load(f)
+
+    boards_model = {board: info["model"] for board, info in board_properties.items()}
+    return boards_model
+
+
+ZEPHYR_BOARDS = zephyr_boards()
+
+
+def qemu_boards(board: str):
+    """Returns True if board is QEMU."""
+    with open(BOARDS) as f:
+        board_properties = json.load(f)
+
+    qemu_boards = [name for name, board in board_properties.items() if board["is_qemu"]]
+    return board in qemu_boards
+
+
+def has_fpu(board: str):
+    """Returns True if board has FPU."""
+    with open(BOARDS) as f:
+        board_properties = json.load(f)
+
+    fpu_boards = [name for name, board in board_properties.items() if board["fpu"]]
+    return board in fpu_boards