Author: Ronan Lamy <[email protected]>
Branch: optimizeopt-cleanup
Changeset: r96463:dab1526f28a6
Date: 2019-04-13 20:19 +0100
http://bitbucket.org/pypy/pypy/changeset/dab1526f28a6/
Log: Pull use_unrolling() call out of optimize_trace()
diff --git a/rpython/jit/metainterp/compile.py
b/rpython/jit/metainterp/compile.py
--- a/rpython/jit/metainterp/compile.py
+++ b/rpython/jit/metainterp/compile.py
@@ -8,8 +8,6 @@
from rpython.rlib import rstack
from rpython.rlib.jit import JitDebugInfo, Counters, dont_look_inside
from rpython.rlib.rjitlog import rjitlog as jl
-from rpython.rlib.objectmodel import compute_unique_id
-from rpython.conftest import option
from rpython.jit.metainterp.resoperation import ResOperation, rop,\
get_deep_immutable_oplist, OpHelpers, InputArgInt, InputArgRef,\
@@ -138,6 +136,7 @@
self.call_pure_results, self.inline_short_preamble)
def show_procedures(metainterp_sd, procedure=None, error=None):
+ from rpython.conftest import option
# debugging
if option and (option.view or option.viewloops):
if error:
@@ -218,7 +217,7 @@
def compile_simple_loop(metainterp, greenkey, trace, runtime_args, enable_opts,
cut_at):
- from rpython.jit.metainterp.optimizeopt import optimize_trace
+ from rpython.jit.metainterp.optimizeopt import optimize_trace,
use_unrolling
jitdriver_sd = metainterp.jitdriver_sd
metainterp_sd = metainterp.staticdata
@@ -226,9 +225,11 @@
call_pure_results = metainterp.call_pure_results
data = SimpleCompileData(trace, call_pure_results=call_pure_results,
enable_opts=enable_opts)
+ use_unroll = use_unrolling(metainterp_sd.cpu, enable_opts)
try:
- loop_info, ops = optimize_trace(metainterp_sd, jitdriver_sd,
- data, metainterp.box_names_memo)
+ loop_info, ops = optimize_trace(
+ metainterp_sd, jitdriver_sd, data, metainterp.box_names_memo,
+ use_unrolling=use_unroll)
except InvalidLoop:
metainterp_sd.jitlog.trace_aborted()
trace.cut_at(cut_at)
@@ -257,7 +258,7 @@
"""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 import optimize_trace,
use_unrolling
metainterp_sd = metainterp.staticdata
jitdriver_sd = metainterp.jitdriver_sd
@@ -269,18 +270,20 @@
faildescr=None, entry_bridge=False)
#
enable_opts = jitdriver_sd.warmstate.enable_opts
+ use_unroll = use_unrolling(metainterp_sd.cpu, enable_opts)
if try_disabling_unroll:
- if 'unroll' not in enable_opts:
+ if not use_unroll:
return None
enable_opts = enable_opts.copy()
del enable_opts['unroll']
+ use_unroll = False
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:
+ if not use_unroll:
return compile_simple_loop(metainterp, greenkey, trace, jumpargs,
enable_opts, cut_at)
call_pure_results = metainterp.call_pure_results
@@ -288,9 +291,9 @@
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)
+ start_state, preamble_ops = optimize_trace(
+ metainterp_sd, jitdriver_sd, preamble_data,
+ metainterp.box_names_memo, use_unrolling=use_unroll)
except InvalidLoop:
metainterp_sd.jitlog.trace_aborted()
history.cut(cut_at)
@@ -305,9 +308,9 @@
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)
+ loop_info, loop_ops = optimize_trace(
+ metainterp_sd, jitdriver_sd, loop_data, metainterp.box_names_memo,
+ use_unrolling=use_unroll)
except InvalidLoop:
metainterp_sd.jitlog.trace_aborted()
history.cut(cut_at)
@@ -354,7 +357,7 @@
"""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 import optimize_trace,
use_unrolling
trace = metainterp.history.trace.cut_trace_from(start, inputargs)
metainterp_sd = metainterp.staticdata
@@ -374,10 +377,11 @@
loop_data = UnrolledLoopData(trace, loop_jitcell_token, start_state,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
+ use_unroll = use_unrolling(metainterp_sd.cpu, enable_opts)
try:
- loop_info, loop_ops = optimize_trace(metainterp_sd, jitdriver_sd,
- loop_data,
- metainterp.box_names_memo)
+ loop_info, loop_ops = optimize_trace(
+ metainterp_sd, jitdriver_sd, loop_data, metainterp.box_names_memo,
+ use_unrolling=use_unroll)
except InvalidLoop:
# Fall back on jumping directly to preamble
history.cut(cut)
@@ -387,9 +391,9 @@
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)
+ loop_info, loop_ops = optimize_trace(
+ metainterp_sd, jitdriver_sd, loop_data,
+ metainterp.box_names_memo, use_unrolling=use_unroll)
except InvalidLoop:
metainterp_sd.jitlog.trace_aborted()
history.cut(cut)
@@ -1048,7 +1052,7 @@
to some existing place.
"""
- from rpython.jit.metainterp.optimizeopt import optimize_trace
+ from rpython.jit.metainterp.optimizeopt import optimize_trace,
use_unrolling
# The history contains new operations to attach as the code for the
# failure of 'resumekey.guard_op'.
@@ -1084,13 +1088,13 @@
data = SimpleCompileData(trace, resumestorage,
call_pure_results=call_pure_results,
enable_opts=enable_opts)
+ use_unroll = use_unrolling(metainterp_sd.cpu, enable_opts)
try:
- info, newops = optimize_trace(metainterp_sd, jitdriver_sd,
- data, metainterp.box_names_memo)
+ info, newops = optimize_trace(
+ metainterp_sd, jitdriver_sd, data, metainterp.box_names_memo,
+ use_unrolling=use_unroll)
except InvalidLoop:
metainterp_sd.jitlog.trace_aborted()
- #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')
diff --git a/rpython/jit/metainterp/optimizeopt/__init__.py
b/rpython/jit/metainterp/optimizeopt/__init__.py
--- a/rpython/jit/metainterp/optimizeopt/__init__.py
+++ b/rpython/jit/metainterp/optimizeopt/__init__.py
@@ -53,7 +53,8 @@
if not is_unrolled:
metainterp_sd.logger_noopt.log_loop_from_trace(trace, memo=memo)
-def optimize_trace(metainterp_sd, jitdriver_sd, compile_data, memo=None):
+def optimize_trace(metainterp_sd, jitdriver_sd, compile_data,
+ memo=None, use_unrolling=True):
"""Optimize loop.operations to remove internal overheadish operations.
"""
debug_start("jit-optimize")
@@ -63,10 +64,9 @@
if memo is None:
memo = {}
compile_data.box_names_memo = memo
- unroll = use_unrolling(metainterp_sd.cpu, compile_data.enable_opts)
optimizations = build_opt_chain(compile_data.enable_opts)
return compile_data.optimize(metainterp_sd, jitdriver_sd,
- optimizations, unroll)
+ optimizations, unroll=use_unrolling)
finally:
compile_data.forget_optimization_info()
debug_stop("jit-optimize")
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
@@ -5,6 +5,7 @@
from rpython.rlib.rarithmetic import LONG_BIT
from rpython.rtyper import rclass
from rpython.rtyper.lltypesystem import lltype
+from rpython.jit.metainterp.optimizeopt import use_unrolling
from rpython.jit.metainterp.optimizeopt.test.test_util import (
BaseTest, FakeMetaInterpStaticData, convert_old_style_to_targets)
from rpython.jit.metainterp.history import (
@@ -33,13 +34,13 @@
expected = convert_old_style_to_targets(exp, jump=True)
call_pure_results = self._convert_call_pure_results(call_pure_results)
trace = convert_loop_to_trace(loop, FakeMetaInterpStaticData(self.cpu))
+ use_unroll = use_unrolling(self.cpu, self.enable_opts)
compile_data = compile.SimpleCompileData(
trace, call_pure_results=call_pure_results)
- info, ops = self._do_optimize_loop(compile_data)
+ info, ops = self._do_optimize_loop(compile_data, use_unroll)
label_op = ResOperation(rop.LABEL, info.inputargs)
loop.inputargs = info.inputargs
loop.operations = [label_op] + ops
- #print '\n'.join([str(o) for o in loop.operations])
self.loop = loop
self.assert_equal(loop, expected)
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_optimizebridge.py
b/rpython/jit/metainterp/optimizeopt/test/test_optimizebridge.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_optimizebridge.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_optimizebridge.py
@@ -1,3 +1,4 @@
+from rpython.jit.metainterp.optimizeopt import use_unrolling
from rpython.jit.metainterp.optimizeopt.test.test_util import (
BaseTest, convert_old_style_to_targets, FakeMetaInterpStaticData)
from rpython.jit.metainterp import compile
@@ -29,12 +30,13 @@
self.add_guard_future_condition(bridge)
trace = oparser.convert_loop_to_trace(
bridge, FakeMetaInterpStaticData(self.cpu))
+ use_unroll = use_unrolling(self.cpu, self.enable_opts)
data = compile.BridgeCompileData(
trace,
self.convert_values(bridge.operations[-1].getarglist(),
bridge_values),
None, enable_opts=self.enable_opts,
inline_short_preamble=inline_short_preamble)
- bridge_info, ops = self._do_optimize_loop(data)
+ bridge_info, ops = self._do_optimize_loop(data, use_unroll)
loop.check_consistency(check_descr=False)
info.preamble.check_consistency(check_descr=False)
bridge.operations = ([ResOperation(rop.LABEL, bridge_info.inputargs)] +
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_unroll.py
b/rpython/jit/metainterp/optimizeopt/test/test_unroll.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_unroll.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_unroll.py
@@ -5,7 +5,7 @@
from rpython.jit.metainterp.optimizeopt.test.test_util import (
BaseTest, FakeMetaInterpStaticData)
from rpython.jit.metainterp.optimizeopt.util import equaloplists
-from rpython.jit.metainterp.history import TreeLoop, JitCellToken
+from rpython.jit.metainterp.history import TreeLoop
from rpython.jit.metainterp.resoperation import (
rop, ResOperation, InputArgRef, InputArgInt)
from rpython.jit.metainterp.support import ptr2int
@@ -16,6 +16,7 @@
NotVirtualStateInfo, LEVEL_CONSTANT, LEVEL_UNKNOWN, LEVEL_KNOWNCLASS,
VirtualStateInfo)
from rpython.jit.metainterp.optimizeopt import info, optimizer
+from rpython.jit.metainterp.optimizeopt import use_unrolling
from rpython.jit.tool import oparser
class FakeOptimizer(object):
@@ -40,20 +41,15 @@
def optimize(self, ops):
loop = self.parse(ops)
self.add_guard_future_condition(loop)
- operations = loop.operations
+ operations = loop.operations
jumpop = operations[-1]
assert jumpop.getopnum() == rop.JUMP
inputargs = loop.inputargs
-
- jump_args = jumpop.getarglist()[:]
- operations = operations[:-1]
-
preamble = TreeLoop('preamble')
-
- token = JitCellToken()
trace = oparser.convert_loop_to_trace(loop,
FakeMetaInterpStaticData(self.cpu))
+ use_unroll = use_unrolling(self.cpu, self.enable_opts)
compile_data = LoopCompileData(trace, inputargs)
- start_state, newops = self._do_optimize_loop(compile_data)
+ start_state, newops = self._do_optimize_loop(compile_data, use_unroll)
preamble.operations = newops
preamble.inputargs = start_state.renamed_inputargs
return start_state, loop, preamble
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_util.py
b/rpython/jit/metainterp/optimizeopt/test/test_util.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_util.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_util.py
@@ -23,7 +23,7 @@
from rpython.jit.metainterp.resoperation import (
rop, ResOperation, InputArgRef, AbstractValue)
from rpython.jit.metainterp.virtualref import VirtualRefInfo
-from rpython.jit.metainterp.optimizeopt import optimize_trace
+from rpython.jit.metainterp.optimizeopt import optimize_trace, use_unrolling
from rpython.jit.metainterp.optimizeopt.util import (
sort_descrs, equaloplists, args_dict)
@@ -538,17 +538,17 @@
assert equaloplists(optimized.operations,
expected.operations, False, remap, text_right)
- def _do_optimize_loop(self, compile_data):
+ def _do_optimize_loop(self, compile_data, use_unroll):
metainterp_sd = FakeMetaInterpStaticData(self.cpu)
metainterp_sd.virtualref_info = self.vrefinfo
compute_bitstrings(self.cpu.fetch_all_descrs())
#
compile_data.enable_opts = self.enable_opts
- state = optimize_trace(metainterp_sd, None, compile_data)
+ state = optimize_trace(
+ metainterp_sd, None, compile_data, use_unrolling=use_unroll)
return state
def _convert_call_pure_results(self, d):
-
if d is None:
return
call_pure_results = args_dict()
@@ -581,18 +581,16 @@
celltoken = JitCellToken()
runtime_boxes = self.pack_into_boxes(jump_op, jump_values)
jump_op.setdescr(celltoken)
- #start_label = ResOperation(rop.LABEL, loop.inputargs,
- # descr=jump_op.getdescr())
- #end_label = jump_op.copy_and_change(opnum=rop.LABEL)
call_pure_results = self._convert_call_pure_results(call_pure_results)
t = convert_loop_to_trace(loop, FakeMetaInterpStaticData(self.cpu))
+ use_unroll = use_unrolling(self.cpu, self.enable_opts)
preamble_data = compile.LoopCompileData(t, runtime_boxes,
call_pure_results)
- start_state, preamble_ops = self._do_optimize_loop(preamble_data)
+ start_state, preamble_ops = self._do_optimize_loop(preamble_data,
use_unroll)
preamble_data.forget_optimization_info()
loop_data = compile.UnrolledLoopData(preamble_data.trace,
celltoken, start_state, call_pure_results)
- loop_info, ops = self._do_optimize_loop(loop_data)
+ loop_info, ops = self._do_optimize_loop(loop_data, use_unroll)
preamble = TreeLoop('preamble')
preamble.inputargs = start_state.renamed_inputargs
start_label = ResOperation(rop.LABEL, start_state.renamed_inputargs)
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
b/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_virtualstate.py
@@ -853,7 +853,7 @@
enable_opts =
"intbounds:rewrite:virtualize:string:pure:earlyforce:heap:unroll"
def _do_optimize_bridge(self, bridge, call_pure_results, values):
- from rpython.jit.metainterp.optimizeopt import optimize_trace
+ from rpython.jit.metainterp.optimizeopt import optimize_trace,
use_unrolling
from rpython.jit.metainterp.optimizeopt.util import args_dict
self.bridge = bridge
@@ -871,7 +871,9 @@
data = compile.BridgeCompileData(trace, runtime_boxes,
enable_opts=self.enable_opts, inline_short_preamble=True)
- info, newops = optimize_trace(metainterp_sd, None, data)
+ use_unroll = use_unrolling(self.cpu, self.enable_opts)
+ info, newops = optimize_trace(metainterp_sd, None, data,
+ use_unrolling=use_unroll)
if info.final():
bridge.operations = newops
bridge.inputargs = info.inputargs
diff --git a/rpython/jit/metainterp/test/test_ajit.py
b/rpython/jit/metainterp/test/test_ajit.py
--- a/rpython/jit/metainterp/test/test_ajit.py
+++ b/rpython/jit/metainterp/test/test_ajit.py
@@ -2901,6 +2901,8 @@
optimizeopt.optimize_trace = old_optimize_trace
def test_max_unroll_loops_retry_without_unroll(self):
+ if not self.basic:
+ py.test.skip("unrolling")
from rpython.jit.metainterp.optimize import InvalidLoop
from rpython.jit.metainterp import optimizeopt
myjitdriver = JitDriver(greens = [], reds = ['n', 'i'])
@@ -2916,14 +2918,14 @@
return i
#
seen = []
- def my_optimize_trace(metainterp_sd, jitdriver_sd, data, memo=None):
- seen.append('unroll' in data.enable_opts)
+ def my_optimize_trace(metainterp_sd, jitdriver_sd, data, memo=None,
+ use_unrolling=True):
+ assert use_unrolling == ('unroll' in data.enable_opts)
+ seen.append(use_unrolling)
raise InvalidLoop
old_optimize_trace = optimizeopt.optimize_trace
optimizeopt.optimize_trace = my_optimize_trace
try:
- if not self.basic:
- py.test.skip("unrolling")
res = self.meta_interp(f, [23, 4])
assert res == 23
assert False in seen
_______________________________________________
pypy-commit mailing list
[email protected]
https://mail.python.org/mailman/listinfo/pypy-commit
