Merge branch 'master' of github.com:score-p/scorep_binding_python

Author: AndreasGocht

scorep/__main__.py

@@ -1,22 +1,12 @@
 import os
 import sys
 import importlib
-import getopt
 
 import scorep.trace
 import scorep.helper
 import scorep.subsystem
 
 
-def _usage(outfile):
-    outfile.write("""TODO
-""" % sys.argv[0])
-
-
-cuda_support = None
-opencl_support = None
-
-
 def _err_exit(msg):
     sys.stderr.write("%s: %s\n" % ("scorep", msg))
     sys.exit(1)

scorep/subsystem.py

@@ -1,10 +1,5 @@
 import os
-import subprocess
-import re
 import sys
-import stat
-import platform
-import functools
 import distutils.ccompiler
 import tempfile
 import shutil

scorep/trace.py

@@ -2,81 +2,70 @@
 import sys
 import inspect
 import os.path
+import scorep.trace_dummy
 
 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 = None
+global_trace = scorep.trace_dummy.ScorepTraceDummy()
 
 
 class ScorepTrace:
     def __init__(self, scorep_bindings, trace=True):
         """
-        @param trace true if there shall be any tracing at all
+        @param trace true if the tracing shall be initialised.
+            Please note, that it is still possible to enable the tracing later using register()
         """
         global global_trace
         global_trace = self
 
-        self.pathtobasename = {}  # for memoizing os.path.basename
-        self.donothing = False
-        self.trace = trace
         self.scorep_bindings = scorep_bindings
-        if trace:
-            self.globaltrace = self.globaltrace_lt
-            self.localtrace = self.localtrace_trace
-        else:
-            self.donothing = True
+        self.globaltrace = self.globaltrace_lt
+        self.no_init_trace = not trace
 
     def register(self):
-        if not self.donothing:
-            _settrace(self.globaltrace)
+        _settrace(self.globaltrace)
 
     def unregister(self):
-        if not self.donothing:
-            _unsettrace()
+        _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):
         if globals is None:
             globals = {}
         if locals is None:
             locals = {}
-        if not self.donothing:
-            _settrace(self.globaltrace)
+        if not self.no_init_trace:
+            self.register()
         try:
             exec(cmd, globals, locals)
         finally:
-            if not self.donothing:
-                _unsettrace()
+            self.unregister()
 
     def runfunc(self, func, *args, **kw):
         result = None
-        if not self.donothing:
-            sys.settrace(self.globaltrace)
+        if not self.no_init_trace:
+            self.register()
         try:
             result = func(*args, **kw)
         finally:
-            if not self.donothing:
-                sys.settrace(None)
+            self.unregister()
         return result
 
     def globaltrace_lt(self, frame, why, arg):
@@ -96,23 +85,19 @@ def globaltrace_lt(self, frame, why, arg):
             else:
                 full_file_name = "None"
             line_number = frame.f_lineno
-            if self.trace and not code.co_name == "_unsettrace" and not modulename == "scorep.trace":
+            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"
-            if self.trace:
-                self.scorep_bindings.region_end(modulename, code.co_name)
-        return self.localtrace
-
+            self.scorep_bindings.region_end(modulename, code.co_name)
+        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

scorep/trace_dummy.py

@@ -0,0 +1,51 @@
+class ScorepTraceDummy:
+    def __init__(self, scorep_bindings=None, trace=True):
+        pass
+
+    def register(self):
+        pass
+
+    def unregister(self):
+        pass
+
+    def run(self, cmd):
+        pass
+
+    def runctx(self, cmd, globals=None, locals=None):
+        pass
+
+    def runfunc(self, func, *args, **kw):
+        pass
+
+    def user_region_begin(self, name, file_name=None, line_number=None):
+        pass
+
+    def user_region_end(self, name):
+        pass
+
+    def rewind_begin(self, name, file_name=None, line_number=None):
+        pass
+
+    def rewind_end(self, name, value):
+        pass
+
+    def oa_region_begin(self, name, file_name=None, line_number=None):
+        pass
+
+    def oa_region_end(self, name):
+        pass
+
+    def user_enable_recording(self):
+        pass
+
+    def user_disable_recording(self):
+        pass
+
+    def user_parameter_int(self, name, val):
+        pass
+
+    def user_parameter_uint(self, name, val):
+        pass
+
+    def user_parameter_string(self, name, string):
+        pass

setup.py

@@ -1,15 +1,23 @@
 from distutils.core import setup, Extension
 import scorep.helper
+import os
+import logging
 
-(include, lib, lib_dir, macro, linker_flags) = scorep.helper.generate_compile_deps()
+cmodules = []
+no_scorep = False
 
+# This is not documented on purpose. Only use if you know what you are doing.
+if "SCOREP_NO_SCOREP" in os.environ and os.environ["SCOREP_NO_SCOREP"] == "YES":
+    logging.warning("building without Score-P! Tracing will not work!")
+    no_scorep = True
 
-cmodules = []
-cmodules.append(Extension('scorep.scorep_bindings',
-                          include_dirs=include,
-                          libraries=[],
-                          extra_compile_args=["-std=c++11"],
-                          sources=['src/scorep.cpp']))
+if not no_scorep:
+    (include, _, _, _, _) = scorep.helper.generate_compile_deps()
+    cmodules.append(Extension('scorep.scorep_bindings',
+                              include_dirs=include,
+                              libraries=[],
+                              extra_compile_args=["-std=c++11"],
+                              sources=['src/scorep.cpp']))
 
 
 setup(

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

test/test.py

@@ -86,6 +86,19 @@ def test_user_regions(self):
         self.assertRegex(std_out,
                          'LEAVE[ ]*[0-9 ]*[0-9 ]*Region: "user:test_region"')
 
+    def test_user_regions_no_scorep(self):
+        env = self.env
+        env["SCOREP_EXPERIMENT_DIRECTORY"] += "/test_user_regions_no_scorep"
+
+        out = call([self.python,
+                    "test_user_regions.py"],
+                   env=env)
+        std_out = out[1]
+        std_err = out[2]
+
+        self.assertEqual(std_err, self.expected_std_err)
+        self.assertEqual(std_out, "hello world\n")
+
     def test_user_rewind(self):
         env = self.env
         env["SCOREP_EXPERIMENT_DIRECTORY"] += "/test_user_rewind"