Merge branch 'master' of github.com:benvanwerkhoven/kernel_tuner into skip_nvml_tests

Author: benvanwerkhoven

kernel_tuner/file_utils.py

@@ -131,7 +131,7 @@ def store_output_file(output_filename, results, tune_params, objective="time"):
     version, _ = output_file_schema("results")
     output_json = dict(results=output_data, schema_version=version)
     with open(output_filename, 'w+') as fh:
-        json.dump(output_json, fh)
+        json.dump(output_json, fh, cls=util.NpEncoder)
 
 
 def get_dependencies(package='kernel_tuner'):
@@ -184,15 +184,19 @@ def store_metadata_file(metadata_filename):
     metadata_filename = filename_ensure_json_extension(metadata_filename)
     metadata = {}
 
-    # lshw only works on Linux, this intentionally raises a FileNotFoundError when ran on systems that do not have it
-    lshw_out = subprocess.run(["lshw", "-json"], capture_output=True)
+    # lshw only works on Linux
+    try:
+        lshw_out = subprocess.run(["lshw", "-json"], capture_output=True)
 
-    # sometimes lshw outputs a list of length 1, sometimes just as a dict, schema wants a list
-    lshw_string = lshw_out.stdout.decode('utf-8').strip()
-    if lshw_string[0] == '{' and lshw_string[-1] == '}':
-        lshw_string = '[' + lshw_string + ']'
+        # sometimes lshw outputs a list of length 1, sometimes just as a dict, schema wants a list
+        lshw_string = lshw_out.stdout.decode('utf-8').strip()
+        if lshw_string[0] == '{' and lshw_string[-1] == '}':
+            lshw_string = '[' + lshw_string + ']'
+        hardware_desc = dict(lshw=json.loads(lshw_string))
+    except:
+        hardware_desc = dict(lshw=["lshw error"])
 
-    metadata["hardware"] = dict(lshw=json.loads(lshw_string))
+    metadata["hardware"] = hardware_desc
 
     # attempts to use nvidia-smi or rocm-smi if present
     device_query = {}

kernel_tuner/observers/powersensor.py

@@ -2,17 +2,17 @@
 
 from kernel_tuner.observers.observer import BenchmarkObserver
 
-# check if power_sensor is installed
+# check if powersensor is installed
 try:
-    import power_sensor
+    import powersensor
 except ImportError:
-    power_sensor = None
+    powersensor = None
 
 
 class PowerSensorObserver(BenchmarkObserver):
     """Observer that an external PowerSensor2 device to accurately measure power
 
-    Requires PowerSensor2 hardware and power_sensor Python bindings.
+    Requires PowerSensor2 hardware and powersensor Python bindings.
 
     :param observables: A list of string, containing any of "ps_energy" or "ps_power".
         To measure energy in Joules or power consumption in Watt.
@@ -25,8 +25,8 @@ class PowerSensorObserver(BenchmarkObserver):
     """
 
     def __init__(self, observables=None, device=None):
-        if not power_sensor:
-            raise ImportError("could not import power_sensor")
+        if not powersensor:
+            raise ImportError("could not import powersensor")
 
         supported = ["ps_energy", "ps_power"]
         for obs in observables:
@@ -35,18 +35,18 @@ def __init__(self, observables=None, device=None):
         self.observables = observables or ["ps_energy"]
 
         device = device or "/dev/ttyACM0"
-        self.ps = power_sensor.PowerSensor(device)
+        self.ps = powersensor.PowerSensor(device)
 
         self.begin_state = None
-        self.results = {"ps_energy": [], "ps_power": []}
+        self.results = {key: [] for key in self.observables}
 
     def after_start(self):
         self.begin_state = self.ps.read()
 
     def after_finish(self):
         end_state = self.ps.read()
         if "ps_energy" in self.observables:
