def compile_simple_loop(metainterp, greenkey, trace, runtime_args, enable_opts,
cut_at):
from rpython.jit.metainterp.optimizeopt import optimize_trace
jitdriver_sd = metainterp.jitdriver_sd
metainterp_sd = metainterp.staticdata
jitcell_token = make_jitcell_token(jitdriver_sd)
call_pure_results = metainterp.call_pure_results
data = SimpleCompileData(trace, call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
loop_info, ops = optimize_trace(metainterp_sd, jitdriver_sd,
data, metainterp.box_names_memo)
except InvalidLoop:
trace.cut_at(cut_at)
return None
loop = create_empty_loop(metainterp)
loop.original_jitcell_token = jitcell_token
loop.inputargs = loop_info.inputargs
if loop_info.quasi_immutable_deps:
loop.quasi_immutable_deps = loop_info.quasi_immutable_deps
jump_op = ops[-1]
target_token = TargetToken(jitcell_token)
target_token.original_jitcell_token = jitcell_token
label = ResOperation(rop.LABEL, loop_info.inputargs[:], descr=target_token)
jump_op.setdescr(target_token)
loop.operations = [label] + ops
if not we_are_translated():
loop.check_consistency()
jitcell_token.target_tokens = [target_token]
send_loop_to_backend(greenkey, jitdriver_sd, metainterp_sd, loop, "loop",
runtime_args, metainterp.box_names_memo)
record_loop_or_bridge(metainterp_sd, loop)
return target_token
def compile_trace(metainterp, resumekey):
"""Try to compile a new bridge leading from the beginning of the history
to some existing place.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
# The history contains new operations to attach as the code for the
# failure of 'resumekey.guard_op'.
#
# Attempt to use optimize_bridge(). This may return None in case
# it does not work -- i.e. none of the existing old_loop_tokens match.
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
if isinstance(resumekey, ResumeAtPositionDescr):
inline_short_preamble = False
else:
inline_short_preamble = True
inputargs = metainterp.history.inputargs[:]
operations = metainterp.history.operations
label = ResOperation(rop.LABEL, inputargs)
jitdriver_sd = metainterp.jitdriver_sd
enable_opts = jitdriver_sd.warmstate.enable_opts
call_pure_results = metainterp.call_pure_results
if operations[-1].getopnum() == rop.JUMP:
data = BridgeCompileData(label, operations[:],
call_pure_results=call_pure_results,
enable_opts=enable_opts,
inline_short_preamble=inline_short_preamble)
else:
data = SimpleCompileData(label, operations[:],
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
info, newops = optimize_trace(metainterp_sd, jitdriver_sd,
data, metainterp.box_names_memo)
except InvalidLoop:
#pdb.post_mortem(sys.exc_info()[2])
debug_print("compile_new_bridge: got an InvalidLoop")
# XXX I am fairly convinced that optimize_bridge cannot actually raise
# InvalidLoop
debug_print('InvalidLoop in compile_new_bridge')
return None
new_trace = create_empty_loop(metainterp)
new_trace.operations = newops
if info.quasi_immutable_deps:
new_trace.quasi_immutable_deps = info.quasi_immutable_deps
if info.final():
new_trace.inputargs = info.inputargs
target_token = new_trace.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, new_trace, inputargs)
record_loop_or_bridge(metainterp_sd, new_trace)
return target_token
new_trace.inputargs = info.renamed_inputargs
metainterp.retrace_needed(new_trace, info)
return None
def _do_optimize_loop(self,
loop,
call_pure_results,
start_state=None,
export_state=False):
from rpython.jit.metainterp.optimizeopt import optimize_trace
from rpython.jit.metainterp.optimizeopt.util import args_dict
self.loop = loop
loop.call_pure_results = args_dict()
if call_pure_results is not None:
for k, v in call_pure_results.items():
loop.call_pure_results[list(k)] = v
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, 'vrefinfo'):
metainterp_sd.virtualref_info = self.vrefinfo
if hasattr(self, 'callinfocollection'):
metainterp_sd.callinfocollection = self.callinfocollection
#
return optimize_trace(metainterp_sd,
None,
loop,
self.enable_opts,
start_state=start_state,
export_state=export_state)
def _do_optimize_loop(self, loop, call_pure_results):
from rpython.jit.metainterp.optimizeopt import optimize_trace
from rpython.jit.metainterp.optimizeopt.util import args_dict
self.loop = loop
loop.call_pure_results = args_dict()
if call_pure_results is not None:
for k, v in call_pure_results.items():
loop.call_pure_results[list(k)] = v
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, 'vrefinfo'):
metainterp_sd.virtualref_info = self.vrefinfo
if hasattr(self, 'callinfocollection'):
metainterp_sd.callinfocollection = self.callinfocollection
#
optimize_trace(metainterp_sd, loop, self.enable_opts)
def compile_trace(metainterp, resumekey, runtime_boxes):
"""Try to compile a new bridge leading from the beginning of the history
to some existging place.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
# The history contains new operations to attach as the code for the
# failure of 'resumekey.guard_op'.
#
# Attempt to use optimize_bridge(). This may return None in case
# it does not work -- i.e. none of the existing old_loop_tokens match.
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
if isinstance(resumekey, ResumeAtPositionDescr):
inline_short_preamble = False
else:
inline_short_preamble = True
inputargs = metainterp.history.inputargs[:]
trace = metainterp.history.trace
jitdriver_sd = metainterp.jitdriver_sd
enable_opts = jitdriver_sd.warmstate.enable_opts
call_pure_results = metainterp.call_pure_results
if metainterp.history.ends_with_jump:
data = BridgeCompileData(trace, runtime_boxes,
call_pure_results=call_pure_results,
enable_opts=enable_opts,
inline_short_preamble=inline_short_preamble)
else:
data = SimpleCompileData(trace,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
info, newops = optimize_trace(metainterp_sd, jitdriver_sd,
data, metainterp.box_names_memo)
except InvalidLoop:
#pdb.post_mortem(sys.exc_info()[2])
debug_print("compile_new_bridge: got an InvalidLoop")
# XXX I am fairly convinced that optimize_bridge cannot actually raise
# InvalidLoop
debug_print('InvalidLoop in compile_new_bridge')
return None
new_trace = create_empty_loop(metainterp)
new_trace.operations = newops
if info.quasi_immutable_deps:
new_trace.quasi_immutable_deps = info.quasi_immutable_deps
if info.final():
new_trace.inputargs = info.inputargs
target_token = new_trace.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, new_trace, inputargs)
record_loop_or_bridge(metainterp_sd, new_trace)
return target_token
new_trace.inputargs = info.renamed_inputargs
metainterp.retrace_needed(new_trace, info)
return None
def _do_optimize_bridge(self, bridge, call_pure_results):
from rpython.jit.metainterp.optimizeopt import optimize_trace
from rpython.jit.metainterp.optimizeopt.util import args_dict
self.bridge = bridge
bridge.call_pure_results = args_dict()
if call_pure_results is not None:
for k, v in call_pure_results.items():
bridge.call_pure_results[list(k)] = v
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, "vrefinfo"):
metainterp_sd.virtualref_info = self.vrefinfo
if hasattr(self, "callinfocollection"):
metainterp_sd.callinfocollection = self.callinfocollection
#
bridge.resume_at_jump_descr = FakeDescrWithSnapshot()
optimize_trace(metainterp_sd, bridge, self.enable_opts)
def _do_optimize_bridge(self, bridge, call_pure_results):
from rpython.jit.metainterp.optimizeopt import optimize_trace
from rpython.jit.metainterp.optimizeopt.util import args_dict
self.bridge = bridge
bridge.call_pure_results = args_dict()
if call_pure_results is not None:
for k, v in call_pure_results.items():
bridge.call_pure_results[list(k)] = v
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, 'vrefinfo'):
metainterp_sd.virtualref_info = self.vrefinfo
if hasattr(self, 'callinfocollection'):
metainterp_sd.callinfocollection = self.callinfocollection
#
bridge.resume_at_jump_descr = FakeDescrWithSnapshot()
optimize_trace(metainterp_sd, bridge, self.enable_opts)
def compile_trace(metainterp, resumekey, resume_at_jump_descr=None):
"""Try to compile a new bridge leading from the beginning of the history
to some existing place.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
# The history contains new operations to attach as the code for the
# failure of 'resumekey.guard_op'.
#
# Attempt to use optimize_bridge(). This may return None in case
# it does not work -- i.e. none of the existing old_loop_tokens match.
new_trace = create_empty_loop(metainterp)
new_trace.inputargs = metainterp.history.inputargs[:]
# clone ops, as optimize_bridge can mutate the ops
new_trace.operations = [op.clone() for op in metainterp.history.operations]
new_trace.resume_at_jump_descr = resume_at_jump_descr
metainterp_sd = metainterp.staticdata
state = metainterp.jitdriver_sd.warmstate
if isinstance(resumekey, ResumeAtPositionDescr):
inline_short_preamble = False
else:
inline_short_preamble = True
try:
optimize_trace(metainterp_sd, new_trace, state.enable_opts, inline_short_preamble)
except InvalidLoop:
debug_print("compile_new_bridge: got an InvalidLoop")
# XXX I am fairly convinced that optimize_bridge cannot actually raise
# InvalidLoop
debug_print('InvalidLoop in compile_new_bridge')
return None
if new_trace.operations[-1].getopnum() != rop.LABEL:
# We managed to create a bridge. Dispatch to resumekey to
# know exactly what we must do (ResumeGuardDescr/ResumeFromInterpDescr)
target_token = new_trace.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, new_trace)
record_loop_or_bridge(metainterp_sd, new_trace)
return target_token
else:
metainterp.retrace_needed(new_trace)
return None
def _do_optimize_loop(self, compile_data):
from rpython.jit.metainterp.optimizeopt import optimize_trace
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, 'vrefinfo'):
metainterp_sd.virtualref_info = self.vrefinfo
if hasattr(self, 'callinfocollection'):
metainterp_sd.callinfocollection = self.callinfocollection
#
compile_data.enable_opts = self.enable_opts
state = optimize_trace(metainterp_sd, None, compile_data)
return state
def _do_optimize_loop(self, compile_data):
from rpython.jit.metainterp.optimizeopt import optimize_trace
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, 'vrefinfo'):
metainterp_sd.virtualref_info = self.vrefinfo
if hasattr(self, 'callinfocollection'):
metainterp_sd.callinfocollection = self.callinfocollection
#
compile_data.enable_opts = self.enable_opts
state = optimize_trace(metainterp_sd, None, compile_data)
return state
def _do_optimize_loop(self, compile_data):
from rpython.jit.metainterp.optimizeopt import optimize_trace
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, 'vrefinfo'):
metainterp_sd.virtualref_info = self.vrefinfo
if hasattr(self, 'callinfocollection'):
metainterp_sd.callinfocollection = self.callinfocollection
compute_bitstrings(self.cpu.fetch_all_descrs())
#
compile_data.enable_opts = self.enable_opts
state = optimize_trace(metainterp_sd, None, compile_data)
state[0]._check_no_forwarding()
return state
def _do_optimize_loop(self, compile_data):
from rpython.jit.metainterp.optimizeopt import optimize_trace
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
if hasattr(self, 'vrefinfo'):
metainterp_sd.virtualref_info = self.vrefinfo
if hasattr(self, 'callinfocollection'):
metainterp_sd.callinfocollection = self.callinfocollection
compute_bitstrings(self.cpu.fetch_all_descrs())
#
compile_data.enable_opts = self.enable_opts
state = optimize_trace(metainterp_sd, None, compile_data)
state[0]._check_no_forwarding()
return state
def compile_trace(metainterp, resumekey):
"""Try to compile a new bridge leading from the beginning of the history
to some existing place.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
# The history contains new operations to attach as the code for the
# failure of 'resumekey.guard_op'.
#
# Attempt to use optimize_bridge(). This may return None in case
# it does not work -- i.e. none of the existing old_loop_tokens match.
new_trace = create_empty_loop(metainterp)
new_trace.inputargs = metainterp.history.inputargs[:]
new_trace.operations = metainterp.history.operations[:]
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
state = jitdriver_sd.warmstate
if isinstance(resumekey, ResumeAtPositionDescr):
inline_short_preamble = False
else:
inline_short_preamble = True
try:
state = optimize_trace(metainterp_sd,
jitdriver_sd,
new_trace,
state.enable_opts,
inline_short_preamble,
export_state=True)
except InvalidLoop:
debug_print("compile_new_bridge: got an InvalidLoop")
# XXX I am fairly convinced that optimize_bridge cannot actually raise
# InvalidLoop
debug_print('InvalidLoop in compile_new_bridge')
return None
if new_trace.operations[-1].getopnum() != rop.LABEL:
# We managed to create a bridge. Dispatch to resumekey to
# know exactly what we must do (ResumeGuardDescr/ResumeFromInterpDescr)
target_token = new_trace.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, new_trace)
record_loop_or_bridge(metainterp_sd, new_trace)
return target_token
else:
metainterp.retrace_needed(new_trace, state)
return None
def compile_retrace(metainterp, greenkey, start,
inputargs, jumpargs,
partial_trace, resumekey, start_state):
"""Try to compile a new procedure by closing the current history back
to the first operation.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
from rpython.jit.metainterp.optimizeopt.optimizer import BasicLoopInfo
history = metainterp.history
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
loop_jitcell_token = metainterp.get_procedure_token(greenkey)
assert loop_jitcell_token
end_label = ResOperation(rop.LABEL, inputargs[:],
descr=loop_jitcell_token)
jump_op = ResOperation(rop.JUMP, jumpargs[:], descr=loop_jitcell_token)
enable_opts = jitdriver_sd.warmstate.enable_opts
ops = history.operations[start:]
call_pure_results = metainterp.call_pure_results
loop_data = UnrolledLoopData(end_label, jump_op, ops, start_state,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
loop_data,
metainterp.box_names_memo)
except InvalidLoop:
# Fall back on jumping directly to preamble
jump_op = ResOperation(rop.JUMP, inputargs[:], descr=loop_jitcell_token)
loop_data = UnrolledLoopData(end_label, jump_op, [jump_op], start_state,
call_pure_results=call_pure_results,
enable_opts=enable_opts,
inline_short_preamble=False)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
loop_data,
metainterp.box_names_memo)
except InvalidLoop:
return None
label_token = loop_info.label_op.getdescr()
assert isinstance(label_token, TargetToken)
if label_token.short_preamble:
metainterp_sd.logger_ops.log_short_preamble([],
label_token.short_preamble, metainterp.box_names_memo)
loop = partial_trace
loop.original_jitcell_token = loop_jitcell_token
loop.operations = (loop.operations + loop_info.extra_same_as +
[loop_info.label_op]
+ loop_ops)
quasi_immutable_deps = {}
if loop_info.quasi_immutable_deps:
quasi_immutable_deps.update(loop_info.quasi_immutable_deps)
if start_state.quasi_immutable_deps:
quasi_immutable_deps.update(start_state.quasi_immutable_deps)
if quasi_immutable_deps:
loop.quasi_immutable_deps = quasi_immutable_deps
target_token = loop.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, loop, inputargs)
record_loop_or_bridge(metainterp_sd, loop)
return target_token
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']
ops = history.operations[start:]
if 'unroll' not in enable_opts or not metainterp.cpu.supports_guard_gc_type:
return compile_simple_loop(metainterp, greenkey, start, inputargs, ops,
jumpargs, enable_opts)
jitcell_token = make_jitcell_token(jitdriver_sd)
label = ResOperation(rop.LABEL, inputargs,
descr=TargetToken(jitcell_token))
end_label = ResOperation(rop.LABEL, jumpargs, descr=jitcell_token)
call_pure_results = metainterp.call_pure_results
preamble_data = LoopCompileData(label, end_label, ops,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
start_state, preamble_ops = optimize_trace(metainterp_sd, jitdriver_sd,
preamble_data,
metainterp.box_names_memo)
except InvalidLoop:
return None
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
end_label = ResOperation(rop.LABEL, inputargs,
descr=jitcell_token)
jump_op = ResOperation(rop.JUMP, jumpargs, descr=jitcell_token)
start_descr = TargetToken(jitcell_token,
original_jitcell_token=jitcell_token)
jitcell_token.target_tokens = [start_descr]
loop_data = UnrolledLoopData(end_label, jump_op, ops, start_state,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
loop_data,
metainterp.box_names_memo)
except InvalidLoop:
return None
loop = create_empty_loop(metainterp)
loop.original_jitcell_token = jitcell_token
loop.inputargs = start_state.renamed_inputargs
quasi_immutable_deps = {}
if start_state.quasi_immutable_deps:
quasi_immutable_deps.update(start_state.quasi_immutable_deps)
if loop_info.quasi_immutable_deps:
quasi_immutable_deps.update(loop_info.quasi_immutable_deps)
if quasi_immutable_deps:
loop.quasi_immutable_deps = quasi_immutable_deps
start_label = ResOperation(rop.LABEL, start_state.renamed_inputargs,
descr=start_descr)
label_token = loop_info.label_op.getdescr()
assert isinstance(label_token, TargetToken)
if label_token.short_preamble:
metainterp_sd.logger_ops.log_short_preamble([],
label_token.short_preamble, metainterp.box_names_memo)
loop.operations = ([start_label] + preamble_ops + loop_info.extra_same_as +
[loop_info.label_op] + loop_ops)
if not we_are_translated():
loop.check_consistency()
send_loop_to_backend(greenkey, jitdriver_sd, metainterp_sd, loop, "loop",
inputargs, metainterp.box_names_memo)
record_loop_or_bridge(metainterp_sd, loop)
return start_descr
def compile_retrace(metainterp, greenkey, start,
inputargs, jumpargs,
partial_trace, resumekey, start_state):
"""Try to compile a new procedure by closing the current history back
to the first operation.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
trace = metainterp.history.trace.cut_trace_from(start, inputargs)
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
history = metainterp.history
loop_jitcell_token = metainterp.get_procedure_token(greenkey)
assert loop_jitcell_token
cut = history.get_trace_position()
history.record(rop.JUMP, jumpargs[:], None, descr=loop_jitcell_token)
enable_opts = jitdriver_sd.warmstate.enable_opts
call_pure_results = metainterp.call_pure_results
loop_data = UnrolledLoopData(trace, loop_jitcell_token, start_state,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
loop_data,
metainterp.box_names_memo)
except InvalidLoop:
# Fall back on jumping directly to preamble
history.cut(cut)
history.record(rop.JUMP, jumpargs[:], None, descr=loop_jitcell_token)
loop_data = UnrolledLoopData(trace, loop_jitcell_token, start_state,
call_pure_results=call_pure_results,
enable_opts=enable_opts,
inline_short_preamble=False)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
loop_data,
metainterp.box_names_memo)
except InvalidLoop:
history.cut(cut)
return None
label_op = loop_info.label_op
if label_op is None:
assert False, "unreachable code" # hint for some strange tests
label_token = label_op.getdescr()
assert isinstance(label_token, TargetToken)
if label_token.short_preamble:
metainterp_sd.logger_ops.log_short_preamble([],
label_token.short_preamble, metainterp.box_names_memo)
loop = partial_trace
loop.original_jitcell_token = loop_jitcell_token
loop.operations = (loop.operations + loop_info.extra_same_as +
[loop_info.label_op]
+ loop_ops)
quasi_immutable_deps = {}
if loop_info.quasi_immutable_deps:
quasi_immutable_deps.update(loop_info.quasi_immutable_deps)
if start_state.quasi_immutable_deps:
quasi_immutable_deps.update(start_state.quasi_immutable_deps)
if quasi_immutable_deps:
loop.quasi_immutable_deps = quasi_immutable_deps
target_token = loop.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, loop, inputargs)
record_loop_or_bridge(metainterp_sd, loop)
return target_token
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
trace = history.trace
warmstate = jitdriver_sd.warmstate
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)
cut_at = history.get_trace_position()
history.record(rop.JUMP, jumpargs, None, descr=jitcell_token)
if start != (0, 0, 0):
trace = trace.cut_trace_from(start, inputargs)
if 'unroll' not in enable_opts or not metainterp.cpu.supports_guard_gc_type:
return compile_simple_loop(metainterp, greenkey, trace, jumpargs,
enable_opts, cut_at)
call_pure_results = metainterp.call_pure_results
preamble_data = LoopCompileData(trace, jumpargs,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
start_state, preamble_ops = optimize_trace(metainterp_sd, jitdriver_sd,
preamble_data,
metainterp.box_names_memo)
except InvalidLoop:
history.cut(cut_at)
return None
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
start_descr = TargetToken(jitcell_token,
original_jitcell_token=jitcell_token)
jitcell_token.target_tokens = [start_descr]
loop_data = UnrolledLoopData(trace, jitcell_token, start_state,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
loop_data,
metainterp.box_names_memo)
except InvalidLoop:
history.cut(cut_at)
return None
if ((warmstate.vec and jitdriver_sd.vec) or warmstate.vec_all):
from rpython.jit.metainterp.optimizeopt.vector import optimize_vector
loop_info, loop_ops = optimize_vector(trace, metainterp_sd,
jitdriver_sd, warmstate,
loop_info, loop_ops,
jitcell_token)
#
loop = create_empty_loop(metainterp)
loop.original_jitcell_token = jitcell_token
loop.inputargs = start_state.renamed_inputargs
quasi_immutable_deps = {}
if start_state.quasi_immutable_deps:
quasi_immutable_deps.update(start_state.quasi_immutable_deps)
if loop_info.quasi_immutable_deps:
quasi_immutable_deps.update(loop_info.quasi_immutable_deps)
if quasi_immutable_deps:
loop.quasi_immutable_deps = quasi_immutable_deps
start_label = ResOperation(rop.LABEL, start_state.renamed_inputargs,
descr=start_descr)
label_token = loop_info.label_op.getdescr()
assert isinstance(label_token, TargetToken)
if label_token.short_preamble:
metainterp_sd.logger_ops.log_short_preamble([],
label_token.short_preamble, metainterp.box_names_memo)
loop.operations = ([start_label] + preamble_ops + loop_info.extra_same_as +
[loop_info.label_op] + loop_ops)
if not we_are_translated():
loop.check_consistency()
send_loop_to_backend(greenkey, jitdriver_sd, metainterp_sd, loop, "loop",
inputargs, metainterp.box_names_memo)
record_loop_or_bridge(metainterp_sd, loop)
loop_info.post_loop_compilation(loop, jitdriver_sd, metainterp, jitcell_token)
return start_descr
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]
def compile_retrace(metainterp, greenkey, start, inputargs, jumpargs,
partial_trace, resumekey, start_state):
"""Try to compile a new procedure by closing the current history back
to the first operation.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
history = metainterp.history
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
loop_jitcell_token = metainterp.get_procedure_token(greenkey)
assert loop_jitcell_token
assert partial_trace.operations[-1].getopnum() == rop.LABEL
part = create_empty_loop(metainterp)
part.inputargs = inputargs[:]
h_ops = history.operations
part.operations = [partial_trace.operations[-1]] + \
h_ops[start:] + \
[ResOperation(rop.JUMP, jumpargs, None, descr=loop_jitcell_token)]
label = part.operations[0]
orignial_label = label.clone()
assert label.getopnum() == rop.LABEL
try:
optimize_trace(metainterp_sd,
jitdriver_sd,
part,
jitdriver_sd.warmstate.enable_opts,
start_state=start_state,
export_state=False)
except InvalidLoop:
# Fall back on jumping to preamble
target_token = label.getdescr()
assert isinstance(target_token, TargetToken)
part.operations = [orignial_label] + \
[ResOperation(rop.JUMP, inputargs[:],
None, descr=loop_jitcell_token)]
try:
optimize_trace(metainterp_sd,
jitdriver_sd,
part,
jitdriver_sd.warmstate.enable_opts,
inline_short_preamble=False,
start_state=start_state,
export_state=False)
except InvalidLoop:
return None
assert part.operations[-1].getopnum() != rop.LABEL
target_token = label.getdescr()
assert isinstance(target_token, TargetToken)
assert loop_jitcell_token.target_tokens
loop_jitcell_token.target_tokens.append(target_token)
if target_token.short_preamble:
metainterp_sd.logger_ops.log_short_preamble(
[], target_token.short_preamble)
loop = partial_trace
loop.operations = loop.operations[:-1] + part.operations
quasi_immutable_deps = {}
if loop.quasi_immutable_deps:
quasi_immutable_deps.update(loop.quasi_immutable_deps)
if part.quasi_immutable_deps:
quasi_immutable_deps.update(part.quasi_immutable_deps)
if quasi_immutable_deps:
loop.quasi_immutable_deps = quasi_immutable_deps
for box in loop.inputargs:
assert isinstance(box, Box)
target_token = loop.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, loop)
target_token = label.getdescr()
assert isinstance(target_token, TargetToken)
record_loop_or_bridge(metainterp_sd, loop)
return target_token
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]
def compile_retrace(metainterp, greenkey, start,
inputargs, jumpargs,
partial_trace, resumekey, start_state):
"""Try to compile a new procedure by closing the current history back
to the first operation.
"""
from rpython.jit.metainterp.optimizeopt import optimize_trace
history = metainterp.history
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
loop_jitcell_token = metainterp.get_procedure_token(greenkey)
assert loop_jitcell_token
assert partial_trace.operations[-1].getopnum() == rop.LABEL
part = create_empty_loop(metainterp)
part.inputargs = inputargs[:]
h_ops = history.operations
part.operations = [partial_trace.operations[-1]] + \
h_ops[start:] + \
[ResOperation(rop.JUMP, jumpargs, None, descr=loop_jitcell_token)]
label = part.operations[0]
orignial_label = label.clone()
assert label.getopnum() == rop.LABEL
try:
optimize_trace(metainterp_sd, jitdriver_sd, part,
jitdriver_sd.warmstate.enable_opts,
start_state=start_state, export_state=False)
except InvalidLoop:
# Fall back on jumping to preamble
target_token = label.getdescr()
assert isinstance(target_token, TargetToken)
part.operations = [orignial_label] + \
[ResOperation(rop.JUMP, inputargs[:],
None, descr=loop_jitcell_token)]
try:
optimize_trace(metainterp_sd, jitdriver_sd, part,
jitdriver_sd.warmstate.enable_opts,
inline_short_preamble=False, start_state=start_state,
export_state=False)
except InvalidLoop:
return None
assert part.operations[-1].getopnum() != rop.LABEL
target_token = label.getdescr()
assert isinstance(target_token, TargetToken)
assert loop_jitcell_token.target_tokens
loop_jitcell_token.target_tokens.append(target_token)
if target_token.short_preamble:
metainterp_sd.logger_ops.log_short_preamble([], target_token.short_preamble)
loop = partial_trace
loop.operations = loop.operations[:-1] + part.operations
quasi_immutable_deps = {}
if loop.quasi_immutable_deps:
quasi_immutable_deps.update(loop.quasi_immutable_deps)
if part.quasi_immutable_deps:
quasi_immutable_deps.update(part.quasi_immutable_deps)
if quasi_immutable_deps:
loop.quasi_immutable_deps = quasi_immutable_deps
for box in loop.inputargs:
assert isinstance(box, Box)
target_token = loop.operations[-1].getdescr()
resumekey.compile_and_attach(metainterp, loop)
target_token = label.getdescr()
assert isinstance(target_token, TargetToken)
record_loop_or_bridge(metainterp_sd, loop)
return target_token
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
trace = history.trace
warmstate = jitdriver_sd.warmstate
#
metainterp_sd.jitlog.start_new_trace(metainterp_sd,
faildescr=None, entry_bridge=False)
#
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)
cut_at = history.get_trace_position()
history.record(rop.JUMP, jumpargs, None, descr=jitcell_token)
if start != (0, 0, 0):
trace = trace.cut_trace_from(start, inputargs)
if 'unroll' not in enable_opts or not metainterp.cpu.supports_guard_gc_type:
return compile_simple_loop(metainterp, greenkey, trace, jumpargs,
enable_opts, cut_at)
call_pure_results = metainterp.call_pure_results
preamble_data = LoopCompileData(trace, jumpargs,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
start_state, preamble_ops = optimize_trace(metainterp_sd, jitdriver_sd,
preamble_data,
metainterp.box_names_memo)
except InvalidLoop:
metainterp_sd.jitlog.trace_aborted()
history.cut(cut_at)
return None
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
start_descr = TargetToken(jitcell_token,
original_jitcell_token=jitcell_token)
jitcell_token.target_tokens = [start_descr]
loop_data = UnrolledLoopData(trace, jitcell_token, start_state, jumpargs,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
try:
loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
loop_data,
metainterp.box_names_memo)
except InvalidLoop:
metainterp_sd.jitlog.trace_aborted()
history.cut(cut_at)
return None
if ((warmstate.vec and jitdriver_sd.vec) or warmstate.vec_all) and \
metainterp.cpu.vector_ext and metainterp.cpu.vector_ext.is_enabled():
from rpython.jit.metainterp.optimizeopt.vector import optimize_vector
loop_info, loop_ops = optimize_vector(trace, metainterp_sd,
jitdriver_sd, warmstate,
loop_info, loop_ops,
jitcell_token)
#
loop = create_empty_loop(metainterp)
loop.original_jitcell_token = jitcell_token
loop.inputargs = start_state.renamed_inputargs
quasi_immutable_deps = {}
if start_state.quasi_immutable_deps:
quasi_immutable_deps.update(start_state.quasi_immutable_deps)
if loop_info.quasi_immutable_deps:
quasi_immutable_deps.update(loop_info.quasi_immutable_deps)
if quasi_immutable_deps:
loop.quasi_immutable_deps = quasi_immutable_deps
start_label = ResOperation(rop.LABEL, start_state.renamed_inputargs,
descr=start_descr)
label_token = loop_info.label_op.getdescr()
assert isinstance(label_token, TargetToken)
if label_token.short_preamble:
metainterp_sd.logger_ops.log_short_preamble([],
label_token.short_preamble, metainterp.box_names_memo)
loop.operations = ([start_label] + preamble_ops + loop_info.extra_same_as +
loop_info.extra_before_label + [loop_info.label_op] + loop_ops)
if not we_are_translated():
loop.check_consistency()
send_loop_to_backend(greenkey, jitdriver_sd, metainterp_sd, loop, "loop",
inputargs, metainterp.box_names_memo)
record_loop_or_bridge(metainterp_sd, loop)
loop_info.post_loop_compilation(loop, jitdriver_sd, metainterp, jitcell_token)
return start_descr