init

.venv/lib/python3.8/site-packages/mypyc/test-data/run-bench.test

@@ -0,0 +1,196 @@
+-- TODO: build some generic benchmark harness
+[case testBenchmarkTree]
+from typing import Optional
+class Node:
+    def __init__(self, value: int) -> None:
+        self.value = value
+        self.left = None  # type: Optional[Node]
+        self.right = None  # type: Optional[Node]
+    def sum(self) -> int:
+        left = 0
+        if self.left is not None:
+            left = self.left.sum()
+        right = 0
+        if self.right is not None:
+            right = self.right.sum()
+        return self.value + left + right
+def sum_tree(x: Optional[Node]) -> int:
+    if x is None:
+        return 0
+    return x.value + sum_tree(x.left) + sum_tree(x.right)
+def build(n: int) -> Optional[Node]:
+    if n == 0:
+        return None
+    x = Node(n)
+    x.left = build(n - 1)
+    x.right = x.left
+    return x
+
+def bench_sum(x: Optional[Node]) -> None:
+    for i in range(1000000):
+        sum_tree(x)
+def bench_sum_method(x: Node) -> None:
+    for i in range(1000000):
+        x.sum()
+[file driver.py]
+from typing import Optional
+import native
+import interpreted
+from timeit import timeit
+from time import time
+import os
+
+def dumb_time(f):
+    t0 = time()
+    f()
+    t1 = time()
+    return t1 - t0
+
+def basic_test(m):
+    tree = m.build(5)
+    assert(m.sum_tree(tree) == 57)
+    assert(tree.sum() == 57)
+    return tree
+
+def test(m):
+    tree = basic_test(m)
+
+    g = {**globals(), **locals()}
+    sum = timeit('m.sum_tree(tree)', globals=g)
+    sum2 = timeit('tree.sum()', globals=g)
+    fsum = dumb_time(lambda: m.bench_sum(tree))
+    fsum2 = dumb_time(lambda: m.bench_sum_method(tree))
+    build = timeit('m.build(5)', globals=g)
+    return (sum, sum2, fsum, fsum2, build)
+
+# Basic functionality test
+basic_test(native)
+
+# Benchmark if we are benchmarking
+if os.environ.get('MYPYC_RUN_BENCH') == '1':
+    nsum, nsum2, nfsum, nfsum2, nbuild = test(native)
+    isum, isum2, ifsum, ifsum2, ibuild = test(interpreted)
+    print(nsum, nsum2, nfsum, nbuild)
+    print("Sum speedup:", isum/nsum)
+    print("Sum method speedup:", isum2/nsum2)
+    print("Sum (fast) speedup:", ifsum/nfsum)
+    print("Sum (fast) method speedup:", ifsum2/nfsum2)
+    print("Build speedup:", ibuild/nbuild)
+
+[case testBenchmarkVisitorTree]
+from mypy_extensions import trait
+from typing import cast, Generic, TypeVar, Any
+
+T = TypeVar('T')
+class Tree:
+    def accept(self, v: 'TreeVisitor[T]') -> T:
+        pass
+class Leaf(Tree):
+    def accept(self, v: 'TreeVisitor[T]') -> T:
+        return v.visit_leaf(self)
+class Node(Tree):
+    def __init__(self, value: int, left: Tree, right: Tree) -> None:
+        self.value = value
+        self.left = left
+        self.right = right
+    def accept(self, v: 'TreeVisitor[T]') -> T:
+        return v.visit_node(self)
+
+@trait
+class TreeVisitor(Generic[T]):
+    def visit_leaf(self, x: Leaf) -> T: return cast(T, None)
+    def visit_node(self, x: Node) -> T: return cast(T, None)
+
+class SumVisitor(TreeVisitor[int]):
+    def sum(self, x: Tree) -> int:
+        return x.accept(self)
+    def visit_leaf(self, x: Leaf) -> int:
+        return 0
+    def visit_node(self, x: Node) -> int:
+        return x.value + self.sum(x.left) + self.sum(x.right)
+
+def equal(x: Tree, y: Tree) -> bool:
+    return EqualVisitor(x).equal(y)
+
+class EqualVisitor(TreeVisitor[bool]):
+    def __init__(self, left: Tree) -> None:
+        self.left = left
+    def equal(self, right: Tree) -> bool:
+        return right.accept(self)
+    def visit_leaf(self, right: Leaf) -> bool:
+        return isinstance(self.left, Leaf)
+    def visit_node(self, right: Node) -> bool:
+        if isinstance(self.left, Node):
+            # our boolean stuff is crap
+            if (self.left.value == right.value and equal(self.left.left, right.left)
+                    and equal(self.left.right, right.right)):
+                return True
+        return False
+
+def sum_tree(x: Tree) -> int:
+    return SumVisitor().sum(x)
+
+def build(n: int) -> Tree:
+    if n == 0:
+        return Leaf()
+    return Node(n, build(n - 1), build(n - 1))
+
+def bench_sum_tree(x: Tree) -> None:
+    for i in range(100000):
+        sum_tree(x)
+def bench_equal_tree(x: Tree, y: Tree) -> None:
+    for i in range(100000):
+        equal(x, y)
+
+[file driver.py]
+from typing import Optional
+import interpreted
+import native
+from timeit import timeit
+from time import time
+import os
+import sys
+
+# Side test: some stuff about MROs and generics
+if sys.version_info[:3] > (3, 5, 2):
+    assert tuple(x.__name__ for x in interpreted.SumVisitor.mro()) == ('SumVisitor', 'TreeVisitor', 'Generic', 'object')
+    assert tuple(x.__name__ for x in native.SumVisitor.mro()) == ('SumVisitor', 'TreeVisitor', 'Generic', 'object')
+    assert str(native.TreeVisitor[native.T]) == "native.TreeVisitor[~T]"
+
+assert native.TreeVisitor.__name__ == "TreeVisitor"
+assert native.SumVisitor.__name__ == "SumVisitor"
+
+def dumb_time(f):
+    t0 = time()
+    f()
+    t1 = time()
+    return t1 - t0
+
+def basic_test(m):
+    tree = m.build(5)
+    tree2 = m.build(5)
+    tree2.right.right.right.value = 10
+    assert m.sum_tree(tree) == 57
+    assert m.equal(tree, tree)
+    assert not m.equal(tree, tree2)
+
+    assert isinstance(native.SumVisitor(), native.TreeVisitor)
+
+    return tree
+
+def test(m):
+    tree = basic_test(m)
+
+    g = {**globals(), **locals()}
+    fsum = dumb_time(lambda: m.bench_sum_tree(tree))
+    feq = dumb_time(lambda: m.bench_equal_tree(tree, tree))
+    return fsum, feq
+
+basic_test(native)
+
+if os.environ.get('MYPYC_RUN_BENCH') == '1':
+    nfsum, nfeq = test(native)
+    ifsum, ifeq = test(interpreted)
+    print(nfsum)
+    print("Sum speedup:", ifsum/nfsum)
+    print("Equal speedup:", ifeq/nfeq)