twister: use filter cache

Signed-off-by: Anas Nashif <[email protected]>

Author: nashif

scripts/pylib/twister/twisterlib/environment.py

@@ -291,6 +291,11 @@ def add_parse_arguments(parser = None):
 files in the directory will be processed. The directory should have the same
 structure in the main Zephyr tree: boards/<vendor>/<board_name>/""")
 
+    parser.add_argument(
+        "--filter-cache",
+        help="Use existing filter cache to speed up test selection."
+    )
+
     parser.add_argument(
         "--allow-installed-plugin", action="store_true", default=None,
         help="Allow to use pytest plugin installed by pip for pytest tests."

scripts/pylib/twister/twisterlib/runner.py

@@ -690,7 +690,6 @@ def run_cmake(self, args="", filter_stages=[]):
             with open(os.path.join(self.build_dir, self.log), "a", encoding=self.default_encoding) as log:
                 log_msg = out.decode(self.default_encoding)
                 log.write(log_msg)
-
         return ret
 
 
@@ -1731,10 +1730,11 @@ def add_tasks_to_queue(self, pipeline, build_only=False, test_only=False, retry_
                 if self.results.iteration > 1:
                     ProjectBuilder._add_instance_testcases_to_status_counts(instance, self.results, decrement=True)
 
-                # Check if cmake package_helper script can be run in advance.
                 instance.filter_stages = []
-                if instance.testsuite.filter:
-                    instance.filter_stages = self.get_cmake_filter_stages(instance.testsuite.filter, expr_parser.reserved.keys())
+                if not self.env.options.filter_cache:
+                    # Check if cmake package_helper script can be run in advance.
+                    if instance.testsuite.filter:
+                        instance.filter_stages = self.get_cmake_filter_stages(instance.testsuite.filter, expr_parser.reserved.keys())
 
                 if test_only and instance.run:
                     pipeline.put({"op": "run", "test": instance})

scripts/pylib/twister/twisterlib/testplan.py

@@ -7,6 +7,7 @@
 import sys
 import re
 import subprocess
+import pickle
 import glob
 import json
 import collections
@@ -35,6 +36,7 @@
 from twisterlib.statuses import TwisterStatus
 from twisterlib.testinstance import TestInstance
 from twisterlib.quarantine import Quarantine
+from twisterlib.cmakecache import CMakeCache
 
 import list_boards
 from zephyr_module import parse_modules
@@ -51,6 +53,8 @@
 sys.path.insert(0, os.path.join(ZEPHYR_BASE, "scripts/"))
 
 import scl
+import expr_parser
+
 class Filters:
     # platform keys
     PLATFORM_KEY = 'platform key filter'
@@ -99,6 +103,7 @@ def __init__(self, env=None):
 
         self.options = env.options
         self.env = env
+        self.filter_cache = {}
 
         # Keep track of which test cases we've filtered out and why
         self.testsuites = {}
@@ -267,6 +272,9 @@ def load(self):
 
             self.generate_subset(subset, int(sets))
 
+        if self.options.filter_cache:
+            logger.info(f"Using filter cache: {self.options.filter_cache}")
+
     def generate_subset(self, subset, sets):
         # Test instances are sorted depending on the context. For CI runs
         # the execution order is: "plat1-testA, plat1-testB, ...,
@@ -721,6 +729,80 @@ def check_platform(self, platform, platform_list):
                 return True
         return False
 
+    def parse_generated(self, instance):
+        config_re = re.compile('(CONFIG_[A-Za-z0-9_]+)[=]\"?([^\"]*)\"?$')
+        dt_re = re.compile('([A-Za-z0-9_]+)[=]\"?([^\"]*)\"?$')
+
+        if instance.platform.name == "unit_testing":
+            return {}
+
+        if not self.filter_cache.get(instance.platform.name):
+            cache_dir = os.path.join(self.options.filter_cache, instance.platform.normalized_name)
+            cmake_cache_path = os.path.join(cache_dir, "CMakeCache.txt")
+            defconfig_path = os.path.join(cache_dir, ".config")
+            edt_pickle = os.path.join(cache_dir, "edt.pickle")
+            defconfig = {}
+
+            if not os.path.exists(defconfig_path) and not os.path.exists(edt_pickle):
+                return None
+
+            if os.path.exists(defconfig_path):
+                with open(defconfig_path, "r") as fp:
+                    for line in fp.readlines():
+                        m = config_re.match(line)
+                        if not m:
+                            if line.strip() and not line.startswith("#"):
+                                sys.stderr.write("Unrecognized line %s\n" % line)
+                            continue
+                        defconfig[m.group(1)] = m.group(2).strip()
+
+            cmake_conf = {}
+            if os.path.exists(cmake_cache_path):
+
+                try:
+                    cache = CMakeCache.from_file(cmake_cache_path)
+                except FileNotFoundError:
+                    cache = {}
+
+                for k in iter(cache):
+                    cmake_conf[k.name] = k.value
+
+            filter_data = {
+                "ARCH": instance.platform.arch,
+                "PLATFORM": instance.platform.name
+            }
+            filter_data.update(os.environ)
+            filter_data.update(defconfig)
+            filter_data.update(cmake_conf)
+
+            if os.path.exists(edt_pickle):
+                with open(edt_pickle, 'rb') as f:
+                    edt = pickle.load(f)
+            else:
+                edt = None
+
+            self.filter_cache[instance.platform.name] = {'filter': filter_data, 'edt': edt}
+
+        if instance.testsuite and instance.testsuite.filter:
+            try:
+                edt = self.filter_cache[instance.platform.name]['edt']
+                filter_data = self.filter_cache[instance.platform.name]['filter']
+
+                ret = expr_parser.parse(instance.testsuite.filter, filter_data, edt)
+
+            except (ValueError, SyntaxError) as se:
+                sys.stderr.write(
+                    "Failed processing %s\n" % instance.testsuite.yamlfile)
+                raise se
+
+            if not ret:
+                return {os.path.join(instance.platform.name, instance.testsuite.name): True}
+            else:
+                return {os.path.join(instance.platform.name, instance.testsuite.name): False}
+        else:
+            instance.platform.filter_data = filter_data
+            return None
+
     def apply_filters(self, **kwargs):
 
         toolchain = self.env.toolchain
@@ -868,6 +950,11 @@ def apply_filters(self, **kwargs):
                 if self.options.integration and ts.integration_platforms and plat.name not in ts.integration_platforms:
                     instance.add_filter("Not part of integration platforms", Filters.TESTSUITE)
 
+                if ts.filter and self.options.filter_cache and not instance.sysbuild:
+                    filter_data = self.parse_generated(instance)
+                    if filter_data and filter_data.get(instance.name, False):
+                        instance.add_filter("Generated filter", Filters.TESTSUITE)
+
                 if ts.skip:
                     instance.add_filter("Skip filter", Filters.SKIP)