Add scorep_instrumenter_base to heavily reduce code duplication (#71)

* Add scorep_instrumenter_base to heavily reduce code duplication
* Rename ScorepInstrumenterBase to ScorepInstrumenter
* Adapt docstring of run
* Use bindings region_begin directly
* Introduce scorep.instrumenter.utils module

Author: Flamefire

scorep/instrumenters/base_instrumenter.py

@@ -1,31 +1,9 @@
 __all__ = ['BaseInstrumenter']
 
 import abc
-import os
 import sys
 
 
-def get_module_name(frame):
-    modulename = frame.f_globals.get('__name__', None)
-    if modulename is None:
-        # this is a NUMPY special situation, see NEP-18, and Score-P Issue
-        # issues #63
-        if frame.f_code.co_filename == "<__array_function__ internals>":
-            modulename = "numpy.__array_function__"
-        else:
-            modulename = "unkown"
-    return modulename
-
-
-def get_file_name(frame):
-    file_name = frame.f_code.co_filename
-    if file_name is not None:
-        full_file_name = os.path.abspath(file_name)
-    else:
-        full_file_name = "None"
-    return full_file_name
-
-
 if sys.version_info >= (3, 4):
     class _BaseInstrumenter(abc.ABC):
         pass

scorep/instrumenters/scorep_instrumenter.py

@@ -0,0 +1,136 @@
+import abc
+import inspect
+import os
+from scorep.instrumenters import base_instrumenter
+
+
+class ScorepInstrumenter(base_instrumenter.BaseInstrumenter):
+    """Base class for all instrumenters using Score-P"""
+
+    def __init__(self, scorep_bindings, 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
+
+    @abc.abstractmethod
+    def _enable_instrumenter(self):
+        """Actually enable this instrumenter to collect events"""
+
+    @abc.abstractmethod
+    def _disable_instrumenter(self):
+        """Stop this instrumenter from collecting events"""
+
+    def register(self):
+        """Register this instrumenter (collect events)"""
+        if not self._tracer_registered:
+            self._enable_instrumenter()
+            self._tracer_registered = True
+
+    def unregister(self):
+        """Unregister this instrumenter (stop collecting events)"""
+        if self._tracer_registered:
+            self._disable_instrumenter()
+            self._tracer_registered = False
+
+    def get_registered(self):
+        """Return whether this instrumenter is currently collecting events"""
+        return self._tracer_registered
+
+    def run(self, cmd, globals=None, locals=None):
+        """Run the compiled command under this instrumenter.
+
+        When the instrumenter is enabled it is registered prior to the invocation and unregistered afterwards
+        """
+        if globals is None:
+            globals = {}
+        if locals is None:
+            locals = {}
+        if self._enabled:
+            self.register()
+        try:
+            exec(cmd, globals, locals)
+        finally:
+            self.unregister()
+
+    def region_begin(self, module_name, function_name, file_name, line_number):
+        """Record a region begin event"""
+        self._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)
+
+    def rewind_begin(self, name, file_name=None, line_number=None):
+        """
+        Begin of an Rewind region. If file_name or line_number is None, both will
+        be determined automatically
+        @param name name of the user region
+        @param file_name file name of the user region
+        @param line_number line number of the user region
+        """
+        if file_name is None or line_number is None:
+            frame = inspect.currentframe().f_back
+            file_name = frame.f_globals.get('__file__', None)
+            line_number = frame.f_lineno
+        if file_name is not None:
+            full_file_name = os.path.abspath(file_name)
+        else:
+            full_file_name = "None"
+
+        self._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)
+
+    def oa_region_begin(self, name, file_name=None, line_number=None):
+        """
+        Begin of an Online Access region. If file_name or line_number is None, both will
+        be determined automatically
+        @param name name of the user region
+        @param file_name file name of the user region
+        @param line_number line number of the user region
+        """
+        if file_name is None or line_number is None:
+            frame = inspect.currentframe().f_back
+            file_name = frame.f_globals.get('__file__', None)
+            line_number = frame.f_lineno
+        if file_name is not None:
+            full_file_name = os.path.abspath(file_name)
+        else:
+            full_file_name = "None"
+
+        self._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)
+
+    def user_enable_recording(self):
+        """Enable writing of trace events in ScoreP"""
+        self._scorep_bindings.enable_recording()
+
+    def user_disable_recording(self):
+        """Disable writing of trace events in ScoreP"""
+        self._scorep_bindings.disable_recording()
+
+    def user_parameter_int(self, name, val):
+        """Record a parameter of type integer"""
+        self._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)
+
+    def user_parameter_string(self, name, string):
+        """Record a parameter of type string"""
+        self._scorep_bindings.parameter_string(name, string)

scorep/instrumenters/scorep_profile.py

@@ -1,9 +1,8 @@
 __all__ = ['ScorepProfile']
 
 import sys
-import inspect
-import os.path
-import scorep.instrumenters.base_instrumenter as base_instrumenter
+from scorep.instrumenters.utils import get_module_name, get_file_name
+from scorep.instrumenters.scorep_instrumenter import ScorepInstrumenter
 
 try:
     import threading
@@ -23,133 +22,28 @@ def _unsetprofile():
         threading.setprofile(None)
 
 
-class ScorepProfile(base_instrumenter.BaseInstrumenter):
-    def __init__(self, scorep_bindings, 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()
-        """
-        global global_instrumenter
-        global_instrumenter = self
-        self.tracer_registered = False
-
-        self.scorep_bindings = scorep_bindings
-        self.globaltrace = self.globaltrace_lt
-        self.enable_instrumenter = enable_instrumenter
-
-    def register(self):
-        self.tracer_registered = True
-        _setprofile(self.globaltrace)
+class ScorepProfile(ScorepInstrumenter):
+    def _enable_instrumenter(self):
+        _setprofile(self._globaltrace)
 
-    def unregister(self):
+    def _disable_instrumenter(self):
         _unsetprofile()
-        self.tracer_registered = False
 
-    def get_registered(self):
-        return self.tracer_registered
-
-    def run(self, cmd, globals=None, locals=None):
-        if globals is None:
-            globals = {}
-        if locals is None:
-            locals = {}
-        if self.enable_instrumenter:
-            self.register()
-        try:
-            exec(cmd, globals, locals)
-        finally:
-            self.unregister()
-
-    def globaltrace_lt(self, frame, why, arg):
+    def _globaltrace(self, frame, why, arg):
         """Handler for call events.
 
         If the code block being entered is to be ignored, returns `None',
         else returns self.localtrace.
         """
         if why == 'call':
             code = frame.f_code
-            modulename = base_instrumenter.get_module_name(frame)
+            modulename = get_module_name(frame)
             if not code.co_name == "_unsetprofile" and not modulename[:6] == "scorep":
-                full_file_name = base_instrumenter.get_file_name(frame)
+                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)
-            return
+                self._scorep_bindings.region_begin(modulename, code.co_name, full_file_name, line_number)
         elif why == 'return':
             code = frame.f_code
-            modulename = base_instrumenter.get_module_name(frame)
+            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)
-        else:
-            return
-
-    def region_begin(self, module_name, function_name, file_name, line_number):
-        self.scorep_bindings.region_begin(
-            module_name, function_name, file_name, line_number)
-
-    def region_end(self, module_name, function_name):
-        self.scorep_bindings.region_end(module_name, function_name)
-
-    def rewind_begin(self, name, file_name=None, line_number=None):
-        """
-        Begin of an Rewind region. If file_name or line_number is None, both will
-        bet determined automatically
-        @param name name of the user region
-        @param file_name file name of the user region
-        @param line_number line number of the user region
-        """
-        if file_name is None or line_number is None:
-            frame = inspect.currentframe().f_back
-            file_name = frame.f_globals.get('__file__', None)
-            line_number = frame.f_lineno
-        if file_name is not None:
-            full_file_name = os.path.abspath(file_name)
-        else:
-            full_file_name = "None"
-
-        self.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)
-
-    def oa_region_begin(self, name, file_name=None, line_number=None):
-        """
-        Begin of an Online Access region. If file_name or line_number is None, both will
-        bet determined automatically
-        @param name name of the user region
-        @param file_name file name of the user region
-        @param line_number line number of the user region
-        """
-        if file_name is None or line_number is None:
-            frame = inspect.currentframe().f_back
-            file_name = frame.f_globals.get('__file__', None)
-            line_number = frame.f_lineno
-        if file_name is not None:
-            full_file_name = os.path.abspath(file_name)
-        else:
-            full_file_name = "None"
-
-        self.scorep_bindings.oa_region_begin(name, full_file_name, line_number)
-
-    def oa_region_end(self, name):
-        self.scorep_bindings.oa_region_end(name)
-
-    def user_enable_recording(self):
-        self.scorep_bindings.enable_recording()
-
-    def user_disable_recording(self):
-        self.scorep_bindings.disable_recording()
-
-    def user_parameter_int(self, name, val):
-        self.scorep_bindings.parameter_int(name, val)
-
-    def user_parameter_uint(self, name, val):
-        self.scorep_bindings.parameter_string(name, val)
-
-    def user_parameter_string(self, name, string):
-        self.scorep_bindings.parameter_string(name, string)
+                self._scorep_bindings.region_end(modulename, code.co_name)