def test_schedule_callback(self):
res = []
cb = []
def schedule_cb(prev, next):
cb.append((prev, next))
stackless.set_schedule_callback(schedule_cb)
def f(i):
res.append('A_%s' % i)
stackless.schedule()
res.append('B_%s' % i)
t1 = stackless.tasklet(f)(1)
t2 = stackless.tasklet(f)(2)
maintask = stackless.getmain()
stackless.run()
assert res == ['A_1', 'A_2', 'B_1', 'B_2']
assert len(cb) == 5
assert cb[0] == (maintask, t1)
assert cb[1] == (t1, t2)
assert cb[2] == (t2, t1)
assert cb[3] == (t1, t2)
assert cb[4] == (t2, maintask)
def testExceptionInScheduleCallback(self):
stackless.set_schedule_callback(self.scheduleCallback)
self.addCleanup(stackless.set_schedule_callback, None)
stackless.tasklet(lambda: None)()
with captured_stderr() as stderr:
stackless.run()
self.assertTrue("scheduleCallback" in stderr.getvalue())
def _runServiceById(sid, proto_func):
ftlog.info("run service:", sid)
_initProtocol(sid, proto_func)
stackless.set_schedule_callback(_tasklet_schedule_cb)
if REACTOR_RUN_NORMAL:
mainloop()
return
stackless.tasklet(mainloop)()
stackless.run()
def testGetCallback(self):
mon = SchedulingMonitor()
self.assertIsNone(stackless.get_schedule_callback())
old = stackless.set_schedule_callback(mon)
self.assertIsNone(old)
self.assertIs(stackless.get_schedule_callback(), mon)
old = stackless.set_schedule_callback(None)
self.assertIs(old, mon)
self.assertIsNone(stackless.get_schedule_callback())
def _runServiceById(sid, proto_func):
ftlog.info("run service:", sid)
_initProtocol(sid, proto_func)
stackless.set_schedule_callback(_tasklet_schedule_cb)
if REACTOR_RUN_NORMAL:
mainloop()
return
stackless.tasklet(mainloop)()
stackless.run()
def testGetCallback(self):
mon = SchedulingMonitor()
self.assertIsNone(stackless.get_schedule_callback())
old = stackless.set_schedule_callback(mon)
self.assertIsNone(old)
self.assertIs(stackless.get_schedule_callback(), mon)
old = stackless.set_schedule_callback(None)
self.assertIs(old, mon)
self.assertIsNone(stackless.get_schedule_callback())
def test0(self):
"Test #callbacks before and after running isolated monitor."
mon1 = SchedulingMonitor()
stackless.set_schedule_callback(mon1)
stackless.tasklet(stackless.test_cframe)(3)
stackless.tasklet(stackless.test_cframe)(3)
# precondition
self.failUnless(mon1.count == 0, "No callbacks before running")
# running
stackless.run()
# postcondition
self.failUnless(mon1.count >= 2 * 3,
"At least as may callbacks as many test_cframe calls")
def test0(self):
"Test callbacks before and after running isolated monitor."
mon1 = SchedulingMonitor()
stackless.set_schedule_callback(mon1)
stackless.tasklet(_teststackless.test_cframe)(3)
stackless.tasklet(_teststackless.test_cframe)(3)
# precondition
self.assertEqual(mon1.count, 0, "No callbacks before running")
# running
stackless.run()
# postcondition
self.assertGreaterEqual(
mon1.count, 2 * 3,
"At least as may callbacks as many test_cframe calls")
def main(debug=False):
m = mutex()
NamedTasklet(f, name="tick")(m)
NamedTasklet(f, name="trick")(m)
NamedTasklet(f, name="track")(m)
if debug:
stackless.set_channel_callback(channel_cb)
stackless.set_schedule_callback(schedule_cb)
stackless.run()
stackless.set_channel_callback(None)
stackless.set_schedule_callback(None)
def patch_stackless():
'''
This function should be called to patch the stackless module so that new tasklets are properly tracked in the
debugger.
'''
global _application_set_schedule_callback
_application_set_schedule_callback = stackless.set_schedule_callback(_schedule_callback)
def set_schedule_callback(callable):
global _application_set_schedule_callback
old = _application_set_schedule_callback
_application_set_schedule_callback = callable
return old
def get_schedule_callback():
global _application_set_schedule_callback
return _application_set_schedule_callback
set_schedule_callback.__doc__ = stackless.set_schedule_callback.__doc__
if hasattr(stackless, "get_schedule_callback"):
get_schedule_callback.__doc__ = stackless.get_schedule_callback.__doc__
stackless.set_schedule_callback = set_schedule_callback
stackless.get_schedule_callback = get_schedule_callback
if not hasattr(stackless.tasklet, "trace_function"):
# Older versions of Stackless, released before 2014
__call__.__doc__ = stackless.tasklet.__call__.__doc__
stackless.tasklet.__call__ = __call__
setup.__doc__ = stackless.tasklet.setup.__doc__
stackless.tasklet.setup = setup
run.__doc__ = stackless.run.__doc__
stackless.run = run
def patch_stackless():
'''
This function should be called to patch the stackless module so that new tasklets are properly tracked in the
debugger.
'''
global _application_set_schedule_callback
_application_set_schedule_callback = stackless.set_schedule_callback(_schedule_callback)
def set_schedule_callback(callable):
global _application_set_schedule_callback
old = _application_set_schedule_callback
_application_set_schedule_callback = callable
return old
def get_schedule_callback():
global _application_set_schedule_callback
return _application_set_schedule_callback
set_schedule_callback.__doc__ = stackless.set_schedule_callback.__doc__
if hasattr(stackless, "get_schedule_callback"):
get_schedule_callback.__doc__ = stackless.get_schedule_callback.__doc__
stackless.set_schedule_callback = set_schedule_callback
stackless.get_schedule_callback = get_schedule_callback
if not hasattr(stackless.tasklet, "trace_function"):
# Older versions of Stackless, released before 2014
__call__.__doc__ = stackless.tasklet.__call__.__doc__
stackless.tasklet.__call__ = __call__
setup.__doc__ = stackless.tasklet.setup.__doc__
stackless.tasklet.setup = setup
run.__doc__ = stackless.run.__doc__
stackless.run = run
def test0(self):
"Test #callbacks before and after running isolated monitor."
mon1 = SchedulingMonitor()
stackless.set_schedule_callback(mon1)
stackless.tasklet(stackless.test_cframe)(3)
stackless.tasklet(stackless.test_cframe)(3)
# precondition
self.assertEqual(mon1.count, 0,
"No callbacks before running")
# running
stackless.run()
# postcondition
self.assertGreaterEqual(
mon1.count, 2*3,
"At least as may callbacks as many test_cframe calls")
def testTracing(self):
t1 = stackless.tasklet(self.f)()
t2 = stackless.tasklet(self.f)()
t3 = stackless.tasklet(self.f)()
self.setup_seen((t1, t2, t3),
(self.f, self.foo, mutex.lock, mutex.unlock))
stackless.set_schedule_callback(self.schedule_cb)
stackless.run()
stackless.set_schedule_callback(None)
seen = len([c for c in self.seen.itervalues() if c > 0])
self.assertListEqual(self.schedule_callback_exc, [])
self.assertListEqual(self.unexpected_trace_events, [])
# We won't see every line, because of if/else, try/except, comments, ...
# But we should see about 80%
self.assertGreater(float(seen) / len(self.seen), 0.75)
def patch_stackless():
'''
This function should be called to patch the stackless module so that new tasklets are properly tracked in the
debugger.
'''
stackless.set_schedule_callback(_schedule_callback)
def set_schedule_callback(callable):
global _application_set_schedule_callback
_application_set_schedule_callback = callable
set_schedule_callback.__doc__ = stackless.set_schedule_callback.__doc__
stackless.set_schedule_callback = set_schedule_callback
__call__.__doc__ = stackless.tasklet.__call__.__doc__
stackless.tasklet.__call__ = __call__
run.__doc__ = stackless.run.__doc__
stackless.run = run
def testTracing(self):
t1 = stackless.tasklet(self.f)()
t2 = stackless.tasklet(self.f)()
t3 = stackless.tasklet(self.f)()
self.setup_seen((t1, t2, t3),
(self.f, self.foo, mutex.lock, mutex.unlock))
stackless.set_schedule_callback(self.schedule_cb)
stackless.run()
stackless.set_schedule_callback(None)
seen = len([c for c in self.seen.itervalues() if c > 0])
self.assertListEqual(self.schedule_callback_exc, [])
self.assertListEqual(self.unexpected_trace_events, [])
# We won't see every line, because of if/else, try/except, comments, ...
# But we should see about 80%
self.assertGreater(float(seen) / len(self.seen), 0.75)
def patch_stackless():
'''
This function should be called to patch the stackless module so that new tasklets are properly tracked in the
debugger.
'''
stackless.set_schedule_callback(_schedule_callback)
def set_schedule_callback(callable):
global _application_set_schedule_callback
_application_set_schedule_callback = callable
set_schedule_callback.__doc__ = stackless.set_schedule_callback.__doc__
stackless.set_schedule_callback = set_schedule_callback
__call__.__doc__ = stackless.tasklet.__call__.__doc__
stackless.tasklet.__call__ = __call__
run.__doc__ = stackless.run.__doc__
stackless.run = run
def test1(self):
"Test multiple monitors, from test/test_set_schedule_callback.py"
fu = self.assertTrue
n = 2
mon1 = SchedulingMonitor()
stackless.set_schedule_callback(mon1)
v = 3
for i in range(n): stackless.tasklet(stackless.test_cframe)(v)
c1 = mon1.count
fu(c1 == 0, "No callbacks before running")
stackless.run()
c1 = mon1.count
fu(c1 >= n*v, "At least as may callbacks as many test_cframe calls")
mon2 = SchedulingMonitor()
stackless.set_schedule_callback(mon2)
v = 5
for i in range(n): stackless.tasklet(stackless.test_cframe)(v)
stackless.run()
c2 = mon2.count
fu(c2 >= n*v, "At least as may callbacks as many test_cframe calls")
fu(mon1.count == c1, "No calls to previous callback")
fu(c2 > c1, "More test_cframe calls => more callbacks on second run")
stackless.set_schedule_callback(None)
v = 7
for i in range(n): stackless.tasklet(stackless.test_cframe)(v)
stackless.run()
c1p = mon1.count
c2p = mon2.count
fu(c1p == c1, "No calls to previous callback after setting it to None")
fu(c2p == c2, "No calls to previous callback after setting it to None")
def test1(self):
"Test multiple monitors, from test/test_set_schedule_callback.py"
fu = self.assertTrue
n = 2
mon1 = SchedulingMonitor()
stackless.set_schedule_callback(mon1)
v = 3
for i in range(n): stackless.tasklet(stackless.test_cframe)(v)
c1 = mon1.count
fu(c1 == 0, "No callbacks before running")
stackless.run()
c1 = mon1.count
fu(c1 >= n*v, "At least as may callbacks as many test_cframe calls")
mon2 = SchedulingMonitor()
stackless.set_schedule_callback(mon2)
v = 5
for i in range(n): stackless.tasklet(stackless.test_cframe)(v)
stackless.run()
c2 = mon2.count
fu(c2 >= n*v, "At least as may callbacks as many test_cframe calls")
fu(mon1.count == c1, "No calls to previous callback")
fu(c2 > c1, "More test_cframe calls => more callbacks on second run")
stackless.set_schedule_callback(None)
v = 7
for i in range(n): stackless.tasklet(stackless.test_cframe)(v)
stackless.run()
c1p = mon1.count
c2p = mon2.count
fu(c1p == c1, "No calls to previous callback after setting it to None")
fu(c2p == c2, "No calls to previous callback after setting it to None")
def _initialize():
if _ModuelState.Inited:
return
_ModuelState.Inited = 1
# log.startLogging(sys.stdout)
if hasattr(stackless, 'get_schedule_callback'):
precb = stackless.get_schedule_callback()
elif hasattr(stackless, '_schedule_callback'):
precb = stackless._schedule_callback
else:
precb = None
stackless.set_schedule_callback(SchedulingCallback(precb))
curTasklet = stackless.getcurrent()
if isinstance(curTasklet, UsrTasklet):
TaskletMetrics.curUsrTasklet = curTasklet
TaskletMetrics.curUsrTaskletContext = curTasklet.context
else:
TaskletMetrics.curUsrTasklet = None
TaskletMetrics.curUsrTaskletContext = None
def test_schedule_callback(self):
res = []
cb = []
def schedule_cb(prev, next):
cb.append((prev, next))
stackless.set_schedule_callback(schedule_cb)
def f(i):
res.append('A_%s' % i)
stackless.schedule()
res.append('B_%s' % i)
t1 = stackless.tasklet(f)(1)
t2 = stackless.tasklet(f)(2)
maintask = stackless.getmain()
stackless.run()
assert res == ['A_1', 'A_2', 'B_1', 'B_2']
assert len(cb) == 5
assert cb[0] == (maintask, t1)
assert cb[1] == (t1, t2)
assert cb[2] == (t2, t1)
assert cb[3] == (t1, t2)
assert cb[4] == (t2, maintask)
def __initSharedMem(self):
self.__jobs_shm = create_shm("wfe-jobs", 524288)
self.__currentjob_shm = create_shm("wfe-current-job", 524288)
stackless.set_schedule_callback(self.__scheduleHandler)
self.__writeJobsToShm()
def test2currentWithPrevAndNext(self):
class Ex_Main(Exception):
name = 'call_run'
class Ex_A(Exception):
name = 'task_a'
def call_run():
try:
raise Ex_Main()
except Exception:
stackless.run()
def task_a():
try:
raise Ex_A()
except Exception:
stackless.schedule()
tasklet_a = stackless.tasklet(task_a)()
tasklet_main = stackless.current
#print "Tasklet a: %r" % (tasklet_a,)
#print "Tasklet main: %r" % (tasklet_main,)
switches = []
def cb(prev, next):
# find the real current according to the information in the frame stack
ex = sys.exc_info()
f = sys._getframe()
current = stackless.current
while f is not None:
if f.f_code in (call_run.func_code, task_a.func_code):
name = f.f_code.co_name
break
f = f.f_back
else:
# Can't deduce the current tasklet from the stack
name = None
#print "Unexpected stack: current %r, prev %r, next %r" % (current, prev, next)
#traceback.print_stack(file=sys.stdout)
if current is tasklet_main:
current_name = 'call_run'
elif current is tasklet_a:
current_name = 'task_a'
else:
print "Unexpected tasklet: current %r, prev %r, next %r" % (
current, prev, next)
traceback.print_stack(file=sys.stdout)
current_name = None
switches.append((name, ex[0], current_name))
stackless.set_schedule_callback(cb)
call_run()
stackless.set_schedule_callback(None)
for real_name, ex, current_name in switches:
if real_name:
self.assertEquals(real_name, current_name)
if ex:
self.assertEquals(ex.name, current_name)
def testExceptionInScheduleCallback(self):
stackless.set_schedule_callback(self.scheduleCallback)
self.addCleanup(stackless.set_schedule_callback, None)
stackless.tasklet(lambda:None)()
stackless.run()
def test2currentWithPrevAndNext(self):
class Ex_Main(Exception):
name = 'call_run'
class Ex_A(Exception):
name = 'task_a'
def call_run():
try:
raise Ex_Main()
except Exception:
stackless.run()
def task_a():
try:
raise Ex_A()
except Exception:
stackless.schedule()
tasklet_a = stackless.tasklet(task_a)()
tasklet_main = stackless.current
#print "Tasklet a: %r" % (tasklet_a,)
#print "Tasklet main: %r" % (tasklet_main,)
switches = []
def cb(prev, next):
# find the real current according to the information in the frame stack
ex = sys.exc_info()
f = sys._getframe()
current = stackless.current
while f is not None:
if f.f_code in (call_run.func_code, task_a.func_code):
name = f.f_code.co_name
break
f = f.f_back
else:
# Can't deduce the current tasklet from the stack
name = None
#print "Unexpected stack: current %r, prev %r, next %r" % (current, prev, next)
#traceback.print_stack(file=sys.stdout)
if current is tasklet_main:
current_name = 'call_run'
elif current is tasklet_a:
current_name = 'task_a'
else:
print "Unexpected tasklet: current %r, prev %r, next %r" % (current, prev, next)
traceback.print_stack(file=sys.stdout)
current_name = None
switches.append((name, ex[0], current_name))
stackless.set_schedule_callback(cb)
call_run()
stackless.set_schedule_callback(None)
for real_name, ex, current_name in switches:
if real_name:
self.assertEquals(real_name, current_name)
if ex:
self.assertEquals(ex.name, current_name)
import stackless
class CallCounter:
def __init__(self):
self.count = 0
def __call__(self, prev, next):
self.count += 1
#print "callback %s" % self.count
callback1 = CallCounter()
stackless.set_schedule_callback(callback1)
stackless.tasklet(stackless.test_cframe)(3)
stackless.tasklet(stackless.test_cframe)(3)
assert callback1.count == 0, "No callbacks before run"
stackless.run()
count1 = callback1.count
assert count1 >= 2 * 3, "At least as may callbacks as many test_cframe calls"
callback2 = CallCounter()
stackless.set_schedule_callback(callback2)
stackless.tasklet(stackless.test_cframe)(5)
stackless.tasklet(stackless.test_cframe)(5)
stackless.run()
count2 = callback2.count
assert count2 >= 2 * 5, "At least as may callbacks as many test_cframe calls"
assert callback1.count == count1, "No calls to previous callback"
assert count2 > count1, "More test_cframe calls => more callbacks on second run"
import stackless class CallCounter: def __init__(self): self.count = 0 def __call__(self, prev, next): self.count += 1 #print "callback %s" % self.count callback1 = CallCounter() stackless.set_schedule_callback(callback1) stackless.tasklet(stackless.test_cframe)(3) stackless.tasklet(stackless.test_cframe)(3) assert callback1.count==0, "No callbacks before run" stackless.run() count1 = callback1.count assert count1>= 2*3, "At least as may callbacks as many test_cframe calls" callback2 = CallCounter() stackless.set_schedule_callback(callback2) stackless.tasklet(stackless.test_cframe)(5) stackless.tasklet(stackless.test_cframe)(5) stackless.run() count2 = callback2.count assert count2>=2*5, "At least as may callbacks as many test_cframe calls" assert callback1.count==count1, "No calls to previous callback" assert count2>count1, "More test_cframe calls => more callbacks on second run" stackless.set_schedule_callback(None) stackless.tasklet(stackless.test_cframe)(7)
# Set the "global" trace function for the tasklet
next.trace_function = tf
# Set the "local" trace function for each frame
# This is required, if the tasklet is already running
frame = next.frame
if frame is current_frame:
frame = frame.f_back
while frame is not None:
frame.f_trace = tf
frame = frame.f_back
except:
traceback.print_exc()
finally:
sys.settrace(current_tf)
if __name__ == "__main__":
if len(sys.argv) > 1 and sys.argv[1] == 'hard':
stackless.enable_softswitch(False)
stackless.set_channel_callback(channel_cb)
stackless.set_schedule_callback(schedule_cb)
NamedTasklet(task, "tick")()
NamedTasklet(task, "trick")()
NamedTasklet(task, "track")()
stackless.run()
stackless.set_channel_callback(None)
stackless.set_schedule_callback(None)
def trace_tasklet_switches(self):
old_scb = stackless.get_schedule_callback()
switch_recorder = SwitchRecorder(old_scb)
self.addCleanup(stackless.set_schedule_callback, old_scb)
self.addCleanup(switch_recorder.print)
stackless.set_schedule_callback(switch_recorder)
def testExceptionInScheduleCallback(self):
stackless.set_schedule_callback(self.scheduleCallback)
self.addCleanup(stackless.set_schedule_callback, None)
stackless.tasklet(lambda: None)()
stackless.run()
