def test_random_class_knowledge(boxes_known_classes):
cls = FakeClass()
for box, known_class in boxes_known_classes:
if known_class:
box.set_forwarded(InstancePtrInfo(known_class=cls))
optimizer = FakeOptimizer()
refboxes = [
box for (box, _) in boxes_known_classes
if isinstance(box, InputArgRef)
]
numb_state = NumberingState(1)
numb_state.append_int(1) # size of resume block
liveboxes = [box for (box, _) in boxes_known_classes]
serialize_optimizer_knowledge(optimizer, numb_state, liveboxes, {}, None)
assert len(numb_state.create_numbering().code) == 4 + math.ceil(
len(refboxes) / 6.0)
dct = {box: cls for box, known_class in boxes_known_classes if known_class}
after_optimizer = FakeOptimizer(cpu=FakeCPU(dct))
deserialize_optimizer_knowledge(after_optimizer,
FakeStorage(numb_state.create_numbering()),
liveboxes, liveboxes)
for box, known_class in boxes_known_classes:
assert (box in after_optimizer.constant_classes) == known_class
def test_known_classes():
cls = FakeClass()
box1 = InputArgRef()
box1.set_forwarded(InstancePtrInfo(known_class=cls))
box2 = InputArgRef()
box3 = InputArgRef()
optimizer = FakeOptimizer()
numb_state = NumberingState(4)
numb_state.append_int(1) # size of resume block
liveboxes = [InputArgInt(), box2, box1, box3]
serialize_optimizer_knowledge(optimizer, numb_state, liveboxes, {}, None)
assert unpack_numbering(
numb_state.create_numbering()) == [1, 0b010000, 0, 0, 0]
rbox1 = InputArgRef()
rbox2 = InputArgRef()
rbox3 = InputArgRef()
after_optimizer = FakeOptimizer(cpu=FakeCPU({rbox1: cls}))
deserialize_optimizer_knowledge(after_optimizer,
FakeStorage(numb_state.create_numbering()),
[InputArgInt(), rbox2, rbox1, rbox3],
liveboxes)
assert box1 in after_optimizer.constant_classes
assert box2 not in after_optimizer.constant_classes
assert box3 not in after_optimizer.constant_classes
def optimize_loop(self, trace, resumestorage, call_pure_results):
traceiter = trace.get_iter()
if resumestorage:
frontend_inputargs = trace.inputargs
deserialize_optimizer_knowledge(
self, resumestorage, frontend_inputargs, traceiter.inputargs)
return self.propagate_all_forward(traceiter, call_pure_results)
def optimize_bridge(self, trace, runtime_boxes, call_pure_results,
inline_short_preamble, box_names_memo, resumestorage):
from rpython.jit.metainterp.optimizeopt.bridgeopt import deserialize_optimizer_knowledge
frontend_inputargs = trace.inputargs
trace = trace.get_iter()
self.optunroll._check_no_forwarding([trace.inputargs])
if resumestorage:
deserialize_optimizer_knowledge(self, resumestorage,
frontend_inputargs,
trace.inputargs)
info, ops = self.propagate_all_forward(trace, call_pure_results, False)
jump_op = info.jump_op
cell_token = jump_op.getdescr()
assert isinstance(cell_token, JitCellToken)
if not inline_short_preamble or len(cell_token.target_tokens) == 1:
self.jump_to_preamble(cell_token, jump_op)
return info, self._newoperations[:]
# force all the information that does not go to the short
# preamble at all
self.flush()
for a in jump_op.getarglist():
self.force_box_for_end_of_preamble(a)
try:
vs = self.optunroll.jump_to_existing_trace(jump_op,
None,
runtime_boxes,
force_boxes=False)
except InvalidLoop:
self.jump_to_preamble(cell_token, jump_op)
return info, self._newoperations[:]
if vs is None:
return info, self._newoperations[:]
warmrunnerdescr = self.metainterp_sd.warmrunnerdesc
limit = warmrunnerdescr.memory_manager.retrace_limit
if cell_token.retraced_count < limit:
cell_token.retraced_count += 1
debug_print('Retracing (%d/%d)' %
(cell_token.retraced_count, limit))
else:
# Try forcing boxes to avoid jumping to the preamble
try:
vs = self.optunroll.jump_to_existing_trace(jump_op,
None,
runtime_boxes,
force_boxes=True)
except InvalidLoop:
pass
if vs is None:
return info, self._newoperations[:]
debug_print("Retrace count reached, jumping to preamble")
self.jump_to_preamble(cell_token, jump_op)
return info, self._newoperations[:]
exported_state = self.optunroll.export_state(info.jump_op.getarglist(),
info.inputargs,
runtime_boxes,
box_names_memo)
exported_state.quasi_immutable_deps = self.quasi_immutable_deps
self._clean_optimization_info(self._newoperations)
return exported_state, self._newoperations
def optimize(self, metainterp_sd, jitdriver_sd, optimizations, unroll):
from rpython.jit.metainterp.optimizeopt.optimizer import Optimizer
from rpython.jit.metainterp.optimizeopt.bridgeopt import deserialize_optimizer_knowledge
#assert not unroll
opt = Optimizer(metainterp_sd, jitdriver_sd, optimizations)
traceiter = self.trace.get_iter()
if self.resumestorage:
frontend_inputargs = self.trace.inputargs
deserialize_optimizer_knowledge(opt, self.resumestorage,
frontend_inputargs,
traceiter.inputargs)
return opt.propagate_all_forward(traceiter, self.call_pure_results)