[GR-23651] Resize pickle benchmarks.

PullRequest: graalpython/1042

Author: cosminbasca

graalpython/com.oracle.graal.python.benchmarks/python/micro/dicts.pickle

@@ -51,22 +51,22 @@ def get_setup(module, name):
     # this is needed in order to unpickle the funcs references ...
     sys.path.append(os.path.split(__file__)[0])
 
-    def __setup__():
+    def __setup__(multiplier):
         global DATA, dumps, loads
         dumps, loads = get_pickler(module)
-        DATA = get_data(name)
+        DATA = get_data(name) * multiplier
     return __setup__
 
 
-def __process_args__():
-    pass
+def __process_args__(multiplier):
+    return int(multiplier),
 
 
-def __teardown__():
+def __teardown__(multiplier):
     pass
 
 
-def __benchmark__():
+def __benchmark__(multiplier):
     dumped = [dumps(s) for s in DATA]
     loaded = [loads(b) for b in dumped]
     print("loaded DATA are the same as dumped DATA: ", loaded == DATA)

graalpython/com.oracle.graal.python.benchmarks/python/micro/funcs.pickle

@@ -45,44 +45,81 @@
 MOD_DIR = os.path.abspath(os.path.split(__file__)[0])
 
 
-def gen_dics(size=500, size_min=10, size_max=100):
-    DATA = [random_dict(random.randint(size_min, size_max)) for _ in range(size)]
+def gen_dics(size=500, size_min=10, size_max=100, strings=None):
+    print(">>>> gen {} dicts ...".format(size))
+    DATA = []
+    for i in range(size):
+        if i % 10 == 0:
+            print(".", end="", flush=True)
+        DATA.append(random_dict(random.randint(size_min, size_max), strings=strings))
+    print("\npickling dicts ... ")
     with open(os.path.join(MOD_DIR, "dicts.pickle"), "w+b") as FILE:
         pickle.dump(DATA, FILE)
+    print("done")
 
 
-def gen_funcs(size=500):
-    DATA = [random_func() for _ in range(size)]
+def gen_funcs(size=1000):
+    print(">>>> gen {} funcs ...".format(size))
+    DATA = []
+    for i in range(size):
+        if i % 100 == 0:
+            print(".", end="", flush=True)
+        DATA.append(random_func())
+    print("\npickling funcs ...")
     with open(os.path.join(MOD_DIR, "funcs.pickle"), "w+b") as FILE:
         pickle.dump(DATA, FILE)
+    print("done")
 
 
-def gen_lists(size=500, size_min=10, size_max=100):
-    DATA = [random_list(random.randint(size_min, size_max)) for _ in range(size)]
+def gen_lists(size=500, size_min=10, size_max=100, strings=None):
+    print(">>>> gen {} lists ...".format(size))
+    DATA = []
+    for i in range(size):
+        if i % 100 == 0:
+            print(".", end="", flush=True)
+        DATA.append(random_list(random.randint(size_min, size_max), strings=strings))
+    print("\npickling lists ...")
     with open(os.path.join(MOD_DIR, "lists.pickle"), "w+b") as FILE:
         pickle.dump(DATA, FILE)
+    print("done")
 
 
 def gen_objects(size=500):
-    DATA = [random_instance() for _ in range(size)]
+    print(">>>> gen {} objects ...".format(size))
+    DATA = []
+    for i in range(size):
+        if i % 100 == 0:
+            print(".", end="", flush=True)
+        DATA.append(random_instance())
+    print("\npickling objects ...")
     with open(os.path.join(MOD_DIR, "objects.pickle"), "w+b") as FILE:
         pickle.dump(DATA, FILE)
+    print("done")
 
 
 def gen_strings(size=10000, size_min=10, size_max=1000):
