Add CString class to avoid allocations

Author: Flamefire

src/scorepy/cInstrumenter.cpp

@@ -1,4 +1,5 @@
 #include "cInstrumenter.hpp"
+#include "cstring.h"
 #include "events.hpp"
 #include "pythonHelpers.hpp"
 #include <algorithm>
@@ -114,12 +115,9 @@ 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 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 CString name = PyUnicode_AsUTF8(code.co_name);
+        const CString module_name = get_module_name(frame);
+        if (name != "_unsetprofile" && !module_name.starts_with("scorep"))
         {
             const int line_number = code.co_firstlineno;
             const auto& region_name = make_region_name(module_name, name);
@@ -131,12 +129,9 @@ bool CInstrumenter::on_event(PyFrameObject& frame, int what, PyObject*)
     case PyTrace_RETURN:
     {
         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 CString name = PyUnicode_AsUTF8(code.co_name);
+        const CString module_name = get_module_name(frame);
+        if (name != "_unsetprofile" && !module_name.starts_with("scorep"))
         {
             const auto& region_name = make_region_name(module_name, name);
             region_end(region_name);

src/scorepy/cstring.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <cassert>
+#include <cstring>
+
+namespace scorepy
+{
+
+/// Thin wrapper around a C-String (NULL-terminated sequence of chars)
+class CString
+{
+    const char* s_;
+
+public:
+    constexpr CString(const char* s) : s_(s)
+    {
+        assert(s_);
+    }
+
+    constexpr const char* c_str() const
+    {
+        return s_;
+    }
+    /// Find the first occurrence of the character and return a pointer to it or NULL if not found
+    const char* find(char c) const
+    {
+        return std::strchr(s_, c);
+    }
+    template <size_t N>
+    bool starts_with(const char (&prefix)[N]) const
+    {
+        return std::strncmp(s_, prefix, N - 1u) == 0;
+    }
+
+    friend bool operator==(const CString& lhs, const CString& rhs)
+    {
+        return std::strcmp(lhs.s_, rhs.s_) == 0;
+    }
+    friend bool operator!=(const CString& lhs, const CString& rhs)
+    {
+        return !(lhs == rhs);
+    }
+};
+
+} // namespace scorepy

src/scorepy/events.cpp

@@ -26,7 +26,7 @@ constexpr region_handle uninitialised_region_handle = region_handle();
 static std::unordered_map<std::string, region_handle> 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,
+void region_begin(const std::string& region_name, const CString& module, const CString& file_name,
                   std::uint64_t line_number)
 {
     auto& region_handle = regions[region_name];
@@ -36,8 +36,17 @@ void region_begin(const std::string& region_name, std::string module, std::strin
         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());
+        // Extract main module name if module is like "mainmodule.submodule.subsubmodule"
+        const char* dot_pos = module.find('.');
+        if (dot_pos)
+        {
+            const std::string main_module(module.c_str(), dot_pos);
+            SCOREP_User_RegionSetGroup(region_handle.value, main_module.c_str());
+        }
+        else
+        {
+            SCOREP_User_RegionSetGroup(region_handle.value, module.c_str());
+        }
     }
     SCOREP_User_RegionEnter(region_handle.value);
 }

src/scorepy/events.hpp

@@ -1,22 +1,23 @@
 #pragma once
 
+#include "cstring.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 CString& module_name, const CString& name)
 {
     static std::string region;
-    region = module_name;
+    region = module_name.c_str();
     region += ":";
-    region += name;
+    region += name.c_str();
     return region;
 }
 
-void region_begin(const std::string& region_name, std::string module, std::string file_name,
+void region_begin(const std::string& region_name, const CString& module, const CString& file_name,
                   std::uint64_t line_number);
 void region_end(const std::string& region_name);
 

src/scorepy/pythonHelpers.cpp

@@ -3,29 +3,32 @@
 
 namespace scorepy
 {
-const char* get_module_name(const PyFrameObject& frame)
+CString get_module_name(const PyFrameObject& frame)
 {
     PyObject* module_name = PyDict_GetItemString(frame.f_globals, "__name__");
     if (module_name)
         return PyUnicode_AsUTF8(module_name);
 
     // this is a NUMPY special situation, see NEP-18, and Score-P issue #63
-    // TODO: Use string_view/C-String to avoid creating 2 std::strings
-    const char* filename = PyUnicode_AsUTF8(frame.f_code->co_filename);
-    if (filename && (std::string(filename) == "<__array_function__ internals>"))
+    const CString filename = PyUnicode_AsUTF8(frame.f_code->co_filename);
+    if (filename == "<__array_function__ internals>")
+    {
         return "numpy.__array_function__";
+    }
     else
+    {
         return "unkown";
+    }
 }
 
-std::string get_file_name(const PyFrameObject& frame)
+CString get_file_name(const PyFrameObject& frame)
 {
     PyObject* filename = frame.f_code->co_filename;
     if (filename == Py_None)
     {
         return "None";
     }
-    char actual_path[PATH_MAX];
+    static char actual_path[PATH_MAX];
     const char* full_file_name = realpath(PyUnicode_AsUTF8(filename), actual_path);
     return full_file_name ? full_file_name : "ErrorPath";
 }

src/scorepy/pythonHelpers.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "cstring.h"
 #include <Python.h>
 #include <frameobject.h>
 #include <string>
@@ -73,9 +74,10 @@ auto cast_to_PyFunc(TFunc* func) -> detail::ReplaceArgsToPyObject_t<TFunc>*
 
 /// Return the module name the frame belongs to.
 /// The pointer is valid for the lifetime of the frame
-const char* get_module_name(const PyFrameObject& frame);
+CString get_module_name(const PyFrameObject& frame);
 /// Return the file name the frame belongs to
-std::string get_file_name(const PyFrameObject& frame);
+/// The returned CString is valid until the next call to this function
+CString get_file_name(const PyFrameObject& frame);
 
 // Implementation details
 namespace detail