Profile (#37)

Switch from sys.settrace to sys.setprofile

The profile part has less overhead, as it only gets called for call and return.
Moreover, we do not need to care about threads, as Score-P does this for us.
In theory, it is also possible to catch calls to builtin C functions. However, this is not implemented.
Also added a minimal async example.

Author: AndreasGocht

scorep/trace.py

@@ -7,19 +7,19 @@
 try:
     import threading
 except ImportError:
-    _settrace = sys.settrace
+    _settrace = sys.setprofile
 
     def _unsettrace():
-        sys.settrace(None)
+        sys.setprofile(None)
 
 else:
     def _settrace(func):
-        threading.settrace(func)
-        sys.settrace(func)
+        threading.setprofile(func)
+        sys.setprofile(func)
 
     def _unsettrace():
-        sys.settrace(None)
-        threading.settrace(None)
+        sys.setprofile(None)
+        threading.setprofile(None)
 
 global_trace = scorep.trace_dummy.ScorepTraceDummy()
 
@@ -33,10 +33,8 @@ def __init__(self, scorep_bindings, trace=True):
         global global_trace
         global_trace = self
 
-        self.pathtobasename = {}  # for memoizing os.path.basename
         self.scorep_bindings = scorep_bindings
         self.globaltrace = self.globaltrace_lt
-        self.localtrace = self.localtrace_trace
         self.no_init_trace = not trace
 
     def register(self):
@@ -46,9 +44,6 @@ def unregister(self):
         _unsettrace()
 
     def run(self, cmd):
-        #import __main__
-        #dict = __main__.__dict__
-        #self.runctx(cmd, dict, dict)
         self.runctx(cmd)
 
     def runctx(self, cmd, globals=None, locals=None):
@@ -93,19 +88,16 @@ def globaltrace_lt(self, frame, why, arg):
             if not code.co_name == "_unsettrace" and not modulename == "scorep.trace":
                 self.scorep_bindings.region_begin(
                     modulename, code.co_name, full_file_name, line_number)
-            return self.localtrace
-        else:
-            return None
-
-    def localtrace_trace(self, frame, why, arg):
-        if why == "return":
+            return
+        elif why == 'return':
             code = frame.f_code
             modulename = frame.f_globals.get('__name__', None)
             if modulename is None:
                 modulename = "None"
             self.scorep_bindings.region_end(modulename, code.co_name)
-        return self.localtrace
-
+        else:
+            return
+          
     def user_region_begin(self, name, file_name=None, line_number=None):
         """
         Begin of an User region. If file_name or line_number is None, both will

test/miniasync.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+
+import asyncio
+
+work_size = 10000000
+
+
+def actual_work(i):
+    return sum(range(i))
+
+
+async def work1():
+    for i in range(5):
+        print("work1 ", actual_work(i * work_size))
+        await asyncio.sleep(1)
+
+
+async def work2():
+    for i in range(5):
+        print("work2 ", actual_work(i * work_size))
+        await asyncio.sleep(1)
+
+
+async def amain():
+    await asyncio.gather(
+        work1(),
+        work2(),
+        asyncio.get_event_loop().getaddrinfo("tu-dresden.de", 80),
+        asyncio.get_event_loop().getaddrinfo("www.tu-dresden.de", 80),
+    )
+
+
+def main():
+    asyncio.run(amain())
+
+
+if __name__ == "__main__":
+    main()