Some minor fixes in perf.testing

Author: densmirn

hpat/tests/tests_perf/__init__.py

@@ -47,35 +47,33 @@ def usecase_series_max(input_data):
     return finish_time - start_time, res
 
 
-# python -m sdc.runtests sdc.tests.tests_perf.test_perf_series.TestSeriesFloatMethods
-class TestSeriesFloatMethods(TestBase):
+# python -m sdc.runtests sdc.tests.tests_perf.test_perf_series.TestSeriesMethods
+class TestSeriesMethods(TestBase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
         cls.total_data_length = [5 * 10 ** 8]
 
-    def _test_series_float(self, pyfunc, name, input_data=None):
-
-        input_data = input_data or test_global_input_data_float64
+    def _test_series(self, pyfunc, name):
+        input_data = test_global_input_data_float64
         hpat_func = sdc.jit(pyfunc)
         for data_length in self.total_data_length:
-            data = perf_data_gen_float(input_data, data_length)
+            data, = perf_data_gen_fixed_len(input_data, data_length, 1)
             test_data = pd.Series(data)
 
             compile_results = calc_compilation(pyfunc, test_data, iter_number=self.iter_number)
             # Warming up
             hpat_func(test_data)
 
             exec_times, boxing_times = get_times(hpat_func, test_data, iter_number=self.iter_number)
-            self.test_results.add(test_name=name, test_type='JIT', data_size=test_data.size, test_results=exec_times,
-                                  boxing_results=boxing_times, compile_results=compile_results)
+            self.test_results.add(name, 'JIT', test_data.size, exec_times, boxing_results=boxing_times,
+                                  compile_results=compile_results)
 
             exec_times, _ = get_times(pyfunc, test_data, iter_number=self.iter_number)
-            self.test_results.add(test_name=name, test_type='Reference', data_size=test_data.size,
-                                  test_results=exec_times)
+            self.test_results.add(name, 'Reference', test_data.size, test_results=exec_times)
 
     def test_series_float_min(self):
-        self._test_series_float(usecase_series_min, 'series_float_min')
+        self._test_series(usecase_series_min, 'series_float_min')
 
     def test_series_float_max(self):
-        self._test_series_float(usecase_series_max, 'series_float_max')
+        self._test_series(usecase_series_max, 'series_float_max')

sdc/tests/tests_perf/test_perf_series.py

@@ -118,7 +118,7 @@ def setUpClass(cls):
         if is_true(os.environ.get('LOAD_PREV_RESULTS')):
             cls.test_results.load()
 
-        cls.total_data_length = [10**4 + 513, 10**5 + 2025]
+        cls.total_data_length = [10**4, 10**5]
         cls.width = [16, 64, 512, 1024]
         cls.num_threads = int(os.environ.get('NUMBA_NUM_THREADS', config.NUMBA_NUM_THREADS))
         cls.threading_layer = os.environ.get('NUMBA_THREADING_LAYER', config.THREADING_LAYER)

sdc/tests/tests_perf/test_perf_series_str.py

@@ -30,12 +30,13 @@
 import gc
 import sys
 import sdc
+import time
+from contextlib import contextmanager
+from copy import copy
 from pathlib import Path
 
 import pandas
 from numba import config
-import time
-from contextlib import contextmanager
 
 """
 Utility functions collection to support performance testing of
@@ -74,24 +75,62 @@ def get_size(obj):
     return size
 
 
+def multiply_oneds_data(tmpl, max_len):
+    """Multiply specified 1D like data."""
+    result = copy(tmpl)
+    while len(result) < max_len:
+        result += tmpl
+
+    # Trim result to max_len
+    return result[:max_len]
+
+
 def multiply_data(tmpl, max_item_len):
     """Multiply specified 2D like data."""
     result = []
     for item in tmpl:
-        local_item = item
-        local_item_len = len(local_item)
+        result += multiply_oneds_data(item, max_item_len)
+
+    return result
+
 
-        while (local_item_len < max_item_len) and (local_item_len >= 0):
-            local_item += item
-            local_item_len = len(local_item)
+def perf_data_gen(tmpl, max_item_len, max_bytes_size):
+    """
+    Data generator produces 2D like data.
+                  tmpl: list of input template string
+          max_item_len: length (in elements) of resulted string in an element of the result array
+        max_bytes_size: maximum size in bytes of the return data
+
+                return: list of iterable data
+    """
+    result = []
+    while get_size(result) < max_bytes_size:
+        result.extend(multiply_data(tmpl, max_item_len))
 
-        # Trim local_item to max_item_len
-        local_item = local_item[:max_item_len]
-        result.append(local_item)
+    # Trim result to max_bytes_size
+    while result and get_size(result) > max_bytes_size:
+        del result[-1]
 
     return result
 
 
+def perf_data_gen_fixed_len(tmpl, max_item_len, max_obj_len):
+    """
+    Data generator produces 2D like data.
+                  tmpl: list of input template string
+          max_item_len: length (in elements) of resulted string in an element of the result array
+           max_obj_len: maximum length of the return data
+
+                return: list of iterable data
+    """
+    result = []
+    while len(result) < max_obj_len:
+        result.extend(multiply_data(tmpl, max_item_len))
+
+    # Trim result to max_obj_len
+    return result[:max_obj_len]
+
+
 @contextmanager
 def do_jit(f):
     """Context manager to jit function"""
@@ -142,56 +181,6 @@ def get_times(f, test_data, iter_number=5):
     return exec_times, boxing_times
 
 
-def perf_data_gen(tmpl, max_item_len, max_bytes_size):
-    """
-    Data generator produces 2D like data.
-                  tmpl: list of input template string
-          max_item_len: length (in elements) of resulted string in an element of the result array
-        max_bytes_size: maximum size in bytes of the return data
-
-                return: list of strings
-    """
-    result = []
-    while get_size(result) < max_bytes_size:
-        result.extend(multiply_data(tmpl, max_item_len))
-
-    # Trim result to max_bytes_size
-    while result and get_size(result) > max_bytes_size:
-        del result[-1]
-
-    return result
-
-
-def perf_data_gen_fixed_len(tmpl, max_item_len, max_obj_len):
-    """
-    Data generator produces 2D like data.
-                  tmpl: list of input template string
-          max_item_len: length (in elements) of resulted string in an element of the result array
-           max_obj_len: maximum length of the return data
-
-                return: list of strings
-    """
-    result = []
-    while len(result) < max_obj_len:
-        result.extend(multiply_data(tmpl, max_item_len))
-
-    # Trim result to max_obj_len
-    return result[:max_obj_len]
-
-
-def perf_data_gen_float(input, maxlen):
-    """
-    """
-    result = []
-    i = 0
-    N = len(input)
-    while len(result) < maxlen:
-        n = (i - i // 2) % N
-        result.extend(input[n])
-        i += 1
-    return result[:maxlen]
-
-
 class TestResults:
     perf_results_xlsx = 'perf_results.xlsx'
     raw_perf_results_xlsx = 'raw_perf_results.xlsx'