Merge remote-tracking branch 'origin/hyperparametertuning_custom_strategies' into constrained_optimization_tunable

Author: fjwillemsen

kernel_tuner/interface.py

@@ -910,6 +910,9 @@ def tune_kernel_T1(
         adjusted_strategy_options = {k:v for k, v in strategy_options.items() if k not in filter_keys}
         optimizer_instance = optimizer_class(**adjusted_strategy_options)
         strategy = OptAlgWrapper(optimizer_instance)
+        if "constraint_aware" not in strategy_options and hasattr(optimizer_instance, "constraint_aware"):
+            # if the optimizer has a constraint_aware attribute, set it in the strategy options
+            strategy_options["constraint_aware"] = optimizer_instance.constraint_aware
 
     # set the cache path
     if cache_filepath is None and "SimulationInput" in kernelspec:

kernel_tuner/runners/simulation.py

@@ -2,6 +2,7 @@
 import logging
 from collections import namedtuple
 from time import perf_counter
+from warnings import warn
 
 from kernel_tuner import util
 from kernel_tuner.runners.runner import Runner
@@ -127,8 +128,26 @@ def run(self, parameter_space, tuning_options):
                 results.append(result)
                 continue
 
-            # if the element is not in the cache, raise an error
-            check = util.check_restrictions(tuning_options.restrictions, dict(zip(tuning_options['tune_params'].keys(), element)), True)
+            # if the configuration is not in the cache and not within restrictions, simulate an InvalidConfig with warning
+            params_dict = dict(zip(tuning_options['tune_params'].keys(), element))
+            check = util.check_restrictions(tuning_options.restrictions, params_dict, True)
+            if not check:
+                result = params_dict
+                result['compile_time'] = 0
+                result['verification_time'] = 0
+                result['benchmark_time'] = 0
+                result['strategy_time'] = self.last_strategy_time
+
+                total_time = 1000 * (perf_counter() - self.start_time)
+                self.start_time = perf_counter()
+                result['framework_time'] = total_time - self.last_strategy_time
+
+                result[tuning_options.objective] = util.InvalidConfig()
+                results.append(result)
+                warn(f"Configuration {element} not in cache, does not pass restrictions. Will be treated as an InvalidConfig, but make sure you are evaluating the correct cache file.")
+                continue
+
+            # if the configuration is not in the cache and passes restrictions, return a ValueError
             err_string = f"kernel configuration {element} not in cache, does {'' if check else 'not '}pass extra restriction check ({check})"
             logging.debug(err_string)
             raise ValueError(f"{err_string} - in simulation mode, all configurations must be present in the cache")

kernel_tuner/util.py

@@ -201,7 +201,7 @@ def check_stop_criterion(to: dict) -> float:
         StopCriterionReached: if the max_fevals is reached or time limit is exceeded.
 
     Returns:
-        float: fraction of budget spent.
+        float: fraction of budget spent. If both max_fevals and time_limit are set, it returns the fraction of time.
     """
     if "max_fevals" in to:
         if len(to.unique_results) >= to.max_fevals: