-- 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)