Improved passing of restrictions

Author: fjwillemsen

kernel_tuner/interface.py

@@ -646,7 +646,6 @@ def tune_kernel(
 
         # ensure strategy_options is an Options object
         tuning_options.strategy_options = Options(strategy_options or {})
-
     # if no strategy selected
     else:
         strategy = brute_force

kernel_tuner/searchspace.py

@@ -5,6 +5,7 @@
 from random import choice, shuffle
 from typing import List, Union
 from warnings import warn
+from copy import deepcopy
 
 import numpy as np
 from constraint import (
@@ -92,10 +93,11 @@ def __init__(
         self._tensorspace_param_config_structure = []
         self._map_tensor_to_param = {}
         self._map_param_to_tensor = {}
-        self.restrictions = restrictions.copy() if hasattr(restrictions, "copy") else restrictions
-        self.original_restrictions = restrictions.copy() if hasattr(restrictions, "copy") else restrictions
+        restrictions = list(restrictions) if not isinstance(restrictions, (list, tuple)) else restrictions
+        self.restrictions = deepcopy(restrictions)
+        self.original_restrictions = deepcopy(restrictions)  # keep the original restrictions, so that the searchspace can be modified later
         # the searchspace can add commonly used constraints (e.g. maxprod(blocks) <= maxthreads)
-        self._modified_restrictions = restrictions.copy() if hasattr(restrictions, "copy") else restrictions
+        self._modified_restrictions = deepcopy(restrictions)
         self.param_names = list(self.tune_params.keys())
         self.params_values = tuple(tuple(param_vals) for param_vals in self.tune_params.values())
         self.params_values_indices = None
@@ -479,8 +481,9 @@ def __build_searchspace(self, block_size_names: list, max_threads: int, solver:
 
     def __add_restrictions(self, parameter_space: Problem) -> Problem:
         """Add the user-specified restrictions as constraints on the parameter space."""
-        if isinstance(self.restrictions, list):
-            for restriction in self.restrictions:
+        restrictions = deepcopy(self.restrictions)
+        if isinstance(restrictions, list):
+            for restriction in restrictions:
                 required_params = self.param_names
 
                 # (un)wrap where necessary
@@ -510,14 +513,14 @@ def __add_restrictions(self, parameter_space: Problem) -> Problem:
                     raise ValueError(f"Unrecognized restriction type {type(restriction)} ({restriction})")
 
         # if the restrictions are the old monolithic function, apply them directly (only for backwards compatibility, likely slower than well-specified constraints!)
-        elif callable(self.restrictions):
+        elif callable(restrictions):
 
             def restrictions_wrapper(*args):
-                return check_instance_restrictions(self.restrictions, dict(zip(self.param_names, args)), False)
+                return check_instance_restrictions(restrictions, dict(zip(self.param_names, args)), False)
 
             parameter_space.addConstraint(FunctionConstraint(restrictions_wrapper), self.param_names)
-        elif self.restrictions is not None:
-            raise ValueError(f"The restrictions are of unsupported type {type(self.restrictions)}")
+        elif restrictions is not None:
+            raise ValueError(f"The restrictions are of unsupported type {type(restrictions)}")
         return parameter_space
 
     def __parse_restrictions_pysmt(self, restrictions: list, tune_params: dict, symbols: dict):

test/strategies/test_strategies.py

@@ -67,7 +67,11 @@ def test_strategies(vector_add, strategy):
     if strategy != "brute_force":
         filter_options["max_fevals"] = 10
 
-    restrictions = ["test_string == 'alg_2'", "test_bool == True", "test_mixed == 2.45"]
+    restrictions = [
+        "test_string == 'alg_2'", 
+        "test_bool == True", 
+        "test_mixed == 2.45"
+    ]
 
     # pyATF can't handle non-number tune parameters, so we filter them out
     cache_filename_local = cache_filename
@@ -81,6 +85,7 @@ def test_strategies(vector_add, strategy):
 
     # run the tuning in simulation mode
     assert cache_filename_local.exists()
+    assert restrictions is not None
     results, _ = kernel_tuner.tune_kernel(*vector_add, restrictions=restrictions, strategy=strategy, strategy_options=filter_options,
                                          verbose=False, cache=cache_filename_local, simulation_mode=True)
 
@@ -123,15 +128,10 @@ def test_strategies(vector_add, strategy):
     x0 = [256]
     filter_options["x0"] = x0
     if not strategy in ["brute_force", "random_sample", "bayes_opt"]:
-        results, _ = kernel_tuner.tune_kernel(*vector_add, strategy=strategy, strategy_options=filter_options,
+        results, _ = kernel_tuner.tune_kernel(*vector_add, restrictions=restrictions, strategy=strategy, strategy_options=filter_options,
                                             verbose=False, cache=cache_filename, simulation_mode=True)
         assert results[0]["block_size_x"] == x0[0]
     else:
         with pytest.raises(ValueError):
-            results, _ = kernel_tuner.tune_kernel(*vector_add, strategy=strategy, strategy_options=filter_options,
+            results, _ = kernel_tuner.tune_kernel(*vector_add, restrictions=restrictions, strategy=strategy, strategy_options=filter_options,
                                             verbose=False, cache=cache_filename, simulation_mode=True)
-
-
-
-
-