timing.py

#!/usr/bin/env python
import sys
from timeit import repeat

import blinker


class Plain(object):
    def __init__(self):
        self.receivers = {}

    def send_fn_len_cmp(self):
        if not self._check_receivers():
            return
    def _check_receivers(self):
        return len(self.receivers) > 0

    def send_not_cmp(self):
        if not self.receivers:
            return

    def send_cmp(self):
        if self.receivers:
            pass
        else:
            return

    def send_not_len(self):
        if not len(self.receivers):
            return

    def send_len_cmp(self):
        if len(self.receivers) == 0:
            return


def run_test(setup, code, label):
    batch = 100000  # less stability higher than this, too fast when lower
    timing = repeat(code, setup, repeat=100, number=batch)
    fastest = (min(timing) / float(batch)) * 1000000000  # nanoseconds
    banner = "%s: %0.2f ns/call" % (label, fastest)
    print(banner)


def test_plain(fn):
    setup = 'from __main__ import Plain; s = Plain()'
    code = 's.%s()' % fn
    label = "python (%s)" % (fn,)
    run_test(setup, code, label)


def test_blinker():
    setup = 'from blinker import Signal; s = Signal()'
    code = 's.send()'
    if hasattr(blinker, '_speedup'):
        label = 'pr-35-cython (send)'
    elif hasattr(blinker.Signal, '_check_receivers'):
        label = 'pr-35-fallback (send)'
    else:
        label = 'baseline (send)'
    run_test(setup, code, label)

try:
    test_fn = sys.argv[1]
except IndexError:
    test_fn = 'send'

if test_fn == 'send':
    test_blinker()
else:
    try:
        test_plain(test_fn)
    except AttributeError:
        print("unknown test (%s)" % test_fn)