Compat python 2.7 (#137)

* Add cTrace and cProfile for Python2
* Improve performance of the backend, by avoiding `str::string` and moving to std::string_view (c++17)
* Test if the region is known also for Trace and Profile instrumenter

Author: AndreasGocht

scorep/_instrumenters/dummy.py

@@ -23,9 +23,15 @@ def run(self, cmd, globals=None, locals=None):
             locals = {}
         exec(cmd, globals, locals)
 
+    def try_region_begin(self, code_object):
+        pass
+
     def region_begin(self, module_name, function_name, file_name, line_number, code_object=None):
         pass
 
+    def try_region_end(self, code_object):
+        pass
+
     def region_end(self, module_name, function_name, code_object=None):
         pass
 

scorep/_instrumenters/scorep_instrumenter.py

@@ -56,11 +56,19 @@ def run(self, cmd, globals=None, locals=None):
         finally:
             self.unregister()
 
+    def try_region_begin(self, code_object):
+        """Tries to record a region begin event. Retruns True on success"""
+        return scorep._bindings.try_region_begin(code_object)
+
     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, code_object)
 
+    def try_region_end(self, code_object):
+        """Tries to record a region end event. Retruns True on success"""
+        return scorep._bindings.try_region_end(code_object)
+
     def region_end(self, module_name, function_name, code_object=None):
         """Record a region end event"""
         scorep._bindings.region_end(module_name, function_name, code_object)

scorep/_instrumenters/scorep_profile.py

@@ -1,7 +1,7 @@
 __all__ = ['ScorepProfile']
 
 import sys
-from scorep._instrumenters.utils import get_module_name, get_file_name
+from scorep._instrumenters.utils import get_module_name
 from scorep._instrumenters.scorep_instrumenter import ScorepInstrumenter
 import scorep._bindings
 
@@ -38,14 +38,17 @@ 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, code)
+            if not scorep._bindings.try_region_begin(code):
+                if not code.co_name == "_unsetprofile":
+                    modulename = get_module_name(frame)
+                    if not modulename[:6] == "scorep":
+                        file_name = code.co_filename
+                        line_number = code.co_firstlineno
+                        scorep._bindings.region_begin(modulename, code.co_name, 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, code)
+            if not scorep._bindings.try_region_end(code):
+                if not code.co_name == "_unsetprofile":
+                    modulename = get_module_name(frame)
+                    if not modulename[:6] == "scorep":
+                        scorep._bindings.region_end(modulename, code.co_name, code)

scorep/_instrumenters/scorep_trace.py

@@ -1,7 +1,7 @@
 __all__ = ['ScorepTrace']
 
 import sys
-from scorep._instrumenters.utils import get_module_name, get_file_name
+from scorep._instrumenters.utils import get_module_name
 from scorep._instrumenters.scorep_instrumenter import ScorepInstrumenter
 import scorep._bindings
 
@@ -36,17 +36,22 @@ def _globaltrace(self, frame, why, arg):
         """
         if why == 'call':
             code = frame.f_code
-            modulename = get_module_name(frame)
-            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, code)
-                return self._localtrace
+            if not scorep._bindings.try_region_begin(code):
+                if not code.co_name == "_unsetprofile":
+                    modulename = get_module_name(frame)
+                    if not modulename[:6] == "scorep":
+                        full_file_name = code.co_filename
+                        line_number = code.co_firstlineno
+                        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, code)
+            if not scorep._bindings.try_region_end(code):
+                if not code.co_name == "_unsetprofile":
+                    modulename = get_module_name(frame)
+                    if not modulename[:6] == "scorep":
+                        scorep._bindings.region_end(modulename, code.co_name, code)
         return self._localtrace

scorep/instrumenter.py

@@ -1,7 +1,6 @@
 import inspect
 import os
 import platform
-import sys
 import functools
 
 global_instrumenter = None
@@ -11,7 +10,7 @@ def has_c_instrumenter():
     """Return true if the C instrumenter(s) are available"""
     # We are using the UTF-8 string features from Python 3
     # The C Instrumenter functions are not available on PyPy
-    return sys.version_info.major >= 3 and platform.python_implementation() != 'PyPy'
+    return platform.python_implementation() != 'PyPy'
 
 
 def get_instrumenter(enable_instrumenter=False,

scorep/user.py

@@ -88,19 +88,14 @@ def __enter__(self):
                     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:
-                    full_file_name = "None"
-
-                scorep.instrumenter.get_instrumenter().region_begin(
-                    self.module_name, self.region_name, full_file_name, line_number, self.code_obj)
+                if not scorep.instrumenter.get_instrumenter().try_region_begin(self.code_obj):
+                    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
+                    scorep.instrumenter.get_instrumenter().region_begin(
+                        self.module_name, self.region_name, 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
@@ -121,8 +116,8 @@ def __exit__(self, exc_type, exc_value, traceback):
                 self.module_name, self.region_name)
         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)
+            if not scorep.instrumenter.get_instrumenter().try_region_end(self.code_obj):
+                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

setup.py

@@ -53,7 +53,7 @@
         "scorep._bindings",
         include_dirs=include,
         define_macros=define_macros,
-        extra_compile_args=["-std=c++11"],
+        extra_compile_args=["-std=c++17"],
         sources=sources,
     )
 )

src/classes.cpp

@@ -94,8 +94,8 @@ extern "C"
         const char* event;
         PyObject* arg;
 
-        if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!sO", const_cast<char**>(kwlist),
-                                         &PyFrame_Type, &frame, &event, &arg))
+        if (!PyArg_ParseTupleAndKeywords(args, kwds, "OsO", const_cast<char**>(kwlist), &frame,
+                                         &event, &arg))
         {
             return nullptr;
         }

src/methods.cpp

@@ -28,58 +28,112 @@ extern "C"
         Py_RETURN_NONE;
     }
 
+    static PyObject* try_region_begin(PyObject* self, PyObject* args)
+    {
+        PyObject* identifier = nullptr;
+        if (!PyArg_ParseTuple(args, "O", &identifier))
+        {
+            return NULL;
+        }
+
+        bool success = scorepy::try_region_begin(reinterpret_cast<PyCodeObject*>(identifier));
+        if (success)
+        {
+            Py_RETURN_TRUE;
+        }
+        else
+        {
+            Py_RETURN_FALSE;
+        }
+    }
+
     /** This code is not thread save. However, this does not matter as the python GIL is not
      * released.
      */
     static PyObject* region_begin(PyObject* self, PyObject* args)
     {
-        const char* module;
-        const char* function_name;
-        const char* file_name;
+        const char* module_cstr;
+        const char* function_name_cstr;
+        const char* file_name_cstr;
+        Py_ssize_t module_len;
+        Py_ssize_t function_name_len;
+        Py_ssize_t file_name_len;
+
         PyObject* identifier = nullptr;
         std::uint64_t line_number = 0;
 
-        if (!PyArg_ParseTuple(args, "sssKO", &module, &function_name, &file_name, &line_number,
+        if (!PyArg_ParseTuple(args, "s#s#s#KO", &module_cstr, &module_len, &function_name_cstr,
+                              &function_name_len, &file_name_cstr, &file_name_len, &line_number,
                               &identifier))
         {
             return NULL;
         }
 
+        std::string_view module(module_cstr, module_len);
+        std::string_view function_name(function_name_cstr, function_name_len);
+        std::string_view file_name(file_name_cstr, file_name_len);
+
+        std::string file_name_abs = scorepy::abspath(file_name);
+
         if (identifier == nullptr or identifier == Py_None)
         {
-            scorepy::region_begin(function_name, module, file_name, line_number);
+            scorepy::region_begin(function_name, module, file_name_abs, line_number);
         }
         else
         {
-            scorepy::region_begin(function_name, module, file_name, line_number,
-                                  reinterpret_cast<std::uintptr_t>(identifier));
+            scorepy::region_begin(function_name, module, file_name_abs, line_number,
+                                  reinterpret_cast<PyCodeObject*>(identifier));
         }
 
         Py_RETURN_NONE;
     }
 
+    static PyObject* try_region_end(PyObject* self, PyObject* args)
+    {
+        PyObject* identifier = nullptr;
+        if (!PyArg_ParseTuple(args, "O", &identifier))
+        {
+            return NULL;
+        }
+
+        bool success = scorepy::try_region_end(reinterpret_cast<PyCodeObject*>(identifier));
+        if (success)
+        {
+            Py_RETURN_TRUE;
+        }
+        else
+        {
+            Py_RETURN_FALSE;
+        }
+    }
+
     /** This code is not thread save. However, this does not matter as the python GIL is not
      * released.
      */
     static PyObject* region_end(PyObject* self, PyObject* args)
     {
-        const char* module;
-        const char* function_name;
+        const char* module_cstr;
+        const char* function_name_cstr;
+        Py_ssize_t module_len;
+        Py_ssize_t function_name_len;
         PyObject* identifier = nullptr;
 
-        if (!PyArg_ParseTuple(args, "ssO", &module, &function_name, &identifier))
+        if (!PyArg_ParseTuple(args, "s#s#O", &module_cstr, &module_len, &function_name_cstr,
+                              &function_name_len, &identifier))
         {
             return NULL;
         }
 
+        std::string_view module(module_cstr, module_len);
+        std::string_view function_name(function_name_cstr, function_name_len);
+
         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));
+            scorepy::region_end(function_name, module, reinterpret_cast<PyCodeObject*>(identifier));
         }
 
         Py_RETURN_NONE;
@@ -182,7 +236,11 @@ extern "C"
 
     static PyMethodDef ScorePMethods[] = {
         { "region_begin", region_begin, METH_VARARGS, "enter a region." },
+        { "try_region_begin", try_region_begin, METH_VARARGS,
+          "Tries to begin a region, returns True on Sucess." },
         { "region_end", region_end, METH_VARARGS, "exit a region." },
+        { "try_region_end", try_region_end, METH_VARARGS,
+          "Tries to end a region, returns True on Sucess." },
         { "rewind_begin", rewind_begin, METH_VARARGS, "rewind begin." },
         { "rewind_end", rewind_end, METH_VARARGS, "rewind end." },
         { "enable_recording", enable_recording, METH_VARARGS, "disable scorep recording." },

src/scorep_bindings.cpp

@@ -1,11 +1,24 @@
+#include <Python.h>
+
+#include <iostream>
+
 #include "classes.hpp"
 #include "methods.hpp"
-#include <Python.h>
 
 #if PY_VERSION_HEX < 0x03000000
 PyMODINIT_FUNC init_bindings(void)
 {
-    (void)Py_InitModule("_bindings", scorepy::getMethodTable());
+    PyObject* m;
+#if SCOREPY_ENABLE_CINSTRUMENTER
+    static PyTypeObject ctracerType = scorepy::getCInstrumenterType();
+    if (PyType_Ready(&ctracerType) < 0)
+        return;
+#endif
+    m = Py_InitModule("_bindings", scorepy::getMethodTable());
+#if SCOREPY_ENABLE_CINSTRUMENTER
+    Py_INCREF(&ctracerType);
+    PyModule_AddObject(m, "CInstrumenter", (PyObject*)&ctracerType);
+#endif
 }
 #else /*python 3*/
 static struct PyModuleDef scorepmodule = { PyModuleDef_HEAD_INIT, "_bindings", /* name of module */