apply internal patches

LibOS/shim/test/apps/python/scripts/benchrun.py

@@ -0,0 +1,116 @@
+"""
+Downloaded from https://code.google.com/p/benchrun/
+
+A benchmark is defined by creating a subclass of Benchmark.
+The subclass should define a method run() that executes the code
+to be timed and returns the elapsed time in seconds (as a float),
+or None if the benchmark should be skipped.
+
+See fibonacci.py for example.
+"""
+
+import sys
+if sys.platform=='win32':
+    from time import clock
+else:
+    from time import time as clock
+
+# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/302478
+def combinations(*seqin):
+    def rloop(seqin,comb):
+        if seqin:
+            for item in seqin[0]:
+                newcomb = comb + [item]
+                for item in rloop(seqin[1:],newcomb):   
+                    yield item
+        else:
+            yield comb
+    return rloop(seqin,[])
+
+
+class Benchmark:
+    sort_by = []
+    reference = None
+
+    def __init__(self):
+        self.pnames = []
+        self.pvalues = []
+        self.results = []
+        self.results_dict = {}
+        for pname in self.parameters:
+            value = getattr(self, pname)
+            self.pnames.append(pname)
+            self.pvalues.append(value)
+        self.pcombos = list(combinations(*self.pvalues))
+        if self.reference:
+            self.reference_param = self.reference[0]
+            self.reference_value = self.reference[1]
+
+    def time_all(self):
+        """Run benchmark for all versions and parameters."""
+        for params in self.pcombos:
+            args = dict(zip(self.pnames, params))
+            t = self.run(**args)
+            self.results.append(tuple(params) + (t,))
+            self.results_dict[tuple(params)] = t
+
+    def sort_results(self):
+        sort_keys = []
+        for name in self.sort_by:
+            sort_keys += [self.pnames.index(name)]
+        for i, name in enumerate(self.pnames):
+            if i not in sort_keys:
+                sort_keys += [i]
+        def key(v):
+            return list(v[i] for i in sort_keys)
+        self.results.sort(key=key)
+
+    def get_factor(self, pvalues, time):
+        if not self.reference or not time:
+            return None
+        pvalues = list(pvalues)
+        i = self.pnames.index(self.reference_param)
+        if pvalues[i] == self.reference_value:
+            return None
+        else:
+            pvalues[i] = self.reference_value
+        ref = self.results_dict[tuple(pvalues)]
+        if ref == None:
+            return None
+        return ref / time
+
+    def print_result(self):
+        """Run benchmark for all versions and parameters and print results
+        in tabular form to the standard output."""
+        self.time_all()
+        self.sort_results()
+
+        print "=" * 78
+        print
+        print self.__class__.__name__
+        print self.__doc__, "\n"
+
+        colwidth = 15
+        reftimes = {}
+
+        ts = "seconds"
+        if self.reference:
+            ts += " (x faster than " + (str(self.reference_value)) + ")"
+        print "  ", "   ".join([str(r).ljust(colwidth) for r in self.pnames + [ts]])
+        print "-"*79
+
+        rows = []
+        for vals in self.results:
+            pvalues =  vals[:-1]
+            time = vals[-1]
+            if time == None:
+                stime = "(n/a)"
+            else:
+                stime = "%.8f" % time
+                factor = self.get_factor(pvalues, time)
+                if factor != None:
+                    stime += ("  (%.2f)" % factor)
+            vals = pvalues + (stime,)
+            row = [str(val).ljust(colwidth) for val in vals]
+            print "  ", "   ".join(row)
+        print

LibOS/shim/test/apps/python/scripts/fibonacci.py

@@ -0,0 +1,54 @@
+"""
+Downloaded from https://code.google.com/p/benchrun/
+
+Fibonacci numbers test benchmark
+"""
+
+from benchrun import Benchmark, clock
+
+def fib1(n):
+    if n < 2:
+        return n
+    return fib1(n-1) + fib1(n-2)
+
+def fib2(n):
+    if n < 2:
+        return n
+    a, b = 1, 0
+    for i in xrange(n-1):
+        a, b = a+b, a
+    return a
+
+class FibonacciBenchmark(Benchmark):
+    """Compare time to compute the nth Fibonacci number recursively
+    (fib1) and iteratively (fib2)."""
+
+    # Execute for all combinations of these parameters
+    parameters = ['version', 'n']
+    version = ['fib1', 'fib2']
+    n = range(0, 60, 5)
+
+    # Compare timings against this parameter value
+    reference = ('version', 'fib1')
+
+    def run(self, n, version):
+        f = globals()[version]
+        # Don't repeat when slow
+        if version == 'fib1' and n > 10:
+            # Skip altogether
+            if n > 30:
+                return None
+            t1 = clock()
+            f(n)
+            t2 = clock()
+            return t2-t1
+        # Need to repeat many times to get accurate timings for small n
+        else:
+            t1 = clock()
+            f(n); f(n); f(n); f(n); f(n); f(n); f(n)
+            f(n); f(n); f(n); f(n); f(n); f(n); f(n)
+            t2 = clock()
+            return (t2 - t1) / 14
+
+if __name__ == '__main__':
+    FibonacciBenchmark().print_result()

LibOS/shim/test/apps/python/scripts/helloworld.py

@@ -0,0 +1,3 @@
+#!/usr/bin/python
+
+print "Hello World"

LibOS/shim/test/apps/python/scripts/sympybench.py

@@ -0,0 +1,70 @@
+"""
+Downloaded from https://code.google.com/p/benchrun/
+
+Test code for benchrun: sympy performance benchmark.
+"""
+
+from benchrun import Benchmark, clock
+
+import sympycore
+import sympy
+
+class SympyBenchmark(Benchmark):
+    version = ['sympy', 'sympycore']
+    reference = ('version', 'sympy')
+
+
+class DirectSymbolicAddition(SympyBenchmark):
+    """Add small polynomials with rational coefficients"""
+    parameters = ['version']
+    def run(self, version):
+        module = __import__(version)
+        x, y, z = map(module.Symbol, 'xyz')
+        a = 3*x + 2*x*y - module.Rational(1,2)*z + 2
+        b = 2*x + module.Rational(3,2)*x*y + 4*z - 2
+        n = N = 100
+        t1 = clock()
+        while n:
+            a + n*b
+            n -= 1
+        t2 = clock()
+        return (t2-t1)/N
+
+class PowerExpansion(SympyBenchmark):
+    """Expand (x+y+z)**n * (y+x)**(n-1)"""
+    parameters = ['version', 'n']
+    n = [5, 10, 20]
+    def run(self, version, n):
+        module = __import__(version)
+        if version == 'sympy' and n > 10:
+            return None
+        x, y, z = map(module.Symbol, 'xyz')
+        t1 = clock()
+        e = ((x+y+z)**n * (y+x)**(n-1)).expand()
+        t2 = clock()
+        return t2-t1
+
+class LegendreRecurrence(SympyBenchmark):
+    """Calculate the nth Legendre polynomial by recurrence."""
+    parameters = ['version', 'n']
+    n = [3, 10, 30, 100]
+    def run(self, version, n):
+        module = __import__(version)
+        x = module.Symbol('x')
+        if version == 'sympy' and n > 30:
+            return None
+        b, a = x, 1
+        t1 = clock()
+        for n in range(1, n):
+            b, a = (((2*n+1)*x*b - n*a)/(n+1)).expand(), b
+        t2 = clock()
+        return t2-t1
+
+all_benchmarks = [
+  DirectSymbolicAddition(),
+  PowerExpansion(),
+  LegendreRecurrence(),
+]
+
+for bench in all_benchmarks:
+    bench.print_result()