def test_a_buncha_stuff (self):
assert_ = self.assert_
class Dummy(object):
def foo (self, when, token = None):
assert_(token is not None)
time.sleep(random.random() / 200.0)
return token
def sender_loop (loopnum):
obj = tpool.Proxy(Dummy())
count = 100
for n in xrange(count):
sleep(random.random() / 200.0)
now = time.time()
token = loopnum * count + n
rv = obj.foo(now, token = token)
self.assertEquals(token, rv)
sleep(random.random() / 200.0)
cnt = 10
pile = GreenPile(cnt)
for i in xrange(cnt):
pile.spawn(sender_loop, i)
results = list(pile)
self.assertEquals(len(results), cnt)
tpool.killall()
def test_a_buncha_stuff(self):
assert_ = self.assert_
class Dummy(object):
def foo(self, when, token=None):
assert_(token is not None)
time.sleep(random.random() / 200.0)
return token
def sender_loop(loopnum):
obj = tpool.Proxy(Dummy())
count = 100
for n in xrange(count):
sleep(random.random() / 200.0)
now = time.time()
token = loopnum * count + n
rv = obj.foo(now, token=token)
self.assertEquals(token, rv)
sleep(random.random() / 200.0)
cnt = 10
pile = GreenPile(cnt)
for i in xrange(cnt):
pile.spawn(sender_loop, i)
results = list(pile)
self.assertEquals(len(results), cnt)
tpool.killall()
def test_leakage_from_tracebacks (self):
tpool.execute(noop) # get it started
gc.collect()
initial_objs = len(gc.get_objects())
for i in xrange(10):
self.assertRaises(RuntimeError, tpool.execute, raise_exception)
gc.collect()
middle_objs = len(gc.get_objects())
# some objects will inevitably be created by the previous loop
# now we test to ensure that running the loop an order of
# magnitude more doesn't generate additional objects
for i in xrange(100):
self.assertRaises(RuntimeError, tpool.execute, raise_exception)
first_created = middle_objs - initial_objs
gc.collect()
second_created = len(gc.get_objects()) - middle_objs
self.assert_(second_created - first_created < 10,
"first loop: %s, second loop: %s" % (first_created, second_created))
tpool.killall()
def test_benchmark (self):
""" Benchmark computing the amount of overhead tpool adds to function calls."""
iterations = 10000
import timeit
imports = """
from tests.tpool_test import noop
from evy.tpool import execute
"""
t = timeit.Timer("noop()", imports)
results = t.repeat(repeat = 3, number = iterations)
best_normal = min(results)
t = timeit.Timer("execute(noop)", imports)
results = t.repeat(repeat = 3, number = iterations)
best_tpool = min(results)
tpool_overhead = (best_tpool - best_normal) / iterations
print "%s iterations\nTpool overhead is %s seconds per call. Normal: %s; Tpool: %s" % (
iterations, tpool_overhead, best_normal, best_tpool)
tpool.killall()
def test_leakage_from_tracebacks(self):
tpool.execute(noop) # get it started
gc.collect()
initial_objs = len(gc.get_objects())
for i in xrange(10):
self.assertRaises(RuntimeError, tpool.execute, raise_exception)
gc.collect()
middle_objs = len(gc.get_objects())
# some objects will inevitably be created by the previous loop
# now we test to ensure that running the loop an order of
# magnitude more doesn't generate additional objects
for i in xrange(100):
self.assertRaises(RuntimeError, tpool.execute, raise_exception)
first_created = middle_objs - initial_objs
gc.collect()
second_created = len(gc.get_objects()) - middle_objs
self.assert_(
second_created - first_created < 10,
"first loop: %s, second loop: %s" %
(first_created, second_created))
tpool.killall()
def test_benchmark(self):
""" Benchmark computing the amount of overhead tpool adds to function calls."""
iterations = 10000
import timeit
imports = """
from tests.tpool_test import noop
from evy.tpool import execute
"""
t = timeit.Timer("noop()", imports)
results = t.repeat(repeat=3, number=iterations)
best_normal = min(results)
t = timeit.Timer("execute(noop)", imports)
results = t.repeat(repeat=3, number=iterations)
best_tpool = min(results)
tpool_overhead = (best_tpool - best_normal) / iterations
print "%s iterations\nTpool overhead is %s seconds per call. Normal: %s; Tpool: %s" % (
iterations, tpool_overhead, best_normal, best_tpool)
tpool.killall()
def tearDown (self):
super(TpoolConnectionPool, self).tearDown()
from evy import tpool
tpool.killall()
def tearDown (self):
tpool.killall()
super(TestTpool, self).tearDown()
def test_killall (self):
tpool.killall()
tpool.setup()
def tearDown(self):
super(TpoolConnectionPool, self).tearDown()
from evy import tpool
tpool.killall()
def tearDown(self):
tpool.killall()
super(TestTpool, self).tearDown()
def test_killall(self):
tpool.killall()
tpool.setup()