def test_vmprof_execute_code_2():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported:
pass
class A:
pass
@rvmprof.vmprof_execute_code("xcode2", lambda num, code: code,
result_class=A)
def main(num, code):
print num
return A()
def f():
a = main(7, MyCode())
assert isinstance(a, A)
return 0
assert f() == 0
fn = compile(f, [])
assert fn() == 0
def test_compiled():
class MyCode:
pass
def get_name(mycode):
raise NotImplementedError
rvmprof.register_code_object_class(MyCode, get_name)
@rvmprof.vmprof_execute_code("mycode", lambda code, level: code)
def mainloop(code, level):
if level > 0:
mainloop(code, level - 1)
else:
p, length = traceback.traceback(20)
traceback.walk_traceback(MyCode, my_callback, 42, p, length)
lltype.free(p, flavor='raw')
def my_callback(code, loc, arg):
print code, loc, arg
return 0
def f(argv):
code1 = MyCode()
rvmprof.register_code(code1, "foo")
mainloop(code1, 2)
return 0
t = Translation(f, None, gc="boehm")
t.compile_c()
stdout = t.driver.cbuilder.cmdexec('')
r = re.compile("[<]MyCode object at 0x([0-9a-f]+)[>] 0 42\n")
got = r.findall(stdout)
assert got == [got[0]] * 3
def test_direct():
class MyCode:
pass
def get_name(mycode):
raise NotImplementedError
rvmprof.register_code_object_class(MyCode, get_name)
#
@rvmprof.vmprof_execute_code("mycode", lambda code, level: code, _hack_update_stack_untranslated=True)
def mainloop(code, level):
if level > 0:
mainloop(code, level - 1)
else:
p, length = traceback.traceback(20)
traceback.walk_traceback(MyCode, my_callback, 42, p, length)
lltype.free(p, flavor="raw")
#
seen = []
def my_callback(code, loc, arg):
seen.append((code, loc, arg))
#
code1 = MyCode()
rvmprof.register_code(code1, "foo")
mainloop(code1, 2)
#
assert seen == [
(code1, traceback.LOC_INTERPRETED, 42),
(code1, traceback.LOC_INTERPRETED, 42),
(code1, traceback.LOC_INTERPRETED, 42),
]
def test_direct():
class MyCode:
pass
def get_name(mycode):
raise NotImplementedError
rvmprof.register_code_object_class(MyCode, get_name)
#
@rvmprof.vmprof_execute_code("mycode",
lambda code, level: code,
_hack_update_stack_untranslated=True)
def mainloop(code, level):
if level > 0:
mainloop(code, level - 1)
else:
p, length = traceback.traceback(20)
traceback.walk_traceback(MyCode, my_callback, 42, p, length)
lltype.free(p, flavor='raw')
#
seen = []
def my_callback(code, loc, arg):
seen.append((code, loc, arg))
#
code1 = MyCode()
rvmprof.register_code(code1, "foo")
mainloop(code1, 2)
#
assert seen == [(code1, traceback.LOC_INTERPRETED, 42),
(code1, traceback.LOC_INTERPRETED, 42),
(code1, traceback.LOC_INTERPRETED, 42)]
def setup_method(self, meth):
visited = []
def helper():
trace = []
stack = cintf.vmprof_tl_stack.getraw()
while stack:
trace.append((stack.c_kind, stack.c_value))
stack = stack.c_next
visited.append(trace)
llfn = llhelper(lltype.Ptr(lltype.FuncType([], lltype.Void)), helper)
class CodeObj(object):
def __init__(self, name):
self.name = name
def get_code_fn(codes, code, arg, c):
return code
def get_name(code):
return "foo"
_get_vmprof().use_weaklist = False
register_code_object_class(CodeObj, get_name)
self.misc = visited, llfn, CodeObj, get_code_fn, get_name
def deco(f):
# Prepare the full location name.
lineNo = inspect.getsourcelines(f)[1]
moduleName = os.path.basename(inspect.getsourcefile(f))
fullLocation = "ty:%s:%d:%s" % (name, lineNo, moduleName)
# Produce the code object class.
class FakeCodeObj(object):
fullName = fullLocation
rvmprof.register_code_object_class(FakeCodeObj,
lambda obj: obj.fullName)
# Prebuild one in order to have something to return.
codeObj = FakeCodeObj()
def get_code_fn(*args):
return codeObj
# And register it at runtime.
def switch():
rvmprof.register_code(codeObj, lambda obj: obj.fullName)
profiledLocations.append(switch)
@rvmprof.vmprof_execute_code(name, get_code_fn)
def fakeExecuteCode(*args):
return f(*args)
return fakeExecuteCode
def deco(f):
# Prepare the full location name.
lineNo = inspect.getsourcelines(f)[1]
moduleName = os.path.basename(inspect.getsourcefile(f))
fullLocation = "ty:%s:%d:%s" % (name, lineNo, moduleName)
# Produce the code object class.
class FakeCodeObj(object):
fullName = fullLocation
rvmprof.register_code_object_class(FakeCodeObj,
lambda obj: obj.fullName)
# Prebuild one in order to have something to return.
codeObj = FakeCodeObj()
def get_code_fn(*args):
return codeObj
# And register it at runtime.
def switch():
rvmprof.register_code(codeObj, lambda obj: obj.fullName)
profiledLocations.append(switch)
@wraps(f)
@rvmprof.vmprof_execute_code(name, get_code_fn)
def fakeExecuteCode(*args):
return f(*args)
return fakeExecuteCode
def setup_method(self, meth):
visited = []
def helper():
trace = []
stack = cintf.vmprof_tl_stack.getraw()
while stack:
trace.append((stack.c_kind, stack.c_value))
stack = stack.c_next
visited.append(trace)
llfn = llhelper(lltype.Ptr(lltype.FuncType([], lltype.Void)), helper)
class CodeObj(object):
def __init__(self, name):
self.name = name
def get_code_fn(codes, code, arg, c):
return code
def get_name(code):
return "foo"
_get_vmprof().use_weaklist = False
register_code_object_class(CodeObj, get_name)
self.misc = visited, llfn, CodeObj, get_code_fn, get_name
def test_vmprof_execute_code_2():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported:
pass
class A:
pass
@rvmprof.vmprof_execute_code("xcode2",
lambda num, code: code,
result_class=A)
def main(num, code):
print num
return A()
def f():
a = main(7, MyCode())
assert isinstance(a, A)
return 0
assert f() == 0
fn = compile(f, [])
assert fn() == 0
def test_compiled():
class MyCode:
pass
def get_name(mycode):
raise NotImplementedError
rvmprof.register_code_object_class(MyCode, get_name)
@rvmprof.vmprof_execute_code("mycode", lambda code, level: code)
def mainloop(code, level):
if level > 0:
mainloop(code, level - 1)
else:
p, length = traceback.traceback(20)
traceback.walk_traceback(MyCode, my_callback, 42, p, length)
lltype.free(p, flavor="raw")
def my_callback(code, loc, arg):
print code, loc, arg
return 0
def f(argv):
code1 = MyCode()
rvmprof.register_code(code1, "foo")
mainloop(code1, 2)
return 0
t = Translation(f, None, gc="boehm")
t.compile_c()
stdout = t.driver.cbuilder.cmdexec("")
r = re.compile("[<]MyCode object at 0x([0-9a-f]+)[>] 0 42\n")
got = r.findall(stdout)
assert got == [got[0]] * 3
def test_register_code():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported, e:
py.test.skip(str(e))
def test_register_code():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported, e:
py.test.skip(str(e))
def test_enable():
class MyCode:
pass
def get_name(code):
return 'py:code:52:x'
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported, e:
py.test.skip(str(e))
def test_enable():
class MyCode:
pass
def get_name(code):
return 'py:code:52:x'
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported, e:
py.test.skip(str(e))
def test_jitted():
from rpython.jit.backend import detect_cpu
if not detect_cpu.autodetect().startswith('x86'):
py.test.skip("HAS_CODEMAP is only in the x86 jit backend for now")
class MyCode:
pass
def get_name(mycode):
raise NotImplementedError
rvmprof.register_code_object_class(MyCode, get_name)
jitdriver = jit.JitDriver(
greens=['code'],
reds='auto',
is_recursive=True,
get_unique_id=lambda code: rvmprof.get_unique_id(code))
@rvmprof.vmprof_execute_code("mycode", lambda code, level, total_i: code)
def mainloop(code, level, total_i):
i = 20
while i > 0:
jitdriver.jit_merge_point(code=code)
i -= 1
if level > 0:
mainloop(code, level - 1, total_i + i)
if level == 0 and total_i == 0:
p, length = traceback.traceback(20)
traceback.walk_traceback(MyCode, my_callback, 42, p, length)
lltype.free(p, flavor='raw')
def my_callback(code, loc, arg):
print code, loc, arg
return 0
def f(argv):
jit.set_param(jitdriver, "inlining", 0)
code1 = MyCode()
rvmprof.register_code(code1, "foo")
mainloop(code1, 2, 0)
return 0
t = Translation(f, None, gc="boehm")
t.rtype()
t.driver.pyjitpl_lltype()
t.compile_c()
stdout = t.driver.cbuilder.cmdexec('')
r = re.compile("[<]MyCode object at 0x([0-9a-f]+)[>] (\d) 42\n")
got = r.findall(stdout)
addr = got[0][0]
assert got == [(addr, '1'), (addr, '1'), (addr, '0')]
def test_jitted():
from rpython.jit.backend import detect_cpu
if not detect_cpu.autodetect().startswith("x86"):
py.test.skip("HAS_CODEMAP is only in the x86 jit backend for now")
class MyCode:
pass
def get_name(mycode):
raise NotImplementedError
rvmprof.register_code_object_class(MyCode, get_name)
jitdriver = jit.JitDriver(
greens=["code"], reds="auto", is_recursive=True, get_unique_id=lambda code: rvmprof.get_unique_id(code)
)
@rvmprof.vmprof_execute_code("mycode", lambda code, level, total_i: code)
def mainloop(code, level, total_i):
i = 20
while i > 0:
jitdriver.jit_merge_point(code=code)
i -= 1
if level > 0:
mainloop(code, level - 1, total_i + i)
if level == 0 and total_i == 0:
p, length = traceback.traceback(20)
traceback.walk_traceback(MyCode, my_callback, 42, p, length)
lltype.free(p, flavor="raw")
def my_callback(code, loc, arg):
print code, loc, arg
return 0
def f(argv):
jit.set_param(jitdriver, "inlining", 0)
code1 = MyCode()
rvmprof.register_code(code1, "foo")
mainloop(code1, 2, 0)
return 0
t = Translation(f, None, gc="boehm")
t.rtype()
t.driver.pyjitpl_lltype()
t.compile_c()
stdout = t.driver.cbuilder.cmdexec("")
r = re.compile("[<]MyCode object at 0x([0-9a-f]+)[>] (\d) 42\n")
got = r.findall(stdout)
addr = got[0][0]
assert got == [(addr, "1"), (addr, "1"), (addr, "0")]
def test_vmprof(self):
from rpython.rlib import rvmprof
class MyCode:
_vmprof_unique_id = 0
def __init__(self, name):
self.name = name
def get_name(code):
return code.name
code2 = MyCode("py:y:foo:4")
rvmprof.register_code(code2, get_name)
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported, e:
py.test.skip(str(e))
def test_vmprof(self):
from rpython.rlib import rvmprof
class MyCode:
_vmprof_unique_id = 0
_vmprof_weak_list = RWeakListMixin()
_vmprof_weak_list.initialize()
def __init__(self, name):
self.name = name
def get_name(code):
return code.name
code2 = MyCode("py:y:foo:4")
rvmprof.register_code(code2, get_name)
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported, e:
py.test.skip(str(e))
def test_vmprof_execute_code_1():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported:
pass
@rvmprof.vmprof_execute_code("xcode1", lambda code, num: code)
def main(code, num):
print num
return 42
def f():
res = main(MyCode(), 5)
assert res == 42
return 0
assert f() == 0
fn = compile(f, [])
assert fn() == 0
def test_vmprof_execute_code_1():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported:
pass
@rvmprof.vmprof_execute_code("xcode1", lambda code, num: code)
def main(code, num):
print num
return 42
def f():
res = main(MyCode(), 5)
assert res == 42
return 0
assert f() == 0
fn = compile(f, [])
assert fn() == 0
def test_register_code():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported as e:
py.test.skip(str(e))
@rvmprof.vmprof_execute_code("xcode1", lambda code, num: code)
def main(code, num):
print num
return 42
def f():
code = MyCode()
rvmprof.register_code(code, lambda code: 'some code')
res = main(code, 5)
assert res == 42
return 0
assert f() == 0
fn = compile(f, [], gcpolicy="minimark")
assert fn() == 0
def test_register_code():
class MyCode:
pass
try:
rvmprof.register_code_object_class(MyCode, lambda code: 'some code')
except rvmprof.VMProfPlatformUnsupported as e:
py.test.skip(str(e))
@rvmprof.vmprof_execute_code("xcode1", lambda code, num: code)
def main(code, num):
print num
return 42
def f():
code = MyCode()
rvmprof.register_code(code, lambda code: 'some code')
res = main(code, 5)
assert res == 42
return 0
assert f() == 0
fn = compile(f, [], gcpolicy="minimark")
assert fn() == 0
_my_stack_frame = _decorator(Interpreter.stack_frame)
Interpreter.stack_frame = _my_stack_frame
print "Interpreter was patched for vmprof"
def _safe(s):
if len(s) > 200:
s = s[:197] + '...'
return s.replace(':', ';')
def _get_full_name(w_cm):
# must not be longer than 255 chars
return "st:%s:0:/img" % _safe(w_cm.safe_identifier_string())
if plugin.is_enabled():
try:
rvmprof.register_code_object_class(W_CompiledMethod,
_get_full_name)
except rvmprof.VMProfPlatformUnsupported:
pass
def patch_compiled_method():
def _my_post_init(self):
from rpython.rlib import rvmprof
rvmprof.register_code(self, _get_full_name)
W_CompiledMethod.post_init = _my_post_init
# ____________________________________________________________
@plugin.expose_primitive(unwrap_spec=[object, int, float])
@jit.dont_look_inside
def enableProfiler(interp, s_frame, w_rcvr, fileno, period):
call_qsort_rec(r - 1)
assert g.num == 1234 + r
else:
raw = llmemory.raw_malloc(5)
qsort(raw, 5, 1, cb_compare_callback)
llmemory.raw_free(raw)
# <vmprof-hack>
# bah, we need to make sure that vmprof_execute_code is annotated, else
# rvmprof.c does not compile correctly
class FakeVMProfCode(object):
pass
rvmprof.register_code_object_class(FakeVMProfCode, lambda code: 'name')
@rvmprof.vmprof_execute_code("xcode1", lambda code, num: code)
def fake_vmprof_main(code, num):
return 42
# </vmprof-hack>
def entry_point(argv):
# <vmprof-hack>
if NonConstant(False):
fake_vmprof_main(FakeVMProfCode(), 42)
# </vmprof-hack>
return my_execute_frame(self, w_inputvalue, operr)
def _safe(s):
if len(s) > 110:
s = s[:107] + '...'
return s.replace(':', ';')
def _get_full_name(pycode):
# careful, must not have extraneous ':' or be longer than 255 chars
return "py:%s:%d:%s" % (_safe(
pycode.co_name), pycode.co_firstlineno, _safe(pycode.co_filename))
rvmprof.register_code_object_class(PyCode, _get_full_name)
def _init_ready(pycode):
rvmprof.register_code(pycode, _get_full_name)
PyCode._init_ready = _init_ready
# ____________________________________________________________
class Cache:
def __init__(self, space):
self.w_VMProfError = space.new_exception_class("_vmprof.VMProfError")
src = source.string.encode('utf-8')
else:
src = source.repr().encode('utf-8')
if len(src) > 200: # Must not be longer than 255 chars.
src = src[:197] + '...'
src = src.replace(':', ';')
return "py:L%s:%d:%s" % ("%d_%d" % (lno0, lno1), lno0, src)
def get_printable_location(pc, block, module, unit, excs, function): # ,ec
opcode = rffi.r_ulong(block[pc]) >> 8
name = optable.names[opcode]
return "pc=%d %s module=%s" % (pc, name, module.repr().encode('utf-8'))
rvmprof.register_code_object_class(Function, get_function_name)
def get_code(pc, block, frame):
return frame.function
#def get_unique_id(next_instr, is_being_profiled, bytecode):
def get_unique_id(pc, block, module, unit, exc, function):
return rvmprof.get_unique_id(function)
jitdriver = jit.JitDriver(
greens=['pc', 'block', 'module', 'unit', 'excs', 'function'], #, 'ec'],
reds=['frame'], # 'regv',
virtualizables=['frame'],
instruction = self.instructions[pc]
index = self.indices[pc]
stackDepth = self.stackDepth[pc]
handlerDepth = self.handlerDepth[pc]
return self.dis(instruction, index, stackDepth, handlerDepth)
def disassemble(self):
rv = [u"Code for %s: S:%d" % (self.profileName.decode("utf-8"),
self.startingDepth)]
for i in range(len(self.instructions)):
rv.append(u"%d: %s" % (i, self.disAt(i)))
return u"\n".join(rv)
def figureMaxDepth(self):
ai = AbstractInterpreter(self)
ai.run()
maxDepth, self.maxHandlerDepth = ai.getDepth()
self.maxDepth = max(maxDepth, self.startingDepth)
@elidable
def _profileName(self):
try:
filename, objname = self.fqn.encode("utf-8").split('$', 1)
except ValueError:
filename = "<unknown>"
objname = self.fqn.encode("utf-8")
method = self.methodName.encode("utf-8")
return "mt:%s.%s:1:%s" % (objname, method, filename)
rvmprof.register_code_object_class(Code, lambda code: code.profileName)
def execute_frame(self, w_inputvalue=None, operr=None):
# indirection for the optional arguments
return my_execute_frame(self, w_inputvalue, operr)
def _safe(s):
if len(s) > 110:
s = s[:107] + '...'
return s.replace(':', ';')
def _get_full_name(pycode):
# careful, must not have extraneous ':' or be longer than 255 chars
return "py:%s:%d:%s" % (_safe(pycode.co_name), pycode.co_firstlineno,
_safe(pycode.co_filename))
rvmprof.register_code_object_class(PyCode, _get_full_name)
def _init_ready(pycode):
rvmprof.register_code(pycode, _get_full_name)
PyCode._init_ready = _init_ready
# ____________________________________________________________
class Cache:
def __init__(self, space):
self.w_VMProfError = space.new_exception_class("_vmprof.VMProfError")
def register(self):
rvmprof.register_code_object_class(self.MyCode, self.MyCode.get_name)
def test_enable():
class MyCode:
pass
def get_name(code):
return 'py:code:52:x'
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported as e:
py.test.skip(str(e))
@rvmprof.vmprof_execute_code("xcode1", lambda code, num: code)
def main(code, num):
print num
s = 0
for i in range(num):
s += (i << 1)
if s % 2123423423 == 0:
print s
return s
tmpfilename = str(udir.join('test_rvmprof'))
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 check_profile(filename):
from vmprof import read_profile
prof = read_profile(filename)
assert prof.get_tree().name.startswith("py:")
assert prof.get_tree().count
assert f() == 0
assert os.path.exists(tmpfilename)
fn = compile(f, [], gcpolicy="minimark")
assert fn() == 0
try:
import vmprof
except ImportError:
py.test.skip("vmprof unimportable")
else:
check_profile(tmpfilename)
finally:
assert os.path.exists(tmpfilename)
os.unlink(tmpfilename)
def setup(self):
from rpython.rlib import rvmprof
rvmprof.register_code_object_class(W_CompiledMethod, _get_full_name)
def test_vmprof(self):
from rpython.rlib import rvmprof
class MyCode:
_vmprof_unique_id = 0
_vmprof_weak_list = RWeakListMixin()
_vmprof_weak_list.initialize()
def __init__(self, name):
self.name = name
def get_name(code):
return code.name
code2 = MyCode("py:y:foo:4")
rvmprof.register_code(code2, get_name)
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported as e:
py.test.skip(str(e))
def get_unique_id(code):
return rvmprof.get_unique_id(code)
driver = JitDriver(greens=['code'],
reds=['i', 's', 'num'],
is_recursive=True,
get_unique_id=get_unique_id)
@rvmprof.vmprof_execute_code("xcode13", lambda code, num: code)
def main(code, num):
return main_jitted(code, num)
def main_jitted(code, num):
s = 0
i = 0
while i < num:
driver.jit_merge_point(code=code, i=i, s=s, num=num)
s += (i << 1)
if i % 3 == 0 and code is not code2:
main(code2, 100)
i += 1
return s
tmpfilename = str(udir.join('test_rvmprof'))
def f(num):
rthread.get_ident() # register TLOFS_thread_ident
code = MyCode("py:x:foo:3")
rvmprof.register_code(code, get_name)
fd = os.open(tmpfilename, os.O_WRONLY | os.O_CREAT, 0666)
period = 0.0001
rvmprof.enable(fd, period)
res = main(code, num)
#assert res == 499999500000
rvmprof.disable()
os.close(fd)
return 0
def check_vmprof_output():
from vmprof import read_profile
tmpfile = str(udir.join('test_rvmprof'))
stats = read_profile(tmpfile)
t = stats.get_tree()
assert t.name == 'py:x:foo:3'
assert len(t.children) == 1 # jit
self.meta_interp(f, [1000000], inline=True)
try:
import vmprof
except ImportError:
pass
else:
check_vmprof_output()
def setup_module(mod):
try:
rvmprof.register_code_object_class(MyCode, MyCode.get_name)
except rvmprof.VMProfPlatformUnsupported as e:
py.test.skip(str(e))
handlerDepth = self.handlerDepth[pc]
return self.dis(instruction, index, stackDepth, handlerDepth)
def disassemble(self):
rv = [
u"Code for %s: S:%d" %
(self.profileName.decode("utf-8"), self.startingDepth)
]
for i in range(len(self.instructions)):
rv.append(u"%d: %s" % (i, self.disAt(i)))
return u"\n".join(rv)
def figureMaxDepth(self):
ai = AbstractInterpreter(self)
ai.run()
maxDepth, self.maxHandlerDepth = ai.getDepth()
self.maxDepth = max(maxDepth, self.startingDepth)
@elidable
def _profileName(self):
try:
filename, objname = self.fqn.encode("utf-8").split('$', 1)
except ValueError:
filename = "<unknown>"
objname = self.fqn.encode("utf-8")
method = self.methodName.encode("utf-8")
return "mt:%s.%s:1:%s" % (objname, method, filename)
rvmprof.register_code_object_class(Code, lambda code: code.profileName)
def setup_module(mod):
try:
rvmprof.register_code_object_class(MyCode, MyCode.get_name)
except rvmprof.VMProfPlatformUnsupported as e:
py.test.skip(str(e))
def test_enable():
class MyCode:
pass
def get_name(code):
return 'py:code:52:x'
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported as e:
py.test.skip(str(e))
@rvmprof.vmprof_execute_code("xcode1", lambda code, num: code)
def main(code, num):
print num
s = 0
for i in range(num):
s += (i << 1)
if s % 2123423423 == 0:
print s
return s
tmpfilename = str(udir.join('test_rvmprof'))
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 check_profile(filename):
from vmprof import read_profile
prof = read_profile(filename)
assert prof.get_tree().name.startswith("py:")
assert prof.get_tree().count
assert f() == 0
assert os.path.exists(tmpfilename)
fn = compile(f, [], gcpolicy="minimark")
assert fn() == 0
try:
import vmprof
except ImportError:
py.test.skip("vmprof unimportable")
else:
check_profile(tmpfilename)
finally:
assert os.path.exists(tmpfilename)
os.unlink(tmpfilename)
def test_vmprof(self):
from rpython.rlib import rvmprof
class MyCode:
_vmprof_unique_id = 0
_vmprof_weak_list = RWeakListMixin() ; _vmprof_weak_list.initialize()
def __init__(self, name):
self.name = name
def get_name(code):
return code.name
code2 = MyCode("py:y:foo:4")
rvmprof.register_code(code2, get_name)
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported as e:
py.test.skip(str(e))
def get_unique_id(code):
return rvmprof.get_unique_id(code)
driver = JitDriver(greens = ['code'], reds = ['i', 's', 'num'],
is_recursive=True, get_unique_id=get_unique_id)
@rvmprof.vmprof_execute_code("xcode13", lambda code, num: code)
def main(code, num):
return main_jitted(code, num)
def main_jitted(code, num):
s = 0
i = 0
while i < num:
driver.jit_merge_point(code=code, i=i, s=s, num=num)
s += (i << 1)
if i % 3 == 0 and code is not code2:
main(code2, 100)
i += 1
return s
tmpfilename = str(udir.join('test_rvmprof'))
def f(num):
rthread.get_ident() # register TLOFS_thread_ident
code = MyCode("py:x:foo:3")
rvmprof.register_code(code, get_name)
fd = os.open(tmpfilename, os.O_WRONLY | os.O_CREAT, 0666)
period = 0.0001
rvmprof.enable(fd, period)
res = main(code, num)
#assert res == 499999500000
rvmprof.disable()
os.close(fd)
return 0
def check_vmprof_output():
from vmprof import read_profile
tmpfile = str(udir.join('test_rvmprof'))
stats = read_profile(tmpfile)
t = stats.get_tree()
assert t.name == 'py:x:foo:3'
assert len(t.children) == 1 # jit
self.meta_interp(f, [1000000], inline=True)
try:
import vmprof
except ImportError:
pass
else:
check_vmprof_output()
def test_native():
eci = ExternalCompilationInfo(compile_extra=['-g','-O0'],
separate_module_sources=["""
RPY_EXTERN int native_func(int d) {
int j = 0;
if (d > 0) {
return native_func(d-1);
} else {
for (int i = 0; i < 42000; i++) {
j += d;
}
}
return j;
}
"""])
native_func = rffi.llexternal("native_func", [rffi.INT], rffi.INT,
compilation_info=eci)
class MyCode:
pass
def get_name(code):
return 'py:code:52:x'
try:
rvmprof.register_code_object_class(MyCode, get_name)
except rvmprof.VMProfPlatformUnsupported as e:
py.test.skip(str(e))
@rvmprof.vmprof_execute_code("xcode1", lambda code, num: code)
def main(code, num):
if num > 0:
return main(code, num-1)
else:
return native_func(100)
tmpfilename = str(udir.join('test_rvmprof'))
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_RDWR | os.O_CREAT, 0666)
num = 10000
period = 0.0001
rvmprof.enable(fd, period, native=1)
for i in range(num):
res = main(code, 3)
rvmprof.disable()
os.close(fd)
return 0
def check_profile(filename):
from vmprof import read_profile
from vmprof.show import PrettyPrinter
prof = read_profile(filename)
tree = prof.get_tree()
p = PrettyPrinter()
p._print_tree(tree)
def walk(tree, symbols):
symbols.append(tree.name)
if len(tree.children) == 0:
return
for child in tree.children.values():
walk(child, symbols)
symbols = []
walk(tree, symbols)
not_found = ['n:native_func']
for sym in symbols:
for i,name in enumerate(not_found):
if sym.startswith(name):
del not_found[i]
break
assert not_found == []
fn = compile(f, [], gcpolicy="incminimark", lldebug=True)
assert fn() == 0
try:
import vmprof
except ImportError:
py.test.skip("vmprof unimportable")
else:
check_profile(tmpfilename)
finally:
assert os.path.exists(tmpfilename)
os.unlink(tmpfilename)
def setup(self):
from rpython.rlib import rvmprof
rvmprof.register_code_object_class(W_CompiledMethod, _get_full_name)
