def set_abort_hook(space, w_hook):
""" set_abort_hook(hook)
Set a hook (callable) that will be called each time there is tracing
aborted due to some reason.
The hook will be called with the signature:
hook(jitdriver_name, greenkey, reason, operations)
Reason is a string, the meaning of other arguments is the same
as attributes on JitLoopInfo object.
"""
cache = space.fromcache(Cache)
if space.is_w(w_hook, space.w_None):
w_hook = None
cache.w_abort_hook = w_hook
cache.in_recursion = NonConstant(False)
def main(argv=[]):
rthread.get_ident() # force TLOFS_thread_ident
if NonConstant(False):
# Hack to give os.open() the correct annotation
os.open('foo', 1, 1)
code1 = MyCode(6500)
fd = os.open(PROF_FILE, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0666)
rvmprof.enable(fd, 0.01)
#
code2 = MyCode(9100)
stop = time.time() + 1
while time.time() < stop:
interpret(code1)
interpret(code2)
#
rvmprof.disable()
os.close(fd)
return 0
def set_compile_hook(space, w_hook, operations=True):
""" set_compile_hook(hook, operations=True)
Set a compiling hook that will be called each time a loop is compiled.
The hook will be called with the pypyjit.JitLoopInfo object. Refer to it's
docstring for details.
Note that jit hook is not reentrant. It means that if the code
inside the jit hook is itself jitted, it will get compiled, but the
jit hook won't be called for that.
"""
cache = space.fromcache(Cache)
if space.is_w(w_hook, space.w_None):
w_hook = None
cache.w_compile_hook = w_hook
cache.compile_hook_with_ops = operations
cache.in_recursion = NonConstant(False)
def f():
if NonConstant(False):
# Hack to give os.open() the correct annotation
os.open('foo', 1, 1)
code = MyCode()
rvmprof.register_code(code, get_name)
fd = os.open(tmpfilename, os.O_WRONLY | os.O_CREAT, 0666)
if we_are_translated():
num = 100000000
period = 0.0001
else:
num = 10000
period = 0.9
rvmprof.enable(fd, period)
res = main(code, num)
#assert res == 499999500000
rvmprof.disable()
os.close(fd)
return 0
def walk_stack_from(self):
curframe = lltype.malloc(WALKFRAME, flavor='raw')
otherframe = lltype.malloc(WALKFRAME, flavor='raw')
# Walk over all the pieces of stack. They are in a circular linked
# list of structures of 7 words, the 2 first words being prev/next.
# The anchor of this linked list is:
anchor = llmemory.cast_ptr_to_adr(gcrootanchor)
initialframedata = anchor.address[1]
stackscount = 0
while initialframedata != anchor: # while we have not looped back
self.walk_frames(curframe, otherframe, initialframedata)
# Then proceed to the next piece of stack
initialframedata = initialframedata.address[1]
stackscount += 1
#
# for the JIT: rpy_fastgil may contain an extra framedata
rpy_fastgil = rgil.gil_fetch_fastgil().signed[0]
if rpy_fastgil != 1:
ll_assert(rpy_fastgil != 0, "walk_stack_from doesn't have the GIL")
initialframedata = rffi.cast(llmemory.Address, rpy_fastgil)
#
# very rare issue: initialframedata.address[0] is uninitialized
# in this case, but "retaddr = callee.frame_address.address[0]"
# reads it. If it happens to be exactly a valid return address
# inside the C code, then bad things occur.
initialframedata.address[0] = llmemory.NULL
#
self.walk_frames(curframe, otherframe, initialframedata)
stackscount += 1
#
expected = rffi.stackcounter.stacks_counter
if NonConstant(0):
rffi.stackcounter.stacks_counter += 42 # hack to force it
ll_assert(not (stackscount < expected), "non-closed stacks around")
ll_assert(not (stackscount > expected), "stacks counter corruption?")
lltype.free(otherframe, flavor='raw')
lltype.free(curframe, flavor='raw')
def actual_entry(argv):
jit.set_param(None, "trace_limit", 1000000)
jit.set_param(None, "threshold", 131)
jit.set_param(None, "trace_eagerness", 50)
if NonConstant(False):
# Hack to give os.open() the correct annotation
os.open('foo', 1, 1)
config, names, args, retval = parse_args(argv)
if retval != 0 or config is None:
return retval
args_w = [W_String.fromstr_utf8(arg) for arg in args]
module_name, json_ast = ensure_json_ast(config, names)
modtable = ModTable()
modtable.enter_module(module_name)
if json_ast is None:
ast = expand_to_ast(module_name, modtable)
else:
ast = load_json_ast_rpython(json_ast, modtable)
modtable.exit_module(module_name, ast)
env = ToplevelEnv(pycketconfig)
env.globalconfig.load(ast)
env.commandline_arguments = args_w
env.module_env.add_module(module_name, ast)
try:
val = interpret_module(ast, env)
finally:
from pycket.prims.input_output import shutdown
if config.get('save-callgraph', False):
with open('callgraph.dot', 'w') as outfile:
env.callgraph.write_dot_file(outfile)
shutdown(env)
return 0
def fn():
return bool(NonConstant(False))
def nonconst_l():
a = NonConstant([1, 2, 3])
return a[0]
def current_trace_length():
"""During JIT tracing, returns the current trace length (as a constant).
If not tracing, returns -1."""
if NonConstant(False):
return 73
return -1
def w_obj_or_none():
if NonConstant(False):
return None
return w_some_obj()
def bigint_w(self, space, allow_conversion=True):
from rpython.rlib.rbigint import rbigint
x = 42
if we_are_translated():
x = NonConstant(x)
return rbigint.fromint(x)
def int_w(self, space, allow_conversion=True):
return NonConstant(-42)
def len_w(self, w_obj):
return NonConstant(37)
def hash_w(self, w_obj):
return NonConstant(32)
def is_true(self, w_obj):
is_root(w_obj)
return NonConstant(False)
def str_w(self, space):
return NonConstant("foobar")
def utf8_w(self, space):
return NonConstant("foobar")
def utf8_len_w(self, space):
return NonConstant((NonConstant("utf8len_foobar"), NonConstant(14)))
def uint_w(self, space):
return r_uint(NonConstant(42))
def check():
scope_w = [w_some_obj()] * NonConstant(42)
w_result = activation._run(self, scope_w)
is_root(w_result)
def w_some_obj():
if NonConstant(False):
return W_Root()
return W_MyObject()
def setdictvalue(self, space, attr, w_value):
attr + "xx" # check that it's a string
is_root(w_value)
return NonConstant(True)
def issubtype_w(self, w_sub, w_type):
is_root(w_type)
return NonConstant(True)
def isinstance_w(self, w_inst, w_type):
is_root(w_inst)
is_root(w_type)
return NonConstant(True)
def nonconst_f():
a = NonConstant(3)
return a
def decode_index4(self, w_index_or_slice, seqlength):
is_root(w_index_or_slice)
return (NonConstant(42), NonConstant(42),
NonConstant(42), NonConstant(42))
def nonconst_i():
return NonConstant(a)
def deldictvalue(self, space, attr):
attr + "xx" # check that it's a string
return NonConstant(True)
def fn(x):
return NonConstant(x)
def is_generator(self, w_obj):
return NonConstant(False)
