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)