Clean-up gil bencmarks

Author: jorisvandenbossche

asv_bench/benchmarks/gil.py

@@ -22,175 +22,130 @@ def wrapper(fname):
         return wrapper
 
 
-class nogil_groupby_base(object):
+class NoGilGroupby(object):
     goal_time = 0.2
 
     def setup(self):
         self.N = 1000000
         self.ngroups = 1000
         np.random.seed(1234)
         self.df = DataFrame({'key': np.random.randint(0, self.ngroups, size=self.N), 'data': np.random.randn(self.N), })
-        if (not have_real_test_parallel):
-            raise NotImplementedError
-
 
-class nogil_groupby_count_2(nogil_groupby_base):
+        np.random.seed(1234)
+        self.size = 2 ** 22
+        self.ngroups = 100
+        self.data = Series(np.random.randint(0, self.ngroups, size=self.size))
 
-    def time_nogil_groupby_count_2(self):
-        self.pg2()
+        if (not have_real_test_parallel):
+            raise NotImplementedError
 
     @test_parallel(num_threads=2)
-    def pg2(self):
+    def _pg2_count(self):
         self.df.groupby('key')['data'].count()
 
-
-class nogil_groupby_last_2(nogil_groupby_base):
-
-    def time_nogil_groupby_last_2(self):
-        self.pg2()
+    def time_count_2(self):
+        self._pg2_count()
 
     @test_parallel(num_threads=2)
-    def pg2(self):
+    def _pg2_last(self):
         self.df.groupby('key')['data'].last()
 
-
-class nogil_groupby_max_2(nogil_groupby_base):
-
-    def time_nogil_groupby_max_2(self):
-        self.pg2()
+    def time_last_2(self):
+        self._pg2_last()
 
     @test_parallel(num_threads=2)
-    def pg2(self):
+    def _pg2_max(self):
         self.df.groupby('key')['data'].max()
 
-
-class nogil_groupby_mean_2(nogil_groupby_base):
-
-    def time_nogil_groupby_mean_2(self):
-        self.pg2()
+    def time_max_2(self):
+        self._pg2_max()
 
     @test_parallel(num_threads=2)
-    def pg2(self):
+    def _pg2_mean(self):
         self.df.groupby('key')['data'].mean()
 
-
-class nogil_groupby_min_2(nogil_groupby_base):
-
-    def time_nogil_groupby_min_2(self):
-        self.pg2()
+    def time_mean_2(self):
+        self._pg2_mean()
 
     @test_parallel(num_threads=2)
-    def pg2(self):
+    def _pg2_min(self):
         self.df.groupby('key')['data'].min()
 
-
-class nogil_groupby_prod_2(nogil_groupby_base):
-
-    def time_nogil_groupby_prod_2(self):
-        self.pg2()
+    def time_min_2(self):
+        self._pg2_min()
 
     @test_parallel(num_threads=2)
-    def pg2(self):
+    def _pg2_prod(self):
         self.df.groupby('key')['data'].prod()
 
-
-class nogil_groupby_sum_2(nogil_groupby_base):
-
-    def time_nogil_groupby_sum_2(self):
-        self.pg2()
+    def time_prod_2(self):
+        self._pg2_prod()
 
     @test_parallel(num_threads=2)
-    def pg2(self):
-        self.df.groupby('key')['data'].sum()
-
-
-class nogil_groupby_sum_4(nogil_groupby_base):
-
-    def time_nogil_groupby_sum_4(self):
-        self.pg4()
-
-    def f(self):
+    def _pg2_sum(self):
         self.df.groupby('key')['data'].sum()
 
-    def g4(self):
-        for i in range(4):
-            self.f()
+    def time_sum_2(self):
+        self._pg2_sum()
 
     @test_parallel(num_threads=4)
-    def pg4(self):
-        self.f()
-
+    def _pg4_sum(self):
+        self.df.groupby('key')['data'].sum()
 
-class nogil_groupby_sum_8(nogil_groupby_base):
+    def time_sum_4(self):
+        self._pg4_sum()
 
-    def time_nogil_groupby_sum_8(self):
-        self.pg8()
+    def time_sum_4_notp(self):
+        for i in range(4):
+            self.df.groupby('key')['data'].sum()
 
-    def f(self):
+    def _f_sum(self):
         self.df.groupby('key')['data'].sum()
 
-    def g8(self):
-        for i in range(8):
-            self.f()
-
     @test_parallel(num_threads=8)
-    def pg8(self):
-        self.f()
-
+    def _pg8_sum(self):
+        self._f_sum()
 
-class nogil_groupby_var_2(nogil_groupby_base):
+    def time_sum_8(self):
+        self._pg8_sum()
 
-    def time_nogil_groupby_var_2(self):
-        self.pg2()
+    def time_sum_8_notp(self):
+        for i in range(8):
+            self._f_sum()
 
     @test_parallel(num_threads=2)
-    def pg2(self):
+    def _pg2_var(self):
         self.df.groupby('key')['data'].var()
 
+    def time_var_2(self):
+        self._pg2_var()
 
-class nogil_groupby_groups(object):
-    goal_time = 0.2
-
-    def setup(self):
-        np.random.seed(1234)
-        self.size = 2**22
-        self.ngroups = 100
-        self.data = Series(np.random.randint(0, self.ngroups, size=self.size))
-        if (not have_real_test_parallel):
-            raise NotImplementedError
+    # get groups
 
-    def f(self):
+    def _groups(self):
         self.data.groupby(self.data).groups
 
-
-class nogil_groupby_groups_2(nogil_groupby_groups):
-
-    def time_nogil_groupby_groups(self):
-        self.pg2()
-
     @test_parallel(num_threads=2)
-    def pg2(self):
-        self.f()
-
+    def _pg2_groups(self):
+        self._groups()
 
-class nogil_groupby_groups_4(nogil_groupby_groups):
-
-    def time_nogil_groupby_groups(self):
-        self.pg4()
+    def time_groups_2(self):
+        self._pg2_groups()
 
     @test_parallel(num_threads=4)
-    def pg4(self):
-        self.f()
+    def _pg4_groups(self):
+        self._groups()
 
+    def time_groups_4(self):
+        self._pg4_groups()
 
-class nogil_groupby_groups_8(nogil_groupby_groups):
+    @test_parallel(num_threads=8)
+    def _pg8_groups(self):
+        self._groups()
 
-    def time_nogil_groupby_groups(self):
-        self.pg8()
+    def time_groups_8(self):
+        self._pg8_groups()
 
-    @test_parallel(num_threads=8)
-    def pg8(self):
-        self.f()
 
 
 class nogil_take1d_float64(object):
@@ -408,19 +363,19 @@ def create_cols(self, name):
     def pg_read_csv(self):
         read_csv('__test__.csv', sep=',', header=None, float_precision=None)
 
-    def time_nogil_read_csv(self):
+    def time_read_csv(self):
         self.pg_read_csv()
 
     @test_parallel(num_threads=2)
     def pg_read_csv_object(self):
         read_csv('__test_object__.csv', sep=',')
 
-    def time_nogil_read_csv_object(self):
+    def time_read_csv_object(self):
         self.pg_read_csv_object()
 
     @test_parallel(num_threads=2)
     def pg_read_csv_datetime(self):
         read_csv('__test_datetime__.csv', sep=',', header=None)
 
-    def time_nogil_read_csv_datetime(self):
+    def time_read_csv_datetime(self):
         self.pg_read_csv_datetime()