Fix tests to work with new constructor for Searchspace

Author: stijnh

kernel_tuner/searchspace.py

@@ -47,7 +47,7 @@ def __init__(
         if neighbor_method is not None and neighbor_method != "Hamming":
             self.__prepare_neighbors_index()
         if build_neighbors_index:
-            self.neighbors_index = self.__build_neighbors_index(neighbor_method, max_threads)
+            self.neighbors_index = self.__build_neighbors_index(neighbor_method)
 
     def __build_searchspace(self, block_size_names: list, max_threads: int) -> Tuple[List[tuple], np.ndarray, dict, int]:
         """compute valid configurations in a search space based on restrictions and max_threads, returns the searchspace, a dict of the searchspace for fast lookups and the size"""

test/strategies/test_common.py

@@ -26,9 +26,8 @@ def fake_runner():
 tune_params = OrderedDict([("x", [1, 2, 3]), ("y", [4, 5, 6])])
 
 
-def test__cost_func():
+def test_cost_func():
     x = [1, 4]
-    kernel_options = None
     tuning_options = Options(scaling=False, snap=False, tune_params=tune_params,
                              restrictions=None, strategy_options={}, cache={}, unique_results={},
                              objective="time", objective_higher_is_better=False, metrics=None)
@@ -39,12 +38,12 @@ def test__cost_func():
     assert time == 5
 
     # check if restrictions are properly handled
-    restrictions = ["False"]
+    restrictions = lambda _: False
     tuning_options = Options(scaling=False, snap=False, tune_params=tune_params,
                              restrictions=restrictions, strategy_options={},
                              verbose=True, cache={}, unique_results={},
                              objective="time", objective_higher_is_better=False, metrics=None)
-    time = CostFunc(Searchspace(tune_params, None, 1024), tuning_options, runner)(x)
+    time = CostFunc(Searchspace(tune_params, restrictions, 1024), tuning_options, runner)(x)
     assert time == sys.float_info.max
 
 

test/test_common.py

@@ -39,7 +39,9 @@ def test_get_bounds():
         random.shuffle(tune_params[k])
 
     expected = [(0, 4), (0, 9900), (-11.2, 123.27)]
-    answer = common.get_bounds(tune_params)
+    searchspace = Searchspace(tune_params, None, 1024)
+    cost_func = common.CostFunc(searchspace, None, None)
+    answer = cost_func.get_bounds()
     assert answer == expected
 
 

test/test_runners.py

@@ -290,7 +290,7 @@ def test_runner(env):
         [32])  # vector_add only has one tunable parameter (block_size_x)
 
     # call the runner
-    results, _ = runner.run(searchspace, kernel_options, tuning_options)
+    results = runner.run(searchspace, tuning_options)
 
     assert len(results) == 1
     assert results[0]['block_size_x'] == 32

test/test_searchspace.py

@@ -52,7 +52,6 @@ def min_func(gpu1, gpu2, gpu3, gpu4):
 sort_tune_params["gpu1"] = list(range(num_layers))
 sort_tune_params["gpu2"] = list(range(num_layers))
 sort_tune_params["gpu3"] = list(range(num_layers))
-sort_tuning_options = Options(dict(restrictions=[], tune_params=sort_tune_params))
 searchspace_sort = Searchspace(sort_tune_params, [], max_threads)
 
 def test_size():
@@ -73,8 +72,13 @@ def test_internal_representation():
 
 def test_sort():
     """test that the sort searchspace option works as expected"""
-    simple_searchspace_sort = Searchspace(simple_tuning_options.tune_params, simple_tuning_options.restrictions, max_threads, sort=True, sort_last_param_first=False)
-    assert simple_searchspace_sort.list == [
+    simple_searchspace_sort = Searchspace(
+        simple_tuning_options.tune_params,
+        simple_tuning_options.restrictions,
+        max_threads
+    )
+
+    expected = [
         (1, 4, "string_1"),
         (1, 4, "string_2"),
         (1, 5.5, "string_1"),
@@ -89,7 +93,11 @@ def test_sort():
         (3, 5.5, "string_2"),
     ]
 
-    assert simple_searchspace.sorted_list(sort_last_param_first=False) == expected
+    # Check if lists match without considering order
+    assert set(simple_searchspace_sort.list) == set(expected)
+
+    # Check if lists match, also considering order
+    assert simple_searchspace_sort.sorted_list() == expected
 
     sorted_list = searchspace_sort.sorted_list(sort_last_param_first=False)
     num_params = len(sorted_list[0])
@@ -102,8 +110,13 @@ def test_sort():
 
 def test_sort_reversed():
     """test that the sort searchspace option with the sort_last_param_first option enabled works as expected"""
-    simple_searchspace_sort_reversed = Searchspace(simple_tuning_options, max_threads, sort=True, sort_last_param_first=True)
-    assert simple_searchspace_sort_reversed.list == [
+    simple_searchspace_sort_reversed = Searchspace(
+        simple_tuning_options.tune_params,
+        simple_tuning_options.restrictions,
+        max_threads
+    )
+
+    expected = [
         (1, 4, "string_1"),
         (2, 4, "string_1"),
         (3, 4, "string_1"),
@@ -118,6 +131,10 @@ def test_sort_reversed():
         (3, 5.5, "string_2"),
     ]
 
+    # Check if lists match without considering order
+    assert set(simple_searchspace_sort_reversed.list) == set(expected)
+
+    # Check if lists match, also considering order
     assert simple_searchspace_sort_reversed.sorted_list(sort_last_param_first=True) == expected
 
     sorted_list = searchspace_sort.sorted_list(sort_last_param_first=True)
@@ -178,7 +195,8 @@ def test_random_sample():
 
 def __test_neighbors_prebuilt(param_config: tuple, expected_neighbors: list, neighbor_method: str):
     simple_searchspace_prebuilt = Searchspace(
-        simple_tuning_options,
+        simple_tuning_options.tune_params,
+        simple_tuning_options.restrictions,
         max_threads,
         build_neighbors_index=True,
         neighbor_method=neighbor_method,
@@ -271,7 +289,13 @@ def test_neighbors_fictious():
 
 def test_neighbors_cached():
     """test whether retrieving a set of neighbors twice returns the cached version"""
-    simple_searchspace_duplicate = Searchspace(simple_tuning_options, max_threads, neighbor_method="Hamming")
+    simple_searchspace_duplicate = Searchspace(
+        simple_tuning_options.tune_params,
+        simple_tuning_options.restrictions,
+        max_threads,
+        neighbor_method="Hamming"
+    )
+
     test_configs = simple_searchspace_duplicate.get_random_sample(10)
     for test_config in test_configs:
         assert not simple_searchspace_duplicate.are_neighbors_indices_cached(test_config)