adding PackedArray benchmarks

Author: crazyeng

wolframclient/cli/commands/benchmark.py

@@ -12,7 +12,8 @@
 from wolframclient.utils.encoding import force_text
 from wolframclient.utils.functional import first
 from wolframclient.utils.importutils import safe_import_string_and_call
-
+from wolframclient.language.array import NumericArray, PackedArray
+from wolframclient.utils.api import numpy
 
 def repeat(el, n=1):
     return tuple(el for _ in range(n))
@@ -21,36 +22,45 @@ def repeat(el, n=1):
 class Command(SimpleCommand):
 
     col_size = 8
+    title_size = 14
     repetitions = 10
     complexity = [1, 2, 5, 10, 100, 1000]
 
     def add_arguments(self, parser):
         parser.add_argument("--profile", dest="profile", default=False, action="store_true")
 
-    def complexity_handler(self, complexity):
+    def expression_handler(self, complexity):
         return {
-            "symbols": repeat(wl.Symbol, complexity),
-            "strings": repeat("string", complexity),
-            "bytes": repeat(b"bytes", complexity),
-            "integers": repeat(1, complexity),
-            "decimals": repeat(decimal.Decimal("1.23"), complexity),
-            "floats": repeat(1.23, complexity),
-            "dict": repeat({1: 2, 3: 4, 5: 6}, complexity),
-            "list": repeat([1, 2, 3], complexity),
-            "functions": repeat(wl.Function(1, 2, 3), complexity),
+            'expr': {
+                "symbols": repeat(wl.Symbol, complexity),
+                "strings": repeat("string", complexity),
+                "bytes": repeat(b"bytes", complexity),
+                "integers": repeat(1, complexity),
+                "decimals": repeat(decimal.Decimal("1.23"), complexity),
+                "floats": repeat(1.23, complexity),
+                "dict": repeat({1: 2, 3: 4, 5: 6}, complexity),
+                "list": repeat([1, 2, 3], complexity),
+                "functions": repeat(wl.Function(1, 2, 3), complexity),
+            },
+            'array': {
+                '%s_%s' % (func.__name__, t): func(numpy.arange(complexity * 100), t)
+                for func in (PackedArray, NumericArray)
+                for t in ('Integer64', 'Real64')
+            }
         }
 
+
     def formatted_time(self, function, *args, **opts):
 
         time = sum(first(timed(function)(*args, **opts)) for i in range(self.repetitions))
 
         return "%.5f" % (time / self.repetitions)
 
     def table_line(self, *iterable):
-        self.print(*(force_text(c).ljust(self.col_size) for c in iterable))
+        self.print(*(force_text(c).ljust(i and self.col_size or self.title_size) for i, c in enumerate(iterable)))
 
     def table_divider(self, length):
-        self.print(*("-" * self.col_size for i in range(length)))
+        self.print(*("-" * (i and self.col_size or self.title_size) for i in range(length)))
 
     def stream_generators(self, path):
         yield "Memory", lambda complexity, export_format, path=path: None
@@ -62,7 +72,7 @@ def report(self):
 
         path = tempfile.gettempdir()
 
-        benchmarks = [(c, self.complexity_handler(c)) for c in self.complexity]
+        benchmarks = [(c, self.expression_handler(c)) for c in self.complexity]
 
         self.table_line("dumping results in %s" % path)
         self.table_line()
@@ -102,24 +112,26 @@ def report(self):
             )
             self.table_divider(len(self.complexity) + 1)
 
-            for label, export_format, opts in (
-                ("wl", "wl", dict()),
-                ("wxf", "wxf", dict()),
-                ("wxf zip", "wxf", dict(compress=True)),
-            ):
-                self.table_line(
-                    label,
-                    *(
-                        self.formatted_time(
-                            export,
-                            expr,
-                            stream=stream_generator(complexity, export_format),
-                            target_format=export_format,
-                            **opts
+            for key in ('expr', 'array'):
+                for label, export_format, opts in (
+                    ("wl", "wl", dict()),
+                    ("wxf", "wxf", dict()),
+                    ("wxf zip", "wxf", dict(compress=True)),
+                ):
+                    if key == 'expr' or (key == 'array' and not label == 'wl'):
+                        self.table_line(
+                            key == 'expr' and label or '%s %s' % (label, key),
+                            *(
+                                self.formatted_time(
+                                    export,
+                                    expr[key],
+                                    stream=stream_generator(complexity, export_format),
+                                    target_format=export_format,
+                                    **opts
+                                )
+                                for complexity, expr in benchmarks
+                            )
                         )
-                        for complexity, expr in benchmarks
-                    )
-                )
 
             self.table_line()