From 6459d289f2db842bc6b852adc6fb91018a977be1 Mon Sep 17 00:00:00 2001
From: Maxim Kulkin <maxim.kulkin@gmail.com>
Date: Tue, 29 Nov 2016 22:02:50 -0800
Subject: [PATCH] Add benchmark

---
 benchmark.py | 160 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 160 insertions(+)
 create mode 100755 benchmark.py

diff --git a/benchmark.py b/benchmark.py
new file mode 100755
index 0000000..a1ec0ac
--- /dev/null
+++ b/benchmark.py
@@ -0,0 +1,160 @@
+#!/usr/bin/env python
+
+import lollipop.types as lt
+import lollipop.validators as lv
+from collections import namedtuple
+
+import timeit
+import os
+import hotshot, hotshot.stats
+
+
+def profile(func, *args, **kwargs):
+    prof = hotshot.Profile("object.prof")
+    prof.runcall(func, *args, **kwargs)
+    prof.close()
+    stats = hotshot.stats.load("object.prof")
+    stats.strip_dirs()
+    stats.sort_stats('time', 'calls')
+    stats.print_stats(30)
+    os.remove('object.prof')
+
+
+def benchmark_large_strings_object_dumping(iterations=1000):
+    n = 100
+    TYPE = lt.Object({
+        'field%02d' % idx: lt.String()
+        for idx in xrange(n)
+    })
+
+    Data = namedtuple('Data', ['field%02d' % idx for idx in xrange(n)])
+    data = Data(*['value%02d' % idx for idx in xrange(n)])
+
+    TYPE.dump(data)  # warmup
+    time = timeit.timeit(lambda: TYPE.dump(data), number=iterations)
+    print 'Large strings object dumping: %s' % time
+
+
+def benchmark_large_strings_object_loading(iterations=1000):
+    n = 100
+    TYPE = lt.Object({
+        'field%02d' % idx: lt.String()
+        for idx in xrange(n)
+    })
+
+    data = {'field%02d' % idx: 'value%02d' % idx for idx in xrange(n)}
+
+    TYPE.load(data)  # warmup
+    time = timeit.timeit(lambda: TYPE.load(data), number=iterations)
+    print 'Large strings object loading: %s' % time
+
+
+def benchmark_large_strings_object_with_validators_loading(iterations=1000):
+    n = 100
+    TYPE = lt.Object({
+        'field%02d' % idx: lt.String(validate=lv.Length(min=1))
+        for idx in xrange(n)
+    })
+
+    data = {'field%02d' % idx: 'value%02d' % idx for idx in xrange(n)}
+
+    TYPE.load(data)  # warmup
+    time = timeit.timeit(lambda: TYPE.load(data), number=iterations)
+    print 'Large strings object with validators loading: %s' % time
+
+
+def benchmark_large_integers_object_dumping(iterations=1000):
+    n = 100
+    TYPE = lt.Object({
+        'field%02d' % idx: lt.Integer()
+        for idx in xrange(n)
+    })
+
+    Data = namedtuple('Data', ['field%02d' % idx for idx in xrange(n)])
+    data = Data(*[idx for idx in xrange(n)])
+
+    TYPE.dump(data)  # warmup
+    time = timeit.timeit(lambda: TYPE.dump(data), number=iterations)
+    print 'Large integers object dumping: %s' % time
+
+
+def benchmark_large_integers_object_loading(iterations=1000):
+    n = 100
+    TYPE = lt.Object({
+        'field%02d' % idx: lt.Integer()
+        for idx in xrange(n)
+    })
+
+    data = {'field%02d' % idx: idx for idx in xrange(n)}
+
+    TYPE.load(data)  # warmup
+    time = timeit.timeit(lambda: TYPE.load(data), number=iterations)
+    print 'Large integers object loading: %s' % time
+
+
+def benchmark_complex_object_dumping(iterations=1000):
+    Foo = namedtuple('Foo', ['a', 'b', 'c', 'd'])
+    Bar = namedtuple('Bar', ['x', 'y', 'foo', 'foos'])
+
+    FOO = lt.Object({
+        'a': lt.Integer(),
+        'b': lt.FunctionField(lt.Integer(), lambda o: o.b + 10),
+        'c': lt.String(),
+        'd': lt.Integer(),
+    })
+
+    BAR = lt.Object({
+        'x': lt.String(),
+        'y': lt.Integer(),
+        'foo': FOO,
+        'foos': lt.List(FOO),
+    })
+
+    bar = Bar(
+        'bar', 123,
+        Foo(123, 456, 'foo', 789),
+        [Foo(123+i, 456+i, 'foo', 789+i) for i in xrange(10)]
+    )
+
+    BAR.dump(bar)  # warmup
+    time = timeit.timeit(lambda: BAR.dump(bar), number=iterations)
+    print 'Complex object dumping: %s' % time
+
+
+def benchmark_complex_object_loading(iterations=1000):
+    Foo = namedtuple('Foo', ['a', 'b', 'c', 'd'])
+    Bar = namedtuple('Bar', ['x', 'y', 'foo', 'foos'])
+
+    FOO = lt.Object({
+        'a': lt.Integer(),
+        'b': lt.FunctionField(lt.Integer(), lambda o: o.b + 10),
+        'c': lt.String(),
+        'd': lt.Integer(),
+    })
+
+    BAR = lt.Object({
+        'x': lt.String(),
+        'y': lt.Integer(),
+        'foo': FOO,
+        'foos': lt.List(FOO),
+    })
+
+    data = {
+        'x': 'bar', 'y': 123,
+        'foo': {'a': 123, 'b': 456, 'c': 'foo', 'd': 789},
+        'foos': [{'a': 123+i, 'b': 456+i, 'c': 'foo', 'd': 789+i}
+                 for i in xrange(10)],
+    }
+
+    BAR.load(data)  # warmup
+    time = timeit.timeit(lambda: BAR.load(data), number=iterations)
+    print 'Complex object loading: %s' % time
+
+
+benchmark_large_strings_object_dumping()
+benchmark_large_integers_object_dumping()
+benchmark_complex_object_dumping()
+benchmark_large_strings_object_loading()
+benchmark_large_integers_object_loading()
+benchmark_large_strings_object_with_validators_loading()
+benchmark_complex_object_loading()