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/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

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* region;
         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, "sssK|O", &module, &region, &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)
+        {
+            scorepy::region_begin(region, module, file_name, line_number);
+        }
+        else
+        {
+            scorepy::region_begin(region, module, file_name, line_number,
+                                  reinterpret_cast<std::uintptr_t>(identifier));
+        }
 
         Py_RETURN_NONE;
     }
@@ -47,13 +60,22 @@ extern "C"
     static PyObject* region_end(PyObject* self, PyObject* args)
     {
         const char* module;
-        const char* region_name;
+        const char* region;
+        PyObject* identifier = nullptr;
 
-        if (!PyArg_ParseTuple(args, "ss", &module, &region_name))
+        if (!PyArg_ParseTuple(args, "ss|O", &module, &region, &identifier))
+        {
             return NULL;
-
-        const std::string& region = scorepy::make_region_name(module, region_name);
-        scorepy::region_end(region);
+        }
+
+        if (identifier == nullptr)
+        {
+            scorepy::region_end(region, module);
+        }
+        else
+        {
+            scorepy::region_end(region, 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
@@ -113,33 +114,32 @@ bool CInstrumenter::on_event(PyFrameObject& frame, int what, PyObject*)
     {
     case PyTrace_CALL:
     {
-        const PyCodeObject& code = *frame.f_code;
-        const char* name = PyUnicode_AsUTF8(code.co_name);
+        const PyCodeObject* code = frame.f_code;
+        const char* name = PyUnicode_AsUTF8(code->co_name);
         const char* module_name = get_module_name(frame);
         assert(name);
         assert(module_name);
         // TODO: Use string_view/CString comparison?
         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 int line_number = code->co_firstlineno;
             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;
     }
     case PyTrace_RETURN:
     {
-        const PyCodeObject& code = *frame.f_code;
-        const char* name = PyUnicode_AsUTF8(code.co_name);
+        const PyCodeObject* code = frame.f_code;
+        const char* name = PyUnicode_AsUTF8(code->co_name);
         const char* module_name = get_module_name(frame);
         assert(name);
         assert(module_name);
         // 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;
     }

src/scorepy/events.cpp

@@ -23,25 +23,11 @@ struct region_handle
 
 constexpr region_handle uninitialised_region_handle = region_handle();
 
-static std::unordered_map<std::string, region_handle> regions;
+static std::unordered_map<std::uintptr_t, region_handle> regions;
+static std::unordered_map<std::string, std::uintptr_t> region_translations;
+static std::unordered_map<std::string, region_handle> user_regions;
 static std::unordered_map<std::string, region_handle> rewind_regions;
 
-void region_begin(const std::string& region_name, std::string module, std::string file_name,
-                  std::uint64_t line_number)
-{
-    auto& region_handle = regions[region_name];
-
-    if (region_handle == uninitialised_region_handle)
-    {
-        SCOREP_User_RegionInit(&region_handle.value, NULL, &SCOREP_User_LastFileHandle,
-                               region_name.c_str(), SCOREP_USER_REGION_TYPE_FUNCTION,
-                               file_name.c_str(), line_number);
-        SCOREP_User_RegionSetGroup(region_handle.value,
-                                   std::string(module, 0, module.find('.')).c_str());
-    }
-    SCOREP_User_RegionEnter(region_handle.value);
-}
-
 /// Region names that are known to have no region enter event and should not report an error
 /// on region exit
 static const std::array<std::string, 2> EXIT_REGION_WHITELIST = {
@@ -52,45 +38,119 @@ static const std::array<std::string, 2> EXIT_REGION_WHITELIST = {
 #endif
 };
 
-void region_end(const std::string& region_name)
+void region_begin(const std::string& region, const std::string& module,
+                  const std::string& file_name, const std::uint64_t line_number,
+                  const std::uintptr_t& identifier)
 {
-    const auto itRegion = regions.find(region_name);
-    if (itRegion != regions.end())
-    {
-        SCOREP_User_RegionEnd(itRegion->second.value);
-    }
-    else
+    auto& region_handle = regions[identifier];
+
+    if (region_handle == uninitialised_region_handle)
     {
-        static region_handle error_region;
-        static SCOREP_User_ParameterHandle scorep_param = SCOREP_USER_INVALID_PARAMETER;
-        static bool error_printed = false;
+        auto& region_name = make_region_name(module, region);
+        auto it = user_regions.find(region_name);
+        if (it == user_regions.end())
+        {
+            SCOREP_User_RegionInit(&region_handle.value, NULL, &SCOREP_User_LastFileHandle,
+                                   region_name.c_str(), SCOREP_USER_REGION_TYPE_FUNCTION,
+                                   file_name.c_str(), line_number);
 
-        if (std::find(EXIT_REGION_WHITELIST.begin(), EXIT_REGION_WHITELIST.end(), region_name) !=
-            EXIT_REGION_WHITELIST.end())
+            SCOREP_User_RegionSetGroup(region_handle.value,
+                                       std::string(module, 0, module.find('.')).c_str());
+        }
+        else
         {
-            return;
+            region_handle = it->second;
         }
+        region_translations[region_name + std::to_string(line_number)] = identifier;
+    }
+    SCOREP_User_RegionEnter(region_handle.value);
+}
+
+void region_begin(const std::string& region, const std::string& module,
+                  const std::string& file_name, const std::uint64_t line_number)
+{
+    auto& region_name = make_region_name(module, region);
+    auto& region_handle = user_regions[region_name];
 
-        if (error_region.value == SCOREP_USER_INVALID_REGION)
+    if (region_handle == uninitialised_region_handle)
+    {
+        auto it_translation = region_translations.find(region_name + std::to_string(line_number));
+        if (it_translation == region_translations.end())
         {
-            SCOREP_User_RegionInit(&error_region.value, NULL, &SCOREP_User_LastFileHandle,
-                                   "error_region", SCOREP_USER_REGION_TYPE_FUNCTION, "scorep.cpp",
-                                   0);
-            SCOREP_User_RegionSetGroup(error_region.value, "error");
-        }
-        SCOREP_User_RegionEnter(error_region.value);
-        SCOREP_User_ParameterString(&scorep_param, "leave-region", region_name.c_str());
-        SCOREP_User_RegionEnd(error_region.value);
+            SCOREP_User_RegionInit(&region_handle.value, NULL, &SCOREP_User_LastFileHandle,
+                                   region_name.c_str(), SCOREP_USER_REGION_TYPE_FUNCTION,
+                                   file_name.c_str(), line_number);
 
-        if (!error_printed)
+            SCOREP_User_RegionSetGroup(region_handle.value,
+                                       std::string(module, 0, module.find('.')).c_str());
+        }
+        else
         {
-            std::cerr << "SCOREP_BINDING_PYTHON ERROR: There was a region exit without an enter!\n"
-                      << "SCOREP_BINDING_PYTHON ERROR: For details look for \"error_region\" in "
-                         "the trace or profile."
-                      << std::endl;
-            error_printed = true;
+            region_handle = regions[it_translation->second];
         }
     }
+    SCOREP_User_RegionEnter(region_handle.value);
+}
+
+void region_end(const std::string& region, const std::string& module,
+                const std::uintptr_t& identifier)
+{
+    const auto it_region = regions.find(identifier);
+    if (it_region != regions.end())
+    {
+        SCOREP_User_RegionEnd(it_region->second.value);
+    }
+    else
+    {
+        auto& region_name = make_region_name(module, region);
+        region_end_error_handling(region_name);
+    }
+}
+
+void region_end(const std::string& region, const std::string& module)
+{
+    auto& region_name = make_region_name(module, region);
+    const auto it_region = user_regions.find(region_name);
+    if (it_region != user_regions.end())
+    {
+        SCOREP_User_RegionEnd(it_region->second.value);
+    }
+    else
+    {
+        region_end_error_handling(region_name);
+    }
+}
+
+void region_end_error_handling(const std::string& region_name)
+{
+    static region_handle error_region;
+    static SCOREP_User_ParameterHandle scorep_param = SCOREP_USER_INVALID_PARAMETER;
+    static bool error_printed = false;
+
+    if (std::find(EXIT_REGION_WHITELIST.begin(), EXIT_REGION_WHITELIST.end(), region_name) !=
+        EXIT_REGION_WHITELIST.end())
+    {
+        return;
+    }
+
+    if (error_region.value == SCOREP_USER_INVALID_REGION)
+    {
+        SCOREP_User_RegionInit(&error_region.value, NULL, &SCOREP_User_LastFileHandle,
+                               "error_region", SCOREP_USER_REGION_TYPE_FUNCTION, "scorep.cpp", 0);
+        SCOREP_User_RegionSetGroup(error_region.value, "error");
+    }
+    SCOREP_User_RegionEnter(error_region.value);
+    SCOREP_User_ParameterString(&scorep_param, "leave-region", region_name.c_str());
+    SCOREP_User_RegionEnd(error_region.value);
+
+    if (!error_printed)
+    {
+        std::cerr << "SCOREP_BINDING_PYTHON ERROR: There was a region exit without an enter!\n"
+                  << "SCOREP_BINDING_PYTHON ERROR: For details look for \"error_region\" in "
+                     "the trace or profile."
+                  << std::endl;
+        error_printed = true;
+    }
 }
 
 void rewind_begin(std::string region_name, std::string file_name, std::uint64_t line_number)
@@ -136,15 +196,15 @@ void parameter_string(std::string name, std::string value)
 
 void oa_region_begin(std::string region_name, std::string file_name, std::uint64_t line_number)
 {
-    auto& handle = regions[region_name];
+    auto& handle = user_regions[region_name];
     SCOREP_User_OaPhaseBegin(&handle.value, &SCOREP_User_LastFileName, &SCOREP_User_LastFileHandle,
                              region_name.c_str(), SCOREP_USER_REGION_TYPE_FUNCTION,
                              file_name.c_str(), line_number);
 }
 
 void oa_region_end(std::string region_name)
 {
-    auto& handle = regions[region_name];
+    auto& handle = user_regions[region_name];
     SCOREP_User_OaPhaseEnd(handle.value);
 }
 

src/scorepy/events.hpp

@@ -1,13 +1,14 @@
 #pragma once
 
+#include <Python.h>
 #include <cstdint>
 #include <string>
 
 namespace scorepy
 {
 /// Combine the arguments into a region name
 /// Return value is a statically allocated string to avoid memory (re)allocations
-inline const std::string& make_region_name(const char* module_name, const char* name)
+inline const std::string& make_region_name(const std::string& module_name, const std::string& name)
 {
     static std::string region;
     region = module_name;
@@ -16,9 +17,17 @@ inline const std::string& make_region_name(const char* module_name, const char*
     return region;
 }
 
-void region_begin(const std::string& region_name, std::string module, std::string file_name,
-                  std::uint64_t line_number);
-void region_end(const std::string& region_name);
+void region_begin(const std::string& region, const std::string& module,
+                  const std::string& file_name, const std::uint64_t line_number,
+                  const std::uintptr_t& identifier);
+void region_begin(const std::string& region, const std::string& module,
+                  const std::string& file_name, const std::uint64_t line_number);
+
+void region_end(const std::string& region, const std::string& module,
+                const std::uintptr_t& identifier);
+void region_end(const std::string& region, const std::string& module);
+
+void region_end_error_handling(const std::string& region_name);
 
 void rewind_begin(std::string region_name, std::string file_name, std::uint64_t line_number);
 void rewind_end(std::string region_name, bool value);