-            ps_measured_e = power_sensor.Joules(
+            ps_measured_e = powersensor.Joules(
                 self.begin_state, end_state, -1
             )  # Joules
             self.results["ps_energy"].append(ps_measured_e)
@@ -58,5 +58,5 @@ def after_finish(self):
 
     def get_results(self):
         averages = {key: np.average(values) for key, values in self.results.items()}
-        self.results = {"ps_energy": [], "ps_power": []}
+        self.results = {key: [] for key in self.observables}
         return averages

kernel_tuner/strategies/common.py

@@ -94,23 +94,24 @@ def __call__(self, x, check_restrictions=True):
                 result = params_dict
                 result[self.tuning_options.objective] = util.InvalidConfig()
 
-        # compile and benchmark this instance
-        if not result:
+        if legal:
+            # compile and benchmark this instance
             res = self.runner.run([params], self.tuning_options)
             result = res[0]
 
-        # append to tuning results
-        if x_int not in self.tuning_options.unique_results:
-            self.tuning_options.unique_results[x_int] = result
+            # append to tuning results
+            if x_int not in self.tuning_options.unique_results:
+                self.tuning_options.unique_results[x_int] = result
 
-        self.results.append(result)
+            self.results.append(result)
+
+            # upon returning from this function control will be given back to the strategy, so reset the start time
+            self.runner.last_strategy_start_time = perf_counter()
 
         # get numerical return value, taking optimization direction into account
         return_value = result[self.tuning_options.objective] or sys.float_info.max
         return_value = return_value if not self.tuning_options.objective_higher_is_better else -return_value
 
-        # upon returning from this function control will be given back to the strategy, so reset the start time
-        self.runner.last_strategy_start_time = perf_counter()
         return return_value
 
     def get_bounds_x0_eps(self):

kernel_tuner/util.py

@@ -49,6 +49,19 @@ class RuntimeFailedConfig(ErrorConfig):
     pass
 
 
+class NpEncoder(json.JSONEncoder):
+    """ Class we use for dumping Numpy objects to JSON """
+
+    def default(self, obj):
+        if isinstance(obj, np.integer):
+            return int(obj)
+        if isinstance(obj, np.floating):
+            return float(obj)
+        if isinstance(obj, np.ndarray):
+            return obj.tolist()
+        return super(NpEncoder, self).default(obj)
+
+
 class TorchPlaceHolder():
 
     def __init__(self):
@@ -725,18 +738,6 @@ def compile_restrictions(restrictions: list, tune_params: dict):
     return func
 
 
-class NpEncoder(json.JSONEncoder):
-
-    def default(self, obj):
-        if isinstance(obj, np.integer):
-            return int(obj)
-        if isinstance(obj, np.floating):
-            return float(obj)
-        if isinstance(obj, np.ndarray):
-            return obj.tolist()
-        return super(NpEncoder, self).default(obj)
-
-
 def process_cache(cache, kernel_options, tuning_options, runner):
     """cache file for storing tuned configurations
 
@@ -871,16 +872,6 @@ def close_cache(cache):
 def store_cache(key, params, tuning_options):
     """ stores a new entry (key, params) to the cachefile """
 
-    # create converter for dumping numpy objects to JSON
-    def JSONconverter(obj):
-        if isinstance(obj, np.integer):
-            return int(obj)
-        if isinstance(obj, np.floating):
-            return float(obj)
-        if isinstance(obj, np.ndarray):
-            return obj.tolist()
-        return obj.__str__()
-
     #logging.debug('store_cache called, cache=%s, cachefile=%s' % (tuning_options.cache, tuning_options.cachefile))
     if isinstance(tuning_options.cache, dict):
         if not key in tuning_options.cache:
@@ -894,7 +885,7 @@ def JSONconverter(obj):
 
             if tuning_options.cachefile:
                 with open(tuning_options.cachefile, "a") as cachefile:
-                    cachefile.write("\n" + json.dumps({ key: output_params }, default=JSONconverter)[1:-1] + ",")
+                    cachefile.write("\n" + json.dumps({ key: output_params }, cls=NpEncoder)[1:-1] + ",")
 
 
 def dump_cache(obj: str, tuning_options):