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 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_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_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 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)