def new_process_consistency(self, process, old_process, w_active_context):
scheduler = wrapper.scheduler(space)
assert scheduler.active_process() is process.wrapped
priority_list = wrapper.scheduler(space).get_process_list(process.priority())
assert priority_list.first_link() is priority_list.last_link()
# activate does not remove the process from the process_list.
# The caller of activate is responsible
assert priority_list.first_link() is process.wrapped
def new_process_consistency(self, process, old_process, w_active_context):
scheduler = wrapper.scheduler(space)
assert scheduler.active_process() is process.wrapped
priority_list = wrapper.scheduler(space).get_process_list(
process.priority())
assert priority_list.first_link() is priority_list.last_link()
# activate does not remove the process from the process_list.
# The caller of activate is responsible
assert priority_list.first_link() is process.wrapped
def test_highest_priority(self):
py.test.raises(FatalError, wrapper.scheduler(space).wake_highest_priority_process)
process, old_process = self.make_processes(4, 2, space.w_false)
process.put_to_sleep()
old_process.put_to_sleep()
highest = wrapper.scheduler(space).wake_highest_priority_process()
assert highest.wrapped is process.wrapped
highest = wrapper.scheduler(space).wake_highest_priority_process()
assert highest.wrapped is old_process.wrapped
py.test.raises(FatalError, wrapper.scheduler(space).wake_highest_priority_process)
def test_suspend_active(self):
suspended_context = new_frame()
process, old_process = self.make_processes(4, 2, suspended_context)
current_context = new_frame()
with py.test.raises(interpreter.ProcessSwitch):
old_process.suspend(current_context)
process_list = wrapper.scheduler(space).get_process_list(old_process.priority())
assert process_list.first_link() is process_list.last_link()
assert process_list.first_link().is_nil(space)
assert old_process.my_list().is_nil(space)
assert old_process.suspended_context() is current_context.w_self()
assert wrapper.scheduler(space).active_process() is process.wrapped
def test_highest_priority(self):
py.test.raises(FatalError,
wrapper.scheduler(space).wake_highest_priority_process)
process, old_process = self.make_processes(4, 2, space.w_false)
process.put_to_sleep()
old_process.put_to_sleep()
highest = wrapper.scheduler(space).wake_highest_priority_process()
assert highest.wrapped is process.wrapped
highest = wrapper.scheduler(space).wake_highest_priority_process()
assert highest.wrapped is old_process.wrapped
py.test.raises(FatalError,
wrapper.scheduler(space).wake_highest_priority_process)
def test_suspend_active(self):
suspended_context = new_frame()
process, old_process = self.make_processes(4, 2, suspended_context)
current_context = new_frame()
with py.test.raises(interpreter.ProcessSwitch):
old_process.suspend(current_context)
process_list = wrapper.scheduler(space).get_process_list(
old_process.priority())
assert process_list.first_link() is process_list.last_link()
assert process_list.first_link().is_nil(space)
assert old_process.my_list().is_nil(space)
assert old_process.suspended_context() is current_context.w_self()
assert wrapper.scheduler(space).active_process() is process.wrapped
def get_instances_array(interp, s_frame, w_class=None, store=True,
some_instance=False):
# early return for classes that never had instances. This is true for a
# bunch of special classes.
if w_class:
if interp.space.w_SmallInteger.is_same_object(w_class):
return []
if interp.space.is_spur.is_set():
if interp.space.w_Character.is_same_object(w_class):
return []
if interp.image.version.is_64bit:
if interp.space.w_Float.is_same_object(w_class):
return []
if interp.image.version.is_modern:
if interp.space.w_BlockContext.is_same_object(w_class):
return []
# make sure we also get any objects in the currently active process
w_active_process = wrapper.scheduler(interp.space).active_process()
active_process = wrapper.ProcessWrapper(interp.space, w_active_process)
active_process.store_suspended_context(s_frame.w_self())
try:
match_w = s_frame.instances_array(w_class)
if match_w is None:
if some_instance and interp.space.is_spur.is_set():
# on Spur, someInstance really means just one, it's not used to
# start iterating over all instances
return get_instances_array_trace(interp, w_class,
some_instance=True)
match_w = get_instances_array_trace(interp, w_class)
if store:
s_frame.store_instances_array(w_class, match_w)
return match_w
finally:
active_process.store_suspended_context(interp.space.w_nil)
def test_semaphore_signal_wait(self):
semaphore = new_semaphore()
self.space = space
semaphore.signal(self)
suspendedcontext = new_frame()
currentcontext = new_frame()
process, old_process = self.make_processes(4, 2, suspendedcontext)
semaphore.wait(currentcontext)
assert semaphore.is_empty_list()
assert wrapper.scheduler(space).active_process() is old_process.wrapped
with py.test.raises(interpreter.ProcessSwitch):
semaphore.wait(currentcontext)
assert semaphore.first_link() is old_process.wrapped
assert wrapper.scheduler(space).active_process() is process.wrapped
py.test.raises(FatalError, semaphore.wait, space.w_true)
def active_context(space):
w_active_process = wrapper.scheduler(space).active_process()
active_process = wrapper.ProcessWrapper(space, w_active_process)
w_active_context = active_process.suspended_context()
assert isinstance(w_active_context, W_PointersObject)
active_process.store_suspended_context(space.w_nil)
return w_active_context.as_context_get_shadow(space)
def test_suspend_asleep(self):
process, old_process = self.make_processes(4, 2, space.w_false)
process.suspend(space.w_true)
process_list = wrapper.scheduler(space).get_process_list(process.priority())
assert process_list.first_link() is process_list.last_link()
assert process_list.first_link().is_nil(space)
assert process.my_list().is_nil(space)
def active_context(space):
w_active_process = wrapper.scheduler(space).active_process()
active_process = wrapper.ProcessWrapper(space, w_active_process)
w_active_context = active_process.suspended_context()
assert isinstance(w_active_context, W_PointersObject)
active_process.store_suspended_context(space.w_nil)
return w_active_context.as_context_get_shadow(space)
def test_semaphore_signal_wait(self):
semaphore = new_semaphore()
self.space = space
semaphore.signal(self)
suspendedcontext = new_frame()
currentcontext = new_frame()
process, old_process = self.make_processes(4, 2, suspendedcontext)
semaphore.wait(currentcontext)
assert semaphore.is_empty_list()
assert wrapper.scheduler(space).active_process() is old_process.wrapped
with py.test.raises(interpreter.ProcessSwitch):
semaphore.wait(currentcontext)
assert semaphore.first_link() is old_process.wrapped
assert wrapper.scheduler(space).active_process() is process.wrapped
py.test.raises(FatalError, semaphore.wait, space.w_true)
def test_suspend_asleep(self):
process, old_process = self.make_processes(4, 2, space.w_false)
process.suspend(space.w_true)
process_list = wrapper.scheduler(space).get_process_list(
process.priority())
assert process_list.first_link() is process_list.last_link()
assert process_list.first_link().is_nil(space)
assert process.my_list().is_nil(space)
def test_semaphore_wait_signal(self):
semaphore = new_semaphore()
suspendedcontext = new_frame()
currentcontext = new_frame()
process, old_process = self.make_processes(4, 2, suspendedcontext)
with py.test.raises(interpreter.ProcessSwitch):
semaphore.wait(currentcontext)
assert wrapper.scheduler(space).active_process() is process.wrapped
semaphore.signal(currentcontext)
assert wrapper.scheduler(space).active_process() is process.wrapped
process_list = wrapper.scheduler(space).get_process_list(old_process.priority())
assert process_list.remove_first_link_of_list() is old_process.wrapped
process.write(2, space.wrap_int(1))
with py.test.raises(interpreter.ProcessSwitch):
old_process.resume(currentcontext)
assert wrapper.scheduler(space).active_process() is old_process.wrapped
with py.test.raises(interpreter.ProcessSwitch):
semaphore.wait(currentcontext)
assert wrapper.scheduler(space).active_process() is process.wrapped
with py.test.raises(interpreter.ProcessSwitch):
semaphore.signal(currentcontext)
assert wrapper.scheduler(space).active_process() is old_process.wrapped
process_list = wrapper.scheduler(space).get_process_list(process.priority())
assert process_list.first_link() is process.wrapped
def test_semaphore_wait_signal(self):
semaphore = new_semaphore()
suspendedcontext = new_frame()
currentcontext = new_frame()
process, old_process = self.make_processes(4, 2, suspendedcontext)
with py.test.raises(interpreter.ProcessSwitch):
semaphore.wait(currentcontext)
assert wrapper.scheduler(space).active_process() is process.wrapped
semaphore.signal(currentcontext)
assert wrapper.scheduler(space).active_process() is process.wrapped
process_list = wrapper.scheduler(space).get_process_list(
old_process.priority())
assert process_list.remove_first_link_of_list() is old_process.wrapped
process.write(2, space.wrap_int(1))
with py.test.raises(interpreter.ProcessSwitch):
old_process.resume(currentcontext)
assert wrapper.scheduler(space).active_process() is old_process.wrapped
with py.test.raises(interpreter.ProcessSwitch):
semaphore.wait(currentcontext)
assert wrapper.scheduler(space).active_process() is process.wrapped
with py.test.raises(interpreter.ProcessSwitch):
semaphore.signal(currentcontext)
assert wrapper.scheduler(space).active_process() is old_process.wrapped
process_list = wrapper.scheduler(space).get_process_list(
process.priority())
assert process_list.first_link() is process.wrapped
def test_semaphore_wait(self):
semaphore = new_semaphore()
suspendedcontext = new_frame()
currentcontext = new_frame()
process, old_process = self.make_processes(4, 2, suspendedcontext)
with py.test.raises(interpreter.ProcessSwitch):
semaphore.wait(currentcontext)
assert semaphore.first_link() is old_process.wrapped
assert wrapper.scheduler(space).active_process() is process.wrapped
def test_semaphore_wait(self):
semaphore = new_semaphore()
suspendedcontext = new_frame()
currentcontext = new_frame()
process, old_process = self.make_processes(4, 2, suspendedcontext)
with py.test.raises(interpreter.ProcessSwitch):
semaphore.wait(currentcontext)
assert semaphore.first_link() is old_process.wrapped
assert wrapper.scheduler(space).active_process() is process.wrapped
def make_processes(self, sleepingpriority, runningpriority,
sleepingcontext):
if not isinstance(sleepingcontext, W_Object):
sleepingcontext = sleepingcontext.w_self()
scheduler = wrapper.scheduler(space)
sleeping = new_process(priority=sleepingpriority, w_suspended_context=sleepingcontext)
sleeping.put_to_sleep()
running = new_process(priority=runningpriority)
scheduler.store_active_process(running.wrapped)
return sleeping, running
def make_processes(self, sleepingpriority, runningpriority,
sleepingcontext):
if not isinstance(sleepingcontext, W_Object):
sleepingcontext = sleepingcontext.w_self()
scheduler = wrapper.scheduler(space)
sleeping = new_process(priority=sleepingpriority,
w_suspended_context=sleepingcontext)
sleeping.put_to_sleep()
running = new_process(priority=runningpriority)
scheduler.store_active_process(running.wrapped)
return sleeping, running
def test_step_run_something():
space, interp = runningSomethingImage(cached=False)
ap = wrapper.ProcessWrapper(space, wrapper.scheduler(space).active_process())
w_ctx = ap.suspended_context()
s_ctx = w_ctx.as_context_get_shadow(space)
ap.store_suspended_context(space.w_nil)
assert isinstance(s_ctx, storage_contexts.ContextPartShadow)
assert s_ctx.top().is_same_object(space.w_true)
interp.step(s_ctx)
interp.step(s_ctx)
assert s_ctx.top().value == 1
interp.step(s_ctx)
assert s_ctx.top().value == 2
interp.step(s_ctx)
assert s_ctx.top().value == 3
def create_process(interp, s_frame):
space = interp.space
w_active_process = wrapper.scheduler(space).active_process()
assert isinstance(w_active_process, W_PointersObject)
w_benchmark_proc = W_PointersObject(space,
w_active_process.getclass(space),
w_active_process.size())
if interp.image.version.has_closures:
# Priorities below 10 are not allowed in newer versions of Squeak.
active_priority = space.unwrap_int(w_active_process.fetch(space, 2))
priority = active_priority / 2 + 1
priority = max(11, priority)
else:
priority = 7
w_benchmark_proc.store(space, 1, s_frame.w_self())
w_benchmark_proc.store(space, 2, space.wrap_int(priority))
# Make process eligible for scheduling
wrapper.ProcessWrapper(space, w_benchmark_proc).put_to_sleep()
def create_process(interp, s_frame):
space = interp.space
w_active_process = wrapper.scheduler(space).active_process()
assert isinstance(w_active_process, W_PointersObject)
w_benchmark_proc = W_PointersObject(
space, w_active_process.getclass(space), w_active_process.size()
)
if interp.image.version.has_closures:
# Priorities below 10 are not allowed in newer versions of Squeak.
active_priority = space.unwrap_int(w_active_process.fetch(space, 2))
priority = active_priority / 2 + 1
priority = max(11, priority)
else:
priority = 7
w_benchmark_proc.store(space, 1, s_frame.w_self())
w_benchmark_proc.store(space, 2, space.wrap_int(priority))
# Make process eligible for scheduling
wrapper.ProcessWrapper(space, w_benchmark_proc).put_to_sleep()
def get_instances_array(interp,
s_frame,
w_class=None,
store=True,
some_instance=False):
# early return for classes that never had instances. This is true for a
# bunch of special classes.
if w_class:
if interp.space.w_SmallInteger.is_same_object(w_class):
return []
if interp.space.is_spur.is_set():
if interp.space.w_Character.is_same_object(w_class):
return []
if interp.image.version.is_64bit:
if interp.space.w_Float.is_same_object(w_class):
return []
if interp.image.version.is_modern:
if interp.space.w_BlockContext.is_same_object(w_class):
return []
# make sure we also get any objects in the currently active process
w_active_process = wrapper.scheduler(interp.space).active_process()
active_process = wrapper.ProcessWrapper(interp.space, w_active_process)
active_process.store_suspended_context(s_frame.w_self())
try:
match_w = s_frame.instances_array(w_class)
if match_w is None:
if some_instance and interp.space.is_spur.is_set():
# on Spur, someInstance really means just one, it's not used to
# start iterating over all instances
return get_instances_array_trace(interp,
w_class,
some_instance=True)
match_w = get_instances_array_trace(interp, w_class)
if store:
s_frame.store_instances_array(w_class, match_w)
return match_w
finally:
active_process.store_suspended_context(interp.space.w_nil)
def test_put_to_sleep(self):
process = new_process(priority=2)
process.put_to_sleep()
process_list = wrapper.scheduler(space).get_process_list(2)
assert process_list.first_link() is process_list.last_link()
assert process_list.first_link() is process.wrapped
def old_process_consistency(self, old_process, old_process_context):
assert old_process.suspended_context() is old_process_context.w_self()
priority_list = wrapper.scheduler(space).get_process_list(
old_process.priority())
assert priority_list.first_link() is old_process.wrapped
def test_step_forged_image():
ap = wrapper.ProcessWrapper(space, wrapper.scheduler(space).active_process())
s_ctx = ap.suspended_context().as_context_get_shadow(space)
assert isinstance(s_ctx, storage_contexts.ContextPartShadow)
assert s_ctx.top().is_same_object(space.w_true)
def test_put_to_sleep(self):
process = new_process(priority=2)
process.put_to_sleep()
process_list = wrapper.scheduler(space).get_process_list(2)
assert process_list.first_link() is process_list.last_link()
assert process_list.first_link() is process.wrapped
def old_process_consistency(self, old_process, old_process_context):
assert old_process.suspended_context() is old_process_context.w_self()
priority_list = wrapper.scheduler(space).get_process_list(old_process.priority())
assert priority_list.first_link() is old_process.wrapped
