def finalize_short_preamble(self, start_label):
short = self.short
assert short[-1].getopnum() == rop.JUMP
target_token = start_label.getdescr()
assert isinstance(target_token, TargetToken)
# Turn guards into conditional jumps to the preamble
for i in range(len(short)):
op = short[i]
if op.is_guard():
op = op.clone()
op.setfailargs(None)
op.setdescr(None) # will be set to a proper descr when the preamble is used
short[i] = op
# Clone ops and boxes to get private versions and
short_inputargs = short[0].getarglist()
boxmap = {}
newargs = [None] * len(short_inputargs)
for i in range(len(short_inputargs)):
a = short_inputargs[i]
if a in boxmap:
newargs[i] = boxmap[a]
else:
newargs[i] = a.clonebox()
boxmap[a] = newargs[i]
inliner = Inliner(short_inputargs, newargs)
target_token.assumed_classes = {}
for i in range(len(short)):
op = short[i]
newop = inliner.inline_op(op)
if op.result and op.result in self.short_boxes.assumed_classes:
target_token.assumed_classes[newop.result] = self.short_boxes.assumed_classes[op.result]
short[i] = newop
# Forget the values to allow them to be freed
for box in short[0].getarglist():
box.forget_value()
for op in short:
if op.result:
op.result.forget_value()
target_token.short_preamble = self.short
def jump_to_already_compiled_trace(self, jumpop, patchguardop):
jumpop = jumpop.clone()
assert jumpop.getopnum() == rop.JUMP
cell_token = jumpop.getdescr()
assert isinstance(cell_token, JitCellToken)
if not cell_token.target_tokens:
return False
if not self.inline_short_preamble:
assert cell_token.target_tokens[0].virtual_state is None
jumpop.setdescr(cell_token.target_tokens[0])
self.optimizer.send_extra_operation(jumpop)
return True
args = jumpop.getarglist()
virtual_state = self.get_virtual_state(args)
values = [self.getvalue(arg)
for arg in jumpop.getarglist()]
debug_start('jit-log-virtualstate')
virtual_state.debug_print("Looking for ", metainterp_sd=self.optimizer.metainterp_sd)
for target in cell_token.target_tokens:
if not target.virtual_state:
continue
extra_guards = []
try:
cpu = self.optimizer.cpu
state = target.virtual_state.generate_guards(virtual_state,
values,
cpu)
extra_guards = state.extra_guards
if extra_guards:
debugmsg = 'Guarded to match '
else:
debugmsg = 'Matched '
except VirtualStatesCantMatch, e:
debugmsg = 'Did not match:\n%s\n' % (e.msg, )
target.virtual_state.debug_print(debugmsg, e.state.bad, metainterp_sd=self.optimizer.metainterp_sd)
continue
assert patchguardop is not None or (extra_guards == [] and len(target.short_preamble) == 1)
target.virtual_state.debug_print(debugmsg, {})
debug_stop('jit-log-virtualstate')
args = target.virtual_state.make_inputargs(values, self.optimizer,
keyboxes=True)
short_inputargs = target.short_preamble[0].getarglist()
inliner = Inliner(short_inputargs, args)
for guard in extra_guards:
if guard.is_guard():
assert isinstance(patchguardop, GuardResOp)
assert isinstance(guard, GuardResOp)
guard.rd_snapshot = patchguardop.rd_snapshot
guard.rd_frame_info_list = patchguardop.rd_frame_info_list
guard.setdescr(compile.ResumeAtPositionDescr())
self.optimizer.send_extra_operation(guard)
try:
# NB: the short_preamble ends with a jump
self._inline_short_preamble(target.short_preamble, inliner,
patchguardop,
target.assumed_classes)
except InvalidLoop:
#debug_print("Inlining failed unexpectedly",
# "jumping to preamble instead")
assert cell_token.target_tokens[0].virtual_state is None
jumpop.setdescr(cell_token.target_tokens[0])
self.optimizer.send_extra_operation(jumpop)
return True
def close_loop(self, start_label, jumpop, patchguardop):
virtual_state = self.initial_virtual_state
short_inputargs = self.short[0].getarglist()
inputargs = self.inputargs
short_jumpargs = inputargs[:]
# Construct jumpargs from the virtual state
original_jumpargs = jumpop.getarglist()[:]
values = [self.getvalue(arg) for arg in jumpop.getarglist()]
try:
jumpargs = virtual_state.make_inputargs(values, self.optimizer)
except BadVirtualState:
raise InvalidLoop('The state of the optimizer at the end of ' +
'peeled loop is inconsistent with the ' +
'VirtualState at the beginning of the peeled ' +
'loop')
jumpop.initarglist(jumpargs)
# Inline the short preamble at the end of the loop
jmp_to_short_args = virtual_state.make_inputargs(values,
self.optimizer,
keyboxes=True)
assert len(short_inputargs) == len(jmp_to_short_args)
args = {}
for i in range(len(short_inputargs)):
if short_inputargs[i] in args:
if args[short_inputargs[i]] != jmp_to_short_args[i]:
raise InvalidLoop('The short preamble wants the ' +
'same box passed to multiple of its ' +
'inputargs, but the jump at the ' +
'end of this bridge does not do that.')
args[short_inputargs[i]] = jmp_to_short_args[i]
self.short_inliner = Inliner(short_inputargs, jmp_to_short_args)
self._inline_short_preamble(self.short, self.short_inliner,
patchguardop, self.short_boxes.assumed_classes)
# Import boxes produced in the preamble but used in the loop
newoperations = self.optimizer.get_newoperations()
self.boxes_created_this_iteration = {}
i = j = 0
while i < len(newoperations) or j < len(jumpargs):
if i == len(newoperations):
while j < len(jumpargs):
a = jumpargs[j]
#if self.optimizer.loop.logops:
# debug_print('J: ' + self.optimizer.loop.logops.repr_of_arg(a))
self.import_box(a, inputargs, short_jumpargs, jumpargs)
j += 1
else:
self._import_op(newoperations[i], inputargs, short_jumpargs, jumpargs)
i += 1
newoperations = self.optimizer.get_newoperations()
jumpop.initarglist(jumpargs)
self.optimizer.send_extra_operation(jumpop)
self.short.append(ResOperation(rop.JUMP, short_jumpargs, None, descr=jumpop.getdescr()))
# Verify that the virtual state at the end of the loop is one
# that is compatible with the virtual state at the start of the loop
final_virtual_state = self.get_virtual_state(original_jumpargs)
#debug_start('jit-log-virtualstate')
#virtual_state.debug_print('Closed loop with ')
bad = {}
if not virtual_state.generalization_of(final_virtual_state, bad,
cpu=self.optimizer.cpu):
# We ended up with a virtual state that is not compatible
# and we are thus unable to jump to the start of the loop
#final_virtual_state.debug_print("Bad virtual state at end of loop, ",
# bad)
#debug_stop('jit-log-virtualstate')
raise InvalidLoop('The virtual state at the end of the peeled ' +
'loop is not compatible with the virtual ' +
'state at the start of the loop which makes ' +
'it impossible to close the loop')
#debug_stop('jit-log-virtualstate')
maxguards = self.optimizer.metainterp_sd.warmrunnerdesc.memory_manager.max_retrace_guards
if self.optimizer.emitted_guards > maxguards:
target_token = jumpop.getdescr()
assert isinstance(target_token, TargetToken)
target_token.targeting_jitcell_token.retraced_count = sys.maxint
self.finalize_short_preamble(start_label)
def compile_loop(metainterp,
greenkey,
start,
inputargs,
jumpargs,
full_preamble_needed=True,
try_disabling_unroll=False):
"""Try to compile a new procedure by closing the current history back
to the first operation.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
history = metainterp.history
enable_opts = jitdriver_sd.warmstate.enable_opts
if try_disabling_unroll:
if 'unroll' not in enable_opts:
return None
enable_opts = enable_opts.copy()
del enable_opts['unroll']
jitcell_token = make_jitcell_token(jitdriver_sd)
part = create_empty_loop(metainterp)
part.inputargs = inputargs[:]
h_ops = history.operations
label = ResOperation(rop.LABEL,
inputargs,
None,
descr=TargetToken(jitcell_token))
end_label = ResOperation(rop.LABEL, jumpargs, None, descr=jitcell_token)
part.operations = [label] + h_ops[start:] + [end_label]
try:
start_state = optimize_trace(metainterp_sd,
jitdriver_sd,
part,
enable_opts,
export_state=True)
except InvalidLoop:
return None
target_token = part.operations[0].getdescr()
assert isinstance(target_token, TargetToken)
all_target_tokens = [target_token]
loop = create_empty_loop(metainterp)
loop.inputargs = part.inputargs
loop.operations = part.operations
loop.quasi_immutable_deps = {}
if part.quasi_immutable_deps:
loop.quasi_immutable_deps.update(part.quasi_immutable_deps)
if part.operations[-1].getopnum() == rop.LABEL:
inliner = Inliner(inputargs, jumpargs)
part.quasi_immutable_deps = None
part.operations = [part.operations[-1]] + \
[inliner.inline_op(h_ops[i]) for i in range(start, len(h_ops))] + \
[ResOperation(rop.JUMP, [inliner.inline_arg(a) for a in jumpargs],
None, descr=jitcell_token)]
target_token = part.operations[0].getdescr()
assert isinstance(target_token, TargetToken)
all_target_tokens.append(target_token)
inputargs = jumpargs
jumpargs = part.operations[-1].getarglist()
try:
optimize_trace(metainterp_sd,
jitdriver_sd,
part,
enable_opts,
start_state=start_state,
export_state=False)
except InvalidLoop:
return None
loop.operations = loop.operations[:-1] + part.operations
if part.quasi_immutable_deps:
loop.quasi_immutable_deps.update(part.quasi_immutable_deps)
assert part.operations[-1].getopnum() != rop.LABEL
if not loop.quasi_immutable_deps:
loop.quasi_immutable_deps = None
for box in loop.inputargs:
assert isinstance(box, Box)
loop.original_jitcell_token = jitcell_token
for label in all_target_tokens:
assert isinstance(label, TargetToken)
if label.virtual_state and label.short_preamble:
metainterp_sd.logger_ops.log_short_preamble([],
label.short_preamble)
jitcell_token.target_tokens = all_target_tokens
propagate_original_jitcell_token(loop)
send_loop_to_backend(greenkey, jitdriver_sd, metainterp_sd, loop, "loop")
record_loop_or_bridge(metainterp_sd, loop)
return all_target_tokens[0]
