Removed direct os.remove usage, updated to current master

Author: fjwillemsen

test/test_file_utils.py

@@ -1,9 +1,9 @@
 from kernel_tuner.file_utils import store_output_file, store_metadata_file, output_file_schema, validate
+from kernel_tuner.util import delete_temp_file
 from .test_integration import fake_results
 from .test_runners import env, cache_filename, tune_kernel
 import pytest
 import json
-import os
 
 
 def test_store_output_file(env):
@@ -24,7 +24,7 @@ def test_store_output_file(env):
     validate(output_json, schema=schema)
 
     # clean up
-    os.remove(filename)
+    delete_temp_file(filename)
 
 
 def test_store_metadata_file():
@@ -46,4 +46,4 @@ def test_store_metadata_file():
     validate(metadata_json, schema=schema)
 
     # clean up
-    os.remove(filename)
+    delete_temp_file(filename)

test/test_runners.py

@@ -5,11 +5,14 @@
 import numpy as np
 import pytest
 
-from kernel_tuner import util, tune_kernel
+from kernel_tuner import util, tune_kernel, core
+from kernel_tuner.interface import Options, _kernel_options, _device_options, _tuning_options
+from kernel_tuner.runners.sequential import SequentialRunner
 
 from .context import skip_if_no_pycuda
 
-cache_filename = os.path.dirname(os.path.realpath(__file__)) + "/test_cache_file.json"
+cache_filename = os.path.dirname(
+    os.path.realpath(__file__)) + "/test_cache_file.json"
 
 
 @pytest.fixture
@@ -61,37 +64,55 @@ def test_sequential_runner_alt_block_size_names(env):
 
     block_size_names = ["block_dim_x"]
 
-    result, _ = tune_kernel(*env, grid_div_x=["block_dim_x"], answer=answer, block_size_names=block_size_names)
+    result, _ = tune_kernel(*env,
+                            grid_div_x=["block_dim_x"],
+                            answer=answer,
+                            block_size_names=block_size_names)
 
     assert len(result) == len(tune_params["block_dim_x"])
 
 
 @skip_if_no_pycuda
 def test_smem_args(env):
-    result, _ = tune_kernel(*env, smem_args=dict(size="block_size_x*4"), verbose=True)
+    result, _ = tune_kernel(*env,
+                            smem_args=dict(size="block_size_x*4"),
+                            verbose=True)
     tune_params = env[-1]
     assert len(result) == len(tune_params["block_size_x"])
-    result, _ = tune_kernel(*env, smem_args=dict(size=lambda p: p['block_size_x'] * 4), verbose=True)
+    result, _ = tune_kernel(
+        *env,
+        smem_args=dict(size=lambda p: p['block_size_x'] * 4),
+        verbose=True)
     tune_params = env[-1]
     assert len(result) == len(tune_params["block_size_x"])
 
 
 @skip_if_no_pycuda
 def test_build_cache(env):
     if not os.path.isfile(cache_filename):
-        result, _ = tune_kernel(*env, cache=cache_filename, verbose=False, quiet=True)
+        result, _ = tune_kernel(*env,
+                                cache=cache_filename,
+                                verbose=False,
+                                quiet=True)
         tune_params = env[-1]
         assert len(result) == len(tune_params["block_size_x"])
 
 
 def test_simulation_runner(env):
     kernel_name, kernel_string, size, args, tune_params = env
     start = time.perf_counter()
-    result, res_env = tune_kernel(*env, cache=cache_filename, strategy="random_sample", simulation_mode=True, strategy_options=dict(fraction=1))
-    actual_time = (time.perf_counter() - start) * 1e3    # ms
+    result, res_env = tune_kernel(*env,
+                                  cache=cache_filename,
+                                  strategy="random_sample",
+                                  simulation_mode=True,
+                                  strategy_options=dict(fraction=1))
+    actual_time = (time.perf_counter() - start) * 1e3  # ms
     assert len(result) == len(tune_params["block_size_x"])
 
-    timings = ['total_framework_time', 'total_strategy_time', 'total_compile_time', 'total_benchmark_time', 'overhead_time']
+    timings = [
+        'total_framework_time', 'total_strategy_time', 'total_compile_time',
+        'total_benchmark_time', 'overhead_time'
+    ]
 
     # ensure all keys are there and non zero
     assert all(key in res_env for key in timings)
@@ -111,7 +132,12 @@ def test_simulation_runner(env):
 
 
 def test_diff_evo(env):
-    result, _ = tune_kernel(*env, strategy="diff_evo", strategy_options=dict(popsize=5), verbose=True, cache=cache_filename, simulation_mode=True)
+    result, _ = tune_kernel(*env,
+                            strategy="diff_evo",
+                            strategy_options=dict(popsize=5),
+                            verbose=True,
+                            cache=cache_filename,
+                            simulation_mode=True)
     assert len(result) > 0
 
 
@@ -120,14 +146,25 @@ def test_time_keeping(env):
     kernel_name, kernel_string, size, args, tune_params = env
     answer = [args[1] + args[2], None, None, None]
 
-    options = dict(method="uniform", popsize=10, maxiter=1, mutation_chance=1, max_fevals=10)
+    options = dict(method="uniform",
+                   popsize=10,
+                   maxiter=1,
+                   mutation_chance=1,
+                   max_fevals=10)
     start = time.perf_counter()
-    result, env = tune_kernel(*env, strategy="genetic_algorithm", strategy_options=options, verbose=True, answer=answer)
-    max_time = (time.perf_counter() - start) * 1e3    # ms
+    result, env = tune_kernel(*env,
+                              strategy="genetic_algorithm",
+                              strategy_options=options,
+                              verbose=True,
+                              answer=answer)
+    max_time = (time.perf_counter() - start) * 1e3  # ms
 
     assert len(result) >= 10
 
-    timings = ['total_framework_time', 'total_strategy_time', 'total_compile_time', 'total_verification_time', 'total_benchmark_time', 'overhead_time']
+    timings = [
+        'total_framework_time', 'total_strategy_time', 'total_compile_time',
+        'total_verification_time', 'total_benchmark_time', 'overhead_time'
+    ]
 
     # ensure all keys are there and non zero
     assert all(key in env for key in timings)
@@ -142,15 +179,27 @@ def test_time_keeping(env):
 
 
 def test_bayesian_optimization(env):
-    for method in ["poi", "ei", "lcb", "lcb-srinivas", "multi", "multi-advanced", "multi-fast"]:
+    for method in [
+            "poi", "ei", "lcb", "lcb-srinivas", "multi", "multi-advanced",
+            "multi-fast"
+    ]:
         print(method, flush=True)
         options = dict(popsize=5, max_fevals=10, method=method)
-        result, _ = tune_kernel(*env, strategy="bayes_opt", strategy_options=options, verbose=True, cache=cache_filename, simulation_mode=True)
+        result, _ = tune_kernel(*env,
+                                strategy="bayes_opt",
+                                strategy_options=options,
+                                verbose=True,
+                                cache=cache_filename,
+                                simulation_mode=True)
         assert len(result) > 0
 
 
 def test_random_sample(env):
-    result, _ = tune_kernel(*env, strategy="random_sample", strategy_options={ "fraction": 0.1 }, cache=cache_filename, simulation_mode=True)
+    result, _ = tune_kernel(*env,
+                            strategy="random_sample",
+                            strategy_options={"fraction": 0.1},
+                            cache=cache_filename,
+                            simulation_mode=True)
     # check that number of benchmarked kernels is 10% (rounded up)
     assert len(result) == 2
     # check all returned results make sense
@@ -182,7 +231,66 @@ def test_interface_handles_compile_failures(env):
     }
     """
 
-    results, env = tune_kernel(kernel_name, kernel_string, size, args, tune_params, verbose=True)
+    results, env = tune_kernel(kernel_name,
+                               kernel_string,
+                               size,
+                               args,
+                               tune_params,
+                               verbose=True)
 
-    failed_config = [record for record in results if record["block_size_x"] == 256][0]
+    failed_config = [
+        record for record in results if record["block_size_x"] == 256
+    ][0]
     assert isinstance(failed_config["time"], util.CompilationFailedConfig)
+
+
+@skip_if_no_pycuda
+def test_runner(env):
+
+    kernel_name, kernel_source, problem_size, arguments, tune_params = env
+
+    # create KernelSource
+    kernelsource = core.KernelSource(kernel_name,
+                                     kernel_source,
+                                     lang=None,
+                                     defines=None)
+
+    # create option bags
+    device = 0
+    atol = 1e-6
+    platform = 0
+    iterations = 7
+    verbose = False
+    objective = "time"
+    opts = locals()
+    kernel_options = Options([(k, opts.get(k, None))
+                              for k in _kernel_options.keys()])
+    tuning_options = Options([(k, opts.get(k, None))
+                              for k in _tuning_options.keys()])
+    device_options = Options([(k, opts.get(k, None))
+                              for k in _device_options.keys()])
+    tuning_options.cachefile = None
+
+    # create runner
+    runner = SequentialRunner(kernelsource,
+                              kernel_options,
+                              device_options,
+                              iterations,
+                              observers=None)
+    runner.warmed_up = True  # disable warm up for this test
+
+    # select a config to run
+    searchspace = []
+
+    # insert configurations to run with this runner in this list
+    # each configuration is described as a list of values, one for each tunable parameter
+    # the order should correspond to the order of parameters specified in tune_params
+    searchspace.append(
+        [32])  # vector_add only has one tunable parameter (block_size_x)
+
+    # call the runner
+    results, _ = runner.run(searchspace, kernel_options, tuning_options)
+
+    assert len(results) == 1
+    assert results[0]['block_size_x'] == 32
+    assert len(results[0]['times']) == iterations