-    DATA = [random_string(random.randint(size_min, size_max)) for _ in range(size)]
-    with open(os.path.join(MOD_DIR, "strings.pickle"), "w+b") as FILE:
-        pickle.dump(DATA, FILE)
+    DATA = get_data("strings")
+    if DATA and len(DATA) >= size:
+        print("strings fixture is already generated, reusing ... ")
+        DATA = DATA[:size]
+    else:
+        print(">>>> gen {} strings ...".format(size))
+        DATA = []
+        for i in range(size):
+            if i % 1000 == 0:
+                print(".", end="", flush=True)
+            DATA.append(random_string(random.randint(size_min, size_max)))
+
+        print("\npickling strings ...")
+        with open(os.path.join(MOD_DIR, "strings.pickle"), "w+b") as FILE:
+            pickle.dump(DATA, FILE)
+        print("done")
+    return DATA
 
 
 if __name__ == '__main__':
-    print(">>>> gen dicts ...")
-    gen_dics()
-    print(">>>> gen funcs ...")
+    strings = gen_strings()
+    gen_dics(strings=strings)
     gen_funcs()
-    print(">>>> gen lists ...")
-    gen_lists()
-    print(">>>> gen objects ...")
+    gen_lists(strings=strings)
     gen_objects()
-    print(">>>> gen strings ...")
-    gen_strings()

graalpython/com.oracle.graal.python.benchmarks/python/micro/lists.pickle

@@ -62,18 +62,20 @@ def random_string(size):
     return ''.join([random.choice(string.ascii_letters + string.digits + string.punctuation) for _ in range(size)])
 
 
-def random_list(size):
+def random_list(size, strings=None):
     def elem():
         t = random.randint(0, 2)
         if t == 0:
             return random.randint(0, 10000000000)
         elif t == 1:
             return float(random.randint(0, 10000000000))
+        elif strings is not None:
+            return strings[random.randint(0, len(strings))-1]
         return random_string(random.randint(100, 1000))
     return [elem() for _ in range(size)]
 
 
-def random_dict(size, ints_only=False):
+def random_dict(size, ints_only=False, strings=None):
     def elem():
         if ints_only:
             return random.randint(0, 10000000000)
@@ -83,6 +85,8 @@ def elem():
                 return random.randint(0, 10000000000)
             elif t == 1:
                 return float(random.randint(0, 10000000000))
+            elif strings is not None:
+                return strings[random.randint(0, len(strings)-1)]
             return random_string(random.randint(100, 1000))
     return {'key_'+str(random.randint(0, 1000000000)): elem() for _ in range(size)}
 
@@ -115,8 +119,11 @@ def random_func():
 
 
 def get_data(name):
-    file_name = "{}.pickle".format(name)
-    file_name = os.path.abspath(os.path.join(os.path.split(__file__)[0], file_name))
-    print(">>> loading {} data file ... ".format(file_name))
-    with open(file_name, "r+b") as FILE:
-        return pickle.load(FILE)
+    try:
+        file_name = "{}.pickle".format(name)
+        file_name = os.path.abspath(os.path.join(os.path.split(__file__)[0], file_name))
+        print(">>> loading {} data file ... ".format(file_name))
+        with open(file_name, "r+b") as FILE:
+            return pickle.load(FILE)
+    except:
+        return None

graalpython/com.oracle.graal.python.benchmarks/python/micro/objects.pickle

@@ -44,7 +44,10 @@
 #
 # ----------------------------------------------------------------------------------------------------------------------
 # the argument list contains both the harness and benchmark args
+ITER_50 = ['-i', '50']
+ITER_35 = ['-i', '35']
 ITER_25 = ['-i', '25']
+ITER_20 = ['-i', '20']
 ITER_15 = ['-i', '15']
 ITER_10 = ['-i', '10']
 
@@ -100,11 +103,11 @@
 
 def _pickling_benchmarks(module='pickle'):
     return {
-        '{}-strings'.format(module): ITER_10,
-        '{}-lists'.format(module): ITER_10,
-        '{}-dicts'.format(module): ITER_10,
-        '{}-objects'.format(module): ITER_10,
-        '{}-funcs'.format(module): ITER_10,
+        '{}-strings'.format(module): ITER_35 + ['40'],
+        '{}-lists'.format(module): ITER_35 + ['20'],
+        '{}-dicts'.format(module): ITER_35 + ['10'],
+        '{}-objects'.format(module): ITER_35 + ['300'],
+        '{}-funcs'.format(module): ITER_35 + ['400'],
     }