Merge branch 'master' into parallel_runner

Author: isazi

kernel_tuner/integration.py

@@ -11,6 +11,9 @@
 objective_default_map = {
     "time": False,
     "energy": False,
+    "fitness": True,
+    "cost": False,
+    "loss": False,
     "GFLOP/s": True,
     "TFLOP/s": True,
     "GB/s": True,

kernel_tuner/strategies/bayes_opt.py

@@ -110,7 +110,7 @@ def tune(searchspace: Searchspace, runner, tuning_options):
     :rtype: list(dict()), dict()
 
     """
-    # we don't actually use this for Bayesian Optimization, but it is used to check for unsupported options  
+    # we don't actually use this for Bayesian Optimization, but it is used to check for unsupported options
     get_options(tuning_options.strategy_options, _options, unsupported=["x0"])
 
     max_fevals = tuning_options.strategy_options.get("max_fevals", 100)
@@ -145,7 +145,13 @@ def tune(searchspace: Searchspace, runner, tuning_options):
     # initialize and optimize
     try:
         bo = BayesianOptimization(
-            parameter_space, searchspace, removed_tune_params, tuning_options, normalize_dict, denormalize_dict, cost_func
+            parameter_space,
+            searchspace,
+            removed_tune_params,
+            tuning_options,
+            normalize_dict,
+            denormalize_dict,
+            cost_func,
         )
     except StopCriterionReached:
         warnings.warn(
@@ -851,7 +857,10 @@ def __optimize_multi_ultrafast(self, max_fevals, predict_eval_ratio=5):
         while self.fevals < max_fevals:
             aqfs = self.multi_afs
             # if we take the prediction only once, we want to go from most exploiting to most exploring, because the more exploiting an AF is, the more it relies on non-stale information from the model
-            fit_observations = last_prediction_time * predict_eval_ratio <= last_eval_time or last_prediction_counter >= predict_eval_ratio
+            fit_observations = (
+                last_prediction_time * predict_eval_ratio <= last_eval_time
+                or last_prediction_counter >= predict_eval_ratio
+            )
             if fit_observations:
                 last_prediction_counter = 0
                 pred_start = time.perf_counter()

kernel_tuner/strategies/common.py

@@ -94,9 +94,9 @@ def __call__(self, x, check_restrictions=True):
 
         # else check if this is a legal (non-restricted) configuration
         if check_restrictions and self.searchspace.restrictions:
-            params_dict = dict(zip(self.searchspace.tune_params.keys(), params))
-            legal = util.check_restrictions(self.searchspace.restrictions, params_dict, self.tuning_options.verbose)
+            legal = self.searchspace.is_param_config_valid(tuple(params))
             if not legal:
+                params_dict = dict(zip(self.searchspace.tune_params.keys(), params))
                 result = params_dict
                 result[self.tuning_options.objective] = util.InvalidConfig()
 

kernel_tuner/util.py

@@ -528,7 +528,8 @@ def get_kernel_string(kernel_source, params=None):
         kernel_string = read_file(kernel_source)
     elif isinstance(kernel_source, str):
         if looks_like_a_filename(kernel_source):
-            kernel_string = read_file(kernel_source) or kernel_source
+            with open(kernel_source, "r") as f:
+                kernel_string = f.read()
         else:
             kernel_string = kernel_source
     else:
@@ -1123,6 +1124,10 @@ def compile_restrictions(
             noncompiled_restrictions.append((r, [], r))
     return noncompiled_restrictions + compiled_restrictions
 
+def check_matching_problem_size(cached_problem_size, problem_size):
+    """Check the if requested problem size matches the problem size in the cache."""
+    if not (np.array(cached_problem_size) == np.array(problem_size)).all():
+        raise ValueError(f"Cannot load cache which contains results for different problem_size, cache: {cached_problem_size}, requested: {problem_size}")
 
 def process_cache(cache, kernel_options, tuning_options, runner):
     """Cache file for storing tuned configurations.
@@ -1193,18 +1198,7 @@ def process_cache(cache, kernel_options, tuning_options, runner):
                 f"Cannot load cache which contains results for different kernel (cache: {cached_data['kernel_name']}, actual: {kernel_options.kernel_name})"
             )
         if "problem_size" in cached_data and not callable(kernel_options.problem_size):
-            # if it's a single value, convert to an array
-            if isinstance(cached_data["problem_size"], int):
-                cached_data["problem_size"] = [cached_data["problem_size"]]
-            # if problem_size is not iterable, compare directly
-            if not hasattr(kernel_options.problem_size, "__iter__"):
-                if cached_data["problem_size"] != kernel_options.problem_size:
-                    raise ValueError("Cannot load cache which contains results for different problem_size")
-            # else (problem_size is iterable)
-            # cache returns list, problem_size is likely a tuple. Therefore, the next check
-            # checks the equality of all items in the list/tuples individually
-            elif not all([i == j for i, j in zip(cached_data["problem_size"], kernel_options.problem_size)]):
-                raise ValueError("Cannot load cache which contains results for different problem_size")
+            check_matching_problem_size(cached_data["problem_size"], kernel_options.problem_size)
         if cached_data["tune_params_keys"] != list(tuning_options.tune_params.keys()):
             if all(key in tuning_options.tune_params for key in cached_data["tune_params_keys"]):
                 raise ValueError(

test/test_util_functions.py

@@ -541,10 +541,10 @@ def gen_kernel(params):
 
 def test_get_kernel_string_filename_not_found():
     # when the string looks like a filename, but the file does not exist
-    # assume the string is not a filename after all
+    # check if throws an exception
     bogus_filename = "filename_3456789.cu"
-    answer = get_kernel_string(bogus_filename)
-    assert answer == bogus_filename
+    with pytest.raises(FileNotFoundError):
+        get_kernel_string(bogus_filename)
 
 
 def test_looks_like_a_filename1():
@@ -742,6 +742,24 @@ def test_parse_restrictions():
     assert all(param in tune_params for param in params)
 
 
+def test_check_matching_problem_size():
+    # these should error
+    with pytest.raises(ValueError):
+        check_matching_problem_size(42, 1000)
+    with pytest.raises(ValueError):
+        check_matching_problem_size([42,1], 42)
+    with pytest.raises(ValueError):
+        check_matching_problem_size([42,0], 42)
+    with pytest.raises(ValueError):
+        check_matching_problem_size(None, 42)
+    # these should not error
+    check_matching_problem_size(1000, (1000,))
+    check_matching_problem_size([1000], 1000)
+    check_matching_problem_size(1000, 1000)
+    check_matching_problem_size(1000, [1000])
+    check_matching_problem_size([1000,], 1000)
+
+
 def test_convert_constraint_lambdas():
 
     restrictions = [lambda p: 32 <= p["block_size_x"]*p["block_size_y"] <= 1024,