Use the codeobject pointer to idetify regions

README.md

@@ -261,6 +261,7 @@ Please be aware the `--user` is always passed to Score-P, as this is needed for
 ## Not Working
 * python multiprocessing
     * Score-P does currently only support MPI or SHMEM. Any other multiprocessing approach cannot be traced.
+* tracking `importlib.reload()`
 
 # Acknowledgments
 The European Union initially supported this work as part of the European Union’s Horizon 2020 project READEX (grant agreement number 671657).

scorep/_instrumenters/base_instrumenter.py

@@ -30,11 +30,11 @@ def run(self, cmd, globals=None, locals=None):
         pass
 
     @abc.abstractmethod
-    def region_begin(self, module_name, function_name, file_name, line_number):
+    def region_begin(self, module_name, function_name, file_name, line_number, code_object):
         pass
 
     @abc.abstractmethod
-    def region_end(self, module_name, function_name):
+    def region_end(self, module_name, function_name, code_object):
         pass
 
     @abc.abstractmethod

scorep/_instrumenters/dummy.py

@@ -23,10 +23,10 @@ def run(self, cmd, globals=None, locals=None):
             locals = {}
         exec(cmd, globals, locals)
 
-    def region_begin(self, module_name, function_name, file_name, line_number):
+    def region_begin(self, module_name, function_name, file_name, line_number, code_object=None):
         pass
 
-    def region_end(self, module_name, function_name):
+    def region_end(self, module_name, function_name, code_object=None):
         pass
 
     def rewind_begin(self, name, file_name=None, line_number=None):

scorep/_instrumenters/scorep_instrumenter.py

@@ -56,14 +56,14 @@ def run(self, cmd, globals=None, locals=None):
         finally:
             self.unregister()
 
-    def region_begin(self, module_name, function_name, file_name, line_number):
+    def region_begin(self, module_name, function_name, file_name, line_number, code_object=None):
         """Record a region begin event"""
         scorep._bindings.region_begin(
-            module_name, function_name, file_name, line_number)
+            module_name, function_name, file_name, line_number, code_object)
 
-    def region_end(self, module_name, function_name):
+    def region_end(self, module_name, function_name, code_object=None):
         """Record a region end event"""
-        scorep._bindings.region_end(module_name, function_name)
+        scorep._bindings.region_end(module_name, function_name, code_object)
 
     def rewind_begin(self, name, file_name=None, line_number=None):
         """

scorep/_instrumenters/scorep_profile.py

@@ -39,12 +39,13 @@ def _globaltrace(self, frame, why, arg):
         if why == 'call':
             code = frame.f_code
             modulename = get_module_name(frame)
+
             if not code.co_name == "_unsetprofile" and not modulename[:6] == "scorep":
                 full_file_name = get_file_name(frame)
                 line_number = code.co_firstlineno
-                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, code)
         elif why == 'return':
             code = frame.f_code
             modulename = get_module_name(frame)
             if not code.co_name == "_unsetprofile" and not modulename[:6] == "scorep":
-                scorep._bindings.region_end(modulename, code.co_name)
+                scorep._bindings.region_end(modulename, code.co_name, code)

scorep/_instrumenters/scorep_trace.py

@@ -40,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
-                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, code)
                 return self._localtrace
         return None
 
     def _localtrace(self, frame, why, arg):
         if why == 'return':
             code = frame.f_code
             modulename = get_module_name(frame)
-            scorep._bindings.region_end(modulename, code.co_name)
+            scorep._bindings.region_end(modulename, code.co_name, code)
         return self._localtrace

scorep/user.py

@@ -74,6 +74,7 @@ def __enter__(self):
         initally_registered = scorep.instrumenter.get_instrumenter().get_registered()
         with scorep.instrumenter.disable():
             if(self.user_region_name):
+                # The user did specify a region name, so its a user_region
                 self.module_name = "user"
                 frame = inspect.currentframe().f_back
                 file_name = frame.f_globals.get('__file__', None)
@@ -85,46 +86,53 @@ def __enter__(self):
 
                 scorep.instrumenter.get_instrumenter().region_begin(
                     self.module_name, self.region_name, full_file_name, line_number)
-            elif(callable(self.func)):
-                """
-                looks like the decorator is invoked
-                """
-                if not initally_registered:
-                    self.region_name = self.func.__name__
-                    self.module_name = self.func.__module__
-                    file_name = self.func.__code__.co_filename
-                    line_number = self.func.__code__.co_firstlineno
-
-                    if file_name is not None:
-                        full_file_name = os.path.abspath(file_name)
-                    else:
-                        full_file_name = "None"
-
-                    scorep.instrumenter.get_instrumenter().region_begin(
-                        self.module_name, self.region_name, full_file_name, line_number)
+            elif callable(self.func) and not initally_registered:
+                # The user did not specify a region name, and it's a callable, so it's a semi instrumented region
+                self.region_name = self.func.__name__
+                self.module_name = self.func.__module__
+                self.code_obj = self.func.__code__
+                file_name = self.func.__code__.co_filename
+                line_number = self.func.__code__.co_firstlineno
+
+                if file_name is not None:
+                    full_file_name = os.path.abspath(file_name)
                 else:
-                    """
-                    do not need to decorate a function, when we are registerd. It is instrumented any way.
-                    """
-                    pass
+                    full_file_name = "None"
+
+                scorep.instrumenter.get_instrumenter().region_begin(
+                    self.module_name, self.region_name, full_file_name, line_number, self.code_obj)
+            elif callable(self.func) and initally_registered:
+                # The user did not specify a region name, and it's a callable, so it's a
+                # semi instrumented region. However, the instrumenter is active, so there
+                # is nothing to do.
+                pass
             else:
-                raise RuntimeError("a region name needs to be specified")
+                # The user did not specify a region name, and it's not a callable. So it
+                # is a context region without a region name. Throw an error.
+                raise RuntimeError("A region name needs to be specified.")
 
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):
-        if (callable(self.func)
-            and scorep.instrumenter.get_instrumenter().get_registered()
-                and not self.user_region_name):
-            """
-            looks like there is a decorator, we are registered and the name is not specified by the user,
-            so we do not need to do anything. The Instrumentation will take care.
-            """
-            return False
-        else:
+        initally_registered = scorep.instrumenter.get_instrumenter().get_registered()
+        if self.user_region_name:
+            # The user did specify a region name, so its a user_region
             scorep.instrumenter.get_instrumenter().region_end(
                 self.module_name, self.region_name)
-            return False
+        elif callable(self.func) and not initally_registered:
+            # The user did not specify a region name, and it's a callable, so it's a semi instrumented region
+            scorep.instrumenter.get_instrumenter().region_end(
+                self.module_name, self.region_name, self.code_obj)
+        elif callable(self.func) and initally_registered:
+            # The user did not specify a region name, and it's a callable, so it's a
+            # semi instrumented region. However, the instrumenter is active, so there
+            # is nothing to do.
+            pass
+        else:
+            # The user did not specify a region name, and it's not a callable. So it
+            # is a context region without a region name. Throw an error.
+            raise RuntimeError("Something wen't wrong. Please do a Bug Report.")
+        return False
 
 
 def rewind_begin(name, file_name=None, line_number=None):

src/methods.cpp

@@ -4,6 +4,8 @@
 #include <cstdint>
 #include <scorep/SCOREP_User_Functions.h>
 
+#include <iostream>
+
 extern "C"
 {
 
@@ -28,15 +30,26 @@ extern "C"
     static PyObject* region_begin(PyObject* self, PyObject* args)
     {
         const char* module;
-        const char* region_name;
+        const char* function_name;
         const char* file_name;
+        PyObject* identifier = nullptr;
         std::uint64_t line_number = 0;
 
-        if (!PyArg_ParseTuple(args, "sssK", &module, &region_name, &file_name, &line_number))
+        if (!PyArg_ParseTuple(args, "sssKO", &module, &function_name, &file_name, &line_number,
+                              &identifier))
+        {
             return NULL;
-
-        const std::string& region = scorepy::make_region_name(module, region_name);
-        scorepy::region_begin(region, module, file_name, line_number);
+        }
+
+        if (identifier == nullptr or identifier == Py_None)
+        {
+            scorepy::region_begin(function_name, module, file_name, line_number);
+        }
+        else
+        {
+            scorepy::region_begin(function_name, module, file_name, line_number,
+                                  reinterpret_cast<std::uintptr_t>(identifier));
+        }
 
         Py_RETURN_NONE;
     }
@@ -47,13 +60,23 @@ extern "C"
     static PyObject* region_end(PyObject* self, PyObject* args)
     {
         const char* module;
-        const char* region_name;
+        const char* function_name;
+        PyObject* identifier = nullptr;
 
-        if (!PyArg_ParseTuple(args, "ss", &module, &region_name))
+        if (!PyArg_ParseTuple(args, "ssO", &module, &function_name, &identifier))
+        {
             return NULL;
-
-        const std::string& region = scorepy::make_region_name(module, region_name);
-        scorepy::region_end(region);
+        }
+
+        if (identifier == nullptr or identifier == Py_None)
+        {
+            scorepy::region_end(function_name, module);
+        }
+        else
+        {
+            scorepy::region_end(function_name, module,
+                                reinterpret_cast<std::uintptr_t>(identifier));
+        }
 
         Py_RETURN_NONE;
     }

src/scorepy/cInstrumenter.cpp

@@ -3,6 +3,7 @@
 #include "pythonHelpers.hpp"
 #include <algorithm>
 #include <array>
+#include <cstdint>
 #include <string>
 
 namespace scorepy
@@ -122,9 +123,9 @@ bool CInstrumenter::on_event(PyFrameObject& frame, int what, PyObject*)
         if (std::string(name) != "_unsetprofile" && std::string(module_name, 0, 6) != "scorep")
         {
             const int line_number = code.co_firstlineno;
-            const auto& region_name = make_region_name(module_name, name);
             const auto file_name = get_file_name(frame);
-            region_begin(region_name, module_name, file_name, line_number);
+            region_begin(name, module_name, file_name, line_number,
+                         reinterpret_cast<std::uintptr_t>(&code));
         }
         break;
     }
@@ -138,8 +139,7 @@ bool CInstrumenter::on_event(PyFrameObject& frame, int what, PyObject*)
         // TODO: Use string_view/CString comparison?
         if (std::string(name) != "_unsetprofile" && std::string(module_name, 0, 6) != "scorep")
         {
-            const auto& region_name = make_region_name(module_name, name);
-            region_end(region_name);
+            region_end(name, module_name, reinterpret_cast<std::uintptr_t>(&code));
         }
         break;
     }