Directly import C extension (#82)

Avoid using `importlib` to load the binding in __main__.py

Author: Flamefire

scorep/__main__.py

@@ -1,6 +1,5 @@
 import os
 import sys
-import importlib
 
 import scorep.instrumenter
 import scorep.subsystem
@@ -83,15 +82,12 @@ def scorep_main(argv=None):
     else:
         scorep.subsystem.reset_pereload()
 
-    scorep_bindings = importlib.import_module("scorep.scorep_bindings")
-
     # everything is ready
     sys.argv = prog_argv
     progname = prog_argv[0]
     sys.path[0] = os.path.split(progname)[0]
 
-    tracer = scorep.instrumenter.get_instrumenter(scorep_bindings,
-                                                  not no_instrumenter,
+    tracer = scorep.instrumenter.get_instrumenter(not no_instrumenter,
                                                   instrumenter_type)
     try:
         with open(progname) as fp:

scorep/instrumenter.py

@@ -1,38 +1,31 @@
-import scorep.instrumenters.dummy
-import scorep.instrumenters.scorep_profile
-import scorep.instrumenters.scorep_trace
-
 import inspect
 import os
 
 global_instrumenter = None
 
 
-def get_instrumenter(bindings=None,
-                     enable_instrumenter=False,
+def get_instrumenter(enable_instrumenter=False,
                      instrumenter_type="dummy"):
     """
     returns an instrumenter
 
-    @param bindings the c/c++ scorep bindings
     @param enable_instrumenter True if the Instrumenter should be enabled when run is called
     @param instrumenter_type which python tracing interface to use.
            Currently available: `profile` (default), `trace` and `dummy`
     """
     global global_instrumenter
     if global_instrumenter is None:
         if instrumenter_type == "profile":
-            global_instrumenter = scorep.instrumenters.scorep_profile.ScorepProfile(
-                bindings, enable_instrumenter)
+            from scorep.instrumenters.scorep_profile import ScorepProfile
+            global_instrumenter = ScorepProfile(enable_instrumenter)
         elif instrumenter_type == "trace":
-            global_instrumenter = scorep.instrumenters.scorep_trace.ScorepTrace(
-                bindings, enable_instrumenter)
+            from scorep.instrumenters.scorep_trace import ScorepTrace
+            global_instrumenter = ScorepTrace(enable_instrumenter)
         elif instrumenter_type == "dummy":
-            global_instrumenter = scorep.instrumenters.dummy.ScorepDummy(
-                enable_instrumenter)
+            from scorep.instrumenters.dummy import ScorepDummy
+            global_instrumenter = ScorepDummy(enable_instrumenter)
         else:
-            raise RuntimeError(
-                "instrumenter_type \"{}\" unkown".format(instrumenter_type))
+            raise RuntimeError('instrumenter_type "{}" unkown'.format(instrumenter_type))
 
     return global_instrumenter
 
@@ -69,8 +62,7 @@ def __init__(self, region_name=None):
         self.region_name = region_name
 
     def __enter__(self):
-        self.tracer_registered = scorep.instrumenter.get_instrumenter(
-        ).get_registered()
+        self.tracer_registered = get_instrumenter().get_registered()
         if not self.tracer_registered:
             if self.region_name:
                 self.module_name = "user_instrumenter"
@@ -82,18 +74,18 @@ def __enter__(self):
                 else:
                     full_file_name = "None"
 
-                scorep.instrumenter.get_instrumenter().region_begin(
+                get_instrumenter().region_begin(
                     self.module_name, self.region_name, full_file_name,
                     line_number)
 
-            scorep.instrumenter.get_instrumenter().register()
+            get_instrumenter().register()
 
     def __exit__(self, exc_type, exc_value, traceback):
         if not self.tracer_registered:
-            scorep.instrumenter.get_instrumenter().unregister()
+            get_instrumenter().unregister()
 
             if self.region_name is not None:
-                scorep.instrumenter.get_instrumenter().region_end(
+                get_instrumenter().region_end(
                     self.module_name, self.region_name)
 
 
@@ -111,10 +103,9 @@ def __init__(self, region_name=None):
         self.region_name = region_name
 
     def __enter__(self):
-        self.tracer_registered = scorep.instrumenter.get_instrumenter(
-        ).get_registered()
+        self.tracer_registered = get_instrumenter().get_registered()
         if self.tracer_registered:
-            scorep.instrumenter.get_instrumenter().unregister()
+            get_instrumenter().unregister()
 
             if self.region_name is not None:
                 self.module_name = "user_instrumenter"
@@ -126,14 +117,14 @@ def __enter__(self):
                 else:
                     full_file_name = "None"
 
-                scorep.instrumenter.get_instrumenter().region_begin(
+                get_instrumenter().region_begin(
                     self.module_name, self.region_name, full_file_name,
                     line_number)
 
     def __exit__(self, exc_type, exc_value, traceback):
         if self.tracer_registered:
             if self.region_name is not None:
-                scorep.instrumenter.get_instrumenter().region_end(
+                get_instrumenter().region_end(
                     self.module_name, self.region_name)
 
-            scorep.instrumenter.get_instrumenter().register()
+            get_instrumenter().register()

scorep/instrumenters/dummy.py

@@ -4,7 +4,7 @@
 
 
 class ScorepDummy(base_instrumenter.BaseInstrumenter):
-    def __init__(self, scorep_bindings=None, enable_instrumenter=True):
+    def __init__(self, enable_instrumenter=True):
         pass
 
     def register(self):

scorep/instrumenters/scorep_instrumenter.py

@@ -2,17 +2,17 @@
 import inspect
 import os
 from scorep.instrumenters import base_instrumenter
+from scorep import scorep_bindings
 
 
 class ScorepInstrumenter(base_instrumenter.BaseInstrumenter):
     """Base class for all instrumenters using Score-P"""
 
-    def __init__(self, scorep_bindings, enable_instrumenter=True):
+    def __init__(self, enable_instrumenter=True):
         """
         @param enable_instrumenter true if the tracing shall be initialised.
             Please note, that it is still possible to enable the tracing later using register()
         """
-        self._scorep_bindings = scorep_bindings
         self._tracer_registered = False
         self._enabled = enable_instrumenter
 
@@ -58,12 +58,12 @@ def run(self, cmd, globals=None, locals=None):
 
     def region_begin(self, module_name, function_name, file_name, line_number):
         """Record a region begin event"""
-        self._scorep_bindings.region_begin(
+        scorep_bindings.region_begin(
             module_name, function_name, file_name, line_number)
 
     def region_end(self, module_name, function_name):
         """Record a region end event"""
-        self._scorep_bindings.region_end(module_name, function_name)
+        scorep_bindings.region_end(module_name, function_name)
 
     def rewind_begin(self, name, file_name=None, line_number=None):
         """
@@ -82,15 +82,15 @@ def rewind_begin(self, name, file_name=None, line_number=None):
         else:
             full_file_name = "None"
 
-        self._scorep_bindings.rewind_begin(name, full_file_name, line_number)
+        scorep_bindings.rewind_begin(name, full_file_name, line_number)
 
     def rewind_end(self, name, value):
         """
         End of an Rewind region.
         @param name name of the user region
         @param value True or False, whenether the region shall be rewinded or not.
         """
-        self._scorep_bindings.rewind_end(name, value)
+        scorep_bindings.rewind_end(name, value)
 
     def oa_region_begin(self, name, file_name=None, line_number=None):
         """
@@ -109,28 +109,28 @@ def oa_region_begin(self, name, file_name=None, line_number=None):
         else:
             full_file_name = "None"
 
-        self._scorep_bindings.oa_region_begin(name, full_file_name, line_number)
+        scorep_bindings.oa_region_begin(name, full_file_name, line_number)
 
     def oa_region_end(self, name):
         """End an Online Access region."""
-        self._scorep_bindings.oa_region_end(name)
+        scorep_bindings.oa_region_end(name)
 
     def user_enable_recording(self):
         """Enable writing of trace events in ScoreP"""
-        self._scorep_bindings.enable_recording()
+        scorep_bindings.enable_recording()
 
     def user_disable_recording(self):
         """Disable writing of trace events in ScoreP"""
-        self._scorep_bindings.disable_recording()
+        scorep_bindings.disable_recording()
 
     def user_parameter_int(self, name, val):
         """Record a parameter of type integer"""
-        self._scorep_bindings.parameter_int(name, val)
+        scorep_bindings.parameter_int(name, val)
 
     def user_parameter_uint(self, name, val):
         """Record a parameter of type unsigned integer"""
-        self._scorep_bindings.parameter_string(name, val)
+        scorep_bindings.parameter_string(name, val)
 
     def user_parameter_string(self, name, string):
         """Record a parameter of type string"""
-        self._scorep_bindings.parameter_string(name, string)
+        scorep_bindings.parameter_string(name, string)

scorep/instrumenters/scorep_profile.py

@@ -3,6 +3,7 @@
 import sys
 from scorep.instrumenters.utils import get_module_name, get_file_name
 from scorep.instrumenters.scorep_instrumenter import ScorepInstrumenter
+from scorep import scorep_bindings
 
 try:
     import threading
@@ -41,9 +42,9 @@ def _globaltrace(self, frame, why, arg):
             if not code.co_name == "_unsetprofile" and not modulename[:6] == "scorep":
                 full_file_name = get_file_name(frame)
                 line_number = code.co_firstlineno
-                self._scorep_bindings.region_begin(modulename, code.co_name, full_file_name, line_number)
+                scorep_bindings.region_begin(modulename, code.co_name, full_file_name, line_number)
         elif why == 'return':
             code = frame.f_code
             modulename = get_module_name(frame)
             if not code.co_name == "_unsetprofile" and not modulename[:6] == "scorep":
-                self._scorep_bindings.region_end(modulename, code.co_name)
+                scorep_bindings.region_end(modulename, code.co_name)

scorep/instrumenters/scorep_trace.py

@@ -3,6 +3,7 @@
 import sys
 from scorep.instrumenters.utils import get_module_name, get_file_name
 from scorep.instrumenters.scorep_instrumenter import ScorepInstrumenter
+from scorep import scorep_bindings
 
 try:
     import threading
@@ -39,13 +40,13 @@ def _globaltrace(self, frame, why, arg):
             if not code.co_name == "_unsettrace" and not modulename[:6] == "scorep":
                 full_file_name = get_file_name(frame)
                 line_number = code.co_firstlineno
-                self._scorep_bindings.region_begin(modulename, code.co_name, full_file_name, line_number)
+                scorep_bindings.region_begin(modulename, code.co_name, full_file_name, line_number)
                 return self._localtrace
         return None
 
     def _localtrace(self, frame, why, arg):
         if why == 'return':
             code = frame.f_code
             modulename = get_module_name(frame)
-            self._scorep_bindings.region_end(modulename, code.co_name)
+            scorep_bindings.region_end(modulename, code.co_name)
         return self._localtrace