Author: Maciej Fijalkowski <fij...@gmail.com>
Branch: better-jit-hooks
Changeset: r51180:aed03c7eb163
Date: 2012-01-09 23:06 +0200
http://bitbucket.org/pypy/pypy/changeset/aed03c7eb163/
Log: update the interface on the pypyjit side
diff --git a/pypy/jit/metainterp/pyjitpl.py b/pypy/jit/metainterp/pyjitpl.py
--- a/pypy/jit/metainterp/pyjitpl.py
+++ b/pypy/jit/metainterp/pyjitpl.py
@@ -1796,7 +1796,7 @@
jd_sd = self.jitdriver_sd
greenkey = self.current_merge_points[0][0][:jd_sd.num_green_args]
self.staticdata.warmrunnerdesc.hooks.on_abort(reason, jd_sd.jitdriver,
- greenkey)
+ greenkey,
jd_sd.warmstate.get_location_str(greenkey))
self.staticdata.stats.aborted()
def blackhole_if_trace_too_long(self):
diff --git a/pypy/jit/metainterp/test/test_jitiface.py
b/pypy/jit/metainterp/test/test_jitiface.py
--- a/pypy/jit/metainterp/test/test_jitiface.py
+++ b/pypy/jit/metainterp/test/test_jitiface.py
@@ -12,14 +12,16 @@
reasons = []
class MyJitIface(JitHookInterface):
- def on_abort(self, reason, jitdriver, greenkey):
+ def on_abort(self, reason, jitdriver, greenkey, greenkey_repr):
assert jitdriver is myjitdriver
assert len(greenkey) == 1
reasons.append(reason)
+ assert greenkey_repr == 'blah'
iface = MyJitIface()
- myjitdriver = JitDriver(greens=['foo'], reds=['x', 'total'])
+ myjitdriver = JitDriver(greens=['foo'], reds=['x', 'total'],
+ get_printable_location=lambda *args: 'blah')
class Foo:
_immutable_fields_ = ['a?']
diff --git a/pypy/module/pypyjit/interp_resop.py
b/pypy/module/pypyjit/interp_resop.py
--- a/pypy/module/pypyjit/interp_resop.py
+++ b/pypy/module/pypyjit/interp_resop.py
@@ -19,8 +19,9 @@
self.w_abort_hook = space.w_None
self.w_optimize_hook = space.w_None
-def wrap_greenkey(space, jitdriver, greenkey):
- if jitdriver.name == 'pypyjit':
+def wrap_greenkey(space, jitdriver, greenkey, greenkey_repr):
+ jitdriver_name = jitdriver.name
+ if jitdriver_name == 'pypyjit':
next_instr = greenkey[0].getint()
is_being_profiled = greenkey[1].getint()
ll_code = lltype.cast_opaque_ptr(lltype.Ptr(OBJECT),
@@ -29,7 +30,7 @@
return space.newtuple([space.wrap(pycode), space.wrap(next_instr),
space.newbool(bool(is_being_profiled))])
else:
- return space.wrap('who knows?')
+ return space.wrap(greenkey_repr)
def set_compile_hook(space, w_hook):
""" set_compile_hook(hook)
@@ -106,7 +107,7 @@
cache.w_abort_hook = w_hook
cache.in_recursion = NonConstant(False)
-def wrap_oplist(space, logops, operations, ops_offset):
+def wrap_oplist(space, logops, operations, ops_offset=None):
l_w = []
for op in operations:
if ops_offset is None:
diff --git a/pypy/module/pypyjit/policy.py b/pypy/module/pypyjit/policy.py
--- a/pypy/module/pypyjit/policy.py
+++ b/pypy/module/pypyjit/policy.py
@@ -7,7 +7,7 @@
WrappedOp
class PyPyJitIface(JitHookInterface):
- def on_abort(self, reason, jitdriver, greenkey):
+ def on_abort(self, reason, jitdriver, greenkey, greenkey_repr):
space = self.space
cache = space.fromcache(Cache)
if cache.in_recursion:
@@ -18,73 +18,75 @@
try:
space.call_function(cache.w_abort_hook,
space.wrap(jitdriver.name),
- wrap_greenkey(space, jitdriver,
greenkey),
+ wrap_greenkey(space, jitdriver,
+ greenkey, greenkey_repr),
space.wrap(counter_names[reason]))
except OperationError, e:
e.write_unraisable(space, "jit hook ", cache.w_abort_hook)
finally:
cache.in_recursion = False
- def after_compile(self, jitdriver, logger, looptoken, operations, type,
- greenkey, ops_offset, asmstart, asmlen):
- self._compile_hook(jitdriver, logger, operations, type,
- ops_offset, asmstart, asmlen,
- wrap_greenkey(self.space, jitdriver, greenkey))
+ def after_compile(self, debug_info):
+ w_greenkey = wrap_greenkey(self.space, debug_info.get_jitdriver(),
+ debug_info.greenkey,
+ debug_info.get_greenkey_repr())
+ self._compile_hook(debug_info, w_greenkey)
- def after_compile_bridge(self, jitdriver, logger, orig_looptoken,
- operations, n, ops_offset, asmstart, asmlen):
- self._compile_hook(jitdriver, logger, operations, 'bridge',
- ops_offset, asmstart, asmlen,
- self.space.wrap(n))
+ def after_compile_bridge(self, debug_info):
+ self._compile_hook(debug_info,
+ self.space.wrap(debug_info.fail_descr_no))
- def before_compile(self, jitdriver, logger, looptoken, operations, type,
- greenkey):
- self._optimize_hook(jitdriver, logger, operations, type,
- wrap_greenkey(self.space, jitdriver, greenkey))
+ def before_compile(self, debug_info):
+ w_greenkey = wrap_greenkey(self.space, debug_info.get_jitdriver(),
+ debug_info.greenkey,
+ debug_info.get_greenkey_repr())
+ self._optimize_hook(debug_info, w_greenkey)
- def before_compile_bridge(self, jitdriver, logger, orig_looptoken,
- operations, n):
- self._optimize_hook(jitdriver, logger, operations, 'bridge',
- self.space.wrap(n))
+ def before_compile_bridge(self, debug_info):
+ self._optimize_hook(debug_info,
+ self.space.wrap(debug_info.fail_descr_no))
- def _compile_hook(self, jitdriver, logger, operations, type,
- ops_offset, asmstart, asmlen, w_arg):
+ def _compile_hook(self, debug_info, w_arg):
space = self.space
cache = space.fromcache(Cache)
if cache.in_recursion:
return
if space.is_true(cache.w_compile_hook):
- logops = logger._make_log_operations()
- list_w = wrap_oplist(space, logops, operations, ops_offset)
+ logops = debug_info.logger._make_log_operations()
+ list_w = wrap_oplist(space, logops, debug_info.operations,
+ debug_info.asminfo.ops_offset)
cache.in_recursion = True
try:
try:
+ jd_name = debug_info.get_jitdriver().name
+ asminfo = debug_info.asminfo
space.call_function(cache.w_compile_hook,
- space.wrap(jitdriver.name),
- space.wrap(type),
+ space.wrap(jd_name),
+ space.wrap(debug_info.type),
w_arg,
space.newlist(list_w),
- space.wrap(asmstart),
- space.wrap(asmlen))
+ space.wrap(asminfo.asmaddr),
+ space.wrap(asminfo.asmlen))
except OperationError, e:
e.write_unraisable(space, "jit hook ",
cache.w_compile_hook)
finally:
cache.in_recursion = False
- def _optimize_hook(self, jitdriver, logger, operations, type, w_arg):
+ def _optimize_hook(self, debug_info, w_arg):
space = self.space
cache = space.fromcache(Cache)
if cache.in_recursion:
return
if space.is_true(cache.w_optimize_hook):
- logops = logger._make_log_operations()
- list_w = wrap_oplist(space, logops, operations, {})
+ logops = debug_info.logger._make_log_operations()
+ list_w = wrap_oplist(space, logops, debug_info.operations)
cache.in_recursion = True
try:
try:
+ jd_name = debug_info.get_jitdriver().name
w_res = space.call_function(cache.w_optimize_hook,
- space.wrap(jitdriver.name),
- space.wrap(type),
+ space.wrap(jd_name),
+ space.wrap(debug_info.type),
w_arg,
space.newlist(list_w))
if space.is_w(w_res, space.w_None):
@@ -93,12 +95,12 @@
for w_item in space.listview(w_res):
item = space.interp_w(WrappedOp, w_item)
l.append(jit_hooks._cast_to_resop(item.op))
- del operations[:] # modifying operations above is
+ del debug_info.operations[:] # modifying operations above
is
# probably not a great idea since types may not work
# and we'll end up with half-working list and
# a segfault/fatal RPython error
for elem in l:
- operations.append(elem)
+ debug_info.operations.append(elem)
except OperationError, e:
e.write_unraisable(space, "jit hook ",
cache.w_compile_hook)
finally:
diff --git a/pypy/module/pypyjit/test/test_jit_hook.py
b/pypy/module/pypyjit/test/test_jit_hook.py
--- a/pypy/module/pypyjit/test/test_jit_hook.py
+++ b/pypy/module/pypyjit/test/test_jit_hook.py
@@ -15,6 +15,7 @@
from pypy.jit.tool.oparser import parse
from pypy.jit.metainterp.typesystem import llhelper
from pypy.jit.metainterp.jitprof import ABORT_TOO_LONG
+from pypy.rlib.jit import JitDebugInfo, AsmInfo
class MockJitDriverSD(object):
class warmstate(object):
@@ -25,6 +26,9 @@
pycode = cast_base_ptr_to_instance(PyCode, ll_code)
return pycode.co_name
+ jitdriver = pypyjitdriver
+
+
class MockSD(object):
class cpu(object):
ts = llhelper
@@ -47,7 +51,7 @@
code_gcref = lltype.cast_opaque_ptr(llmemory.GCREF, ll_code)
logger = Logger(MockSD())
- cls.origoplist = parse("""
+ oplist = parse("""
[i1, i2, p2]
i3 = int_add(i1, i2)
debug_merge_point(0, 0, 0, 0, ConstPtr(ptr0))
@@ -56,35 +60,43 @@
""", namespace={'ptr0': code_gcref}).operations
greenkey = [ConstInt(0), ConstInt(0), ConstPtr(code_gcref)]
offset = {}
- for i, op in enumerate(cls.origoplist):
+ for i, op in enumerate(oplist):
if i != 1:
offset[op] = i
+ di_loop = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(),
+ oplist, 'loop', greenkey)
+ di_loop_optimize = JitDebugInfo(MockJitDriverSD, logger,
JitCellToken(),
+ oplist, 'loop', greenkey)
+ di_loop.asminfo = AsmInfo(offset, 0, 0)
+ di_bridge = JitDebugInfo(MockJitDriverSD, logger, JitCellToken(),
+ oplist, 'bridge', fail_descr_no=0)
+ di_bridge.asminfo = AsmInfo(offset, 0, 0)
+
def interp_on_compile():
- pypy_hooks.after_compile(pypyjitdriver, logger, JitCellToken(),
- cls.oplist, 'loop', greenkey, offset,
- 0, 0)
+ di_loop.oplist = cls.oplist
+ pypy_hooks.after_compile(di_loop)
def interp_on_compile_bridge():
- pypy_hooks.after_compile_bridge(pypyjitdriver, logger,
- JitCellToken(), cls.oplist, 0,
- offset, 0, 0)
+ pypy_hooks.after_compile_bridge(di_bridge)
def interp_on_optimize():
- pypy_hooks.before_compile(pypyjitdriver, logger, JitCellToken(),
- cls.oplist, 'loop', greenkey)
+ di_loop_optimize.oplist = cls.oplist
+ pypy_hooks.before_compile(di_loop_optimize)
def interp_on_abort():
- pypy_hooks.on_abort(ABORT_TOO_LONG, pypyjitdriver, greenkey)
+ pypy_hooks.on_abort(ABORT_TOO_LONG, pypyjitdriver, greenkey,
+ 'blah')
cls.w_on_compile = space.wrap(interp2app(interp_on_compile))
cls.w_on_compile_bridge =
space.wrap(interp2app(interp_on_compile_bridge))
cls.w_on_abort = space.wrap(interp2app(interp_on_abort))
cls.w_int_add_num = space.wrap(rop.INT_ADD)
cls.w_on_optimize = space.wrap(interp2app(interp_on_optimize))
+ cls.orig_oplist = oplist
def setup_method(self, meth):
- self.__class__.oplist = self.origoplist
+ self.__class__.oplist = self.orig_oplist[:]
def test_on_compile(self):
import pypyjit
diff --git a/pypy/rlib/jit.py b/pypy/rlib/jit.py
--- a/pypy/rlib/jit.py
+++ b/pypy/rlib/jit.py
@@ -779,7 +779,7 @@
of JIT running like JIT loops compiled, aborts etc.
An instance of this class will be available as policy.jithookiface.
"""
- def on_abort(self, reason, jitdriver, greenkey):
+ def on_abort(self, reason, jitdriver, greenkey, greenkey_repr):
""" A hook called each time a loop is aborted with jitdriver and
greenkey where it started, reason is a string why it got aborted
"""
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
http://mail.python.org/mailman/listinfo/pypy-commit
