Refactor to match coding style

Flamefire · Flamefire · commit 18ea7fcba77b · 2020-06-11T16:42:04.000+02:00
Replace camelCase by snake_case
diff --git a/scorep/_instrumenters/scorep_cProfile.py b/scorep/_instrumenters/scorep_cProfile.py
@@ -4,7 +4,7 @@
 
 class ScorepCProfile(scorep._bindings.CInstrumenter, ScorepInstrumenter):
     def __init__(self, enable_instrumenter):
-        scorep._bindings.CInstrumenter.__init__(self, tracingOrProfiling=False)
+        scorep._bindings.CInstrumenter.__init__(self, tracing_or_profiling=False)
         ScorepInstrumenter.__init__(self, enable_instrumenter)
 
     def _enable_instrumenter(self):
diff --git a/scorep/_instrumenters/scorep_cTrace.py b/scorep/_instrumenters/scorep_cTrace.py
@@ -4,7 +4,7 @@
 
 class ScorepCTrace(scorep._bindings.CInstrumenter, ScorepInstrumenter):
     def __init__(self, enable_instrumenter):
-        scorep._bindings.CInstrumenter.__init__(self, tracingOrProfiling=True)
+        scorep._bindings.CInstrumenter.__init__(self, tracing_or_profiling=True)
         ScorepInstrumenter.__init__(self, enable_instrumenter)
 
     def _enable_instrumenter(self):
diff --git a/src/classes.cpp b/src/classes.cpp
@@ -26,20 +26,20 @@ extern "C"
 
     static int CInstrumenter_init(scorepy::CInstrumenter* self, PyObject* args, PyObject* kwds)
     {
-        static const char* kwlist[] = { "tracingOrProfiling", nullptr };
-        int tracingOrProfiling;
+        static const char* kwlist[] = { "tracing_or_profiling", nullptr };
+        int tracing_or_profiling;
 
         if (!PyArg_ParseTupleAndKeywords(args, kwds, "p", const_cast<char**>(kwlist),
-                                         &tracingOrProfiling))
+                                         &tracing_or_profiling))
             return -1;
 
-        self->init(tracingOrProfiling != 0);
+        self->init(tracing_or_profiling != 0);
         return 0;
     }
 
     static PyObject* CInstrumenter_get_tracingOrProfiling(scorepy::CInstrumenter* self, void*)
     {
-        scorepy::PyRefObject result(self->tracingOrProfiling ? Py_True : Py_False,
+        scorepy::PyRefObject result(self->tracing_or_profiling ? Py_True : Py_False,
                                     scorepy::retain_object);
         return result;
     }
@@ -78,14 +78,14 @@ namespace scorepy
 PyTypeObject& getCInstrumenterType()
 {
     static PyMethodDef methods[] = {
-        { "_enable_instrumenter", scorepy::castToPyFunc(CInstrumenter_enable_instrumenter),
+        { "_enable_instrumenter", scorepy::cast_to_PyFunc(CInstrumenter_enable_instrumenter),
           METH_NOARGS, "Enable the instrumenter" },
-        { "_disable_instrumenter", scorepy::castToPyFunc(CInstrumenter_disable_instrumenter),
+        { "_disable_instrumenter", scorepy::cast_to_PyFunc(CInstrumenter_disable_instrumenter),
           METH_NOARGS, "Disable the instrumenter" },
         { nullptr } /* Sentinel */
     };
     static PyGetSetDef getseters[] = {
-        { "tracingOrProfiling", scorepy::castToPyFunc(CInstrumenter_get_tracingOrProfiling),
+        { "tracing_or_profiling", scorepy::cast_to_PyFunc(CInstrumenter_get_tracingOrProfiling),
           nullptr, "Return whether the trace (True) or profile (False) instrumentation is used",
           nullptr },
         { nullptr } /* Sentinel */
@@ -97,9 +97,9 @@ PyTypeObject& getCInstrumenterType()
         sizeof(CInstrumenter),            /* tp_basicsize */
     };
     type.tp_new = call_object_new;
-    type.tp_init = scorepy::castToPyFunc(CInstrumenter_init);
+    type.tp_init = scorepy::cast_to_PyFunc(CInstrumenter_init);
     type.tp_methods = methods;
-    type.tp_call = scorepy::castToPyFunc(CInstrumenter_call);
+    type.tp_call = scorepy::cast_to_PyFunc(CInstrumenter_call);
     type.tp_getset = getseters;
     type.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE;
     type.tp_doc = "Class for the C instrumenter interface of Score-P";
diff --git a/src/scorepy/cInstrumenter.cpp b/src/scorepy/cInstrumenter.cpp
@@ -19,87 +19,88 @@ static const std::string& make_region_name(const char* moduleName, const char* n
 void CInstrumenter::enable_instrumenter()
 {
     const auto callback = [](PyObject* obj, PyFrameObject* frame, int what, PyObject* arg) -> int {
-        return fromPyObject(obj)->onEvent(*frame, what, arg) ? 0 : -1;
+        return from_PyObject(obj)->on_event(*frame, what, arg) ? 0 : -1;
     };
-    if (tracingOrProfiling)
+    if (tracing_or_profiling)
     {
-        PyEval_SetTrace(callback, toPyObject());
+        PyEval_SetTrace(callback, to_PyObject());
     }
     else
     {
-        PyEval_SetProfile(callback, toPyObject());
+        PyEval_SetProfile(callback, to_PyObject());
     }
 }
 
 void CInstrumenter::disable_instrumenter()
 {
-    if (tracingOrProfiling)
+    if (tracing_or_profiling)
         PyEval_SetTrace(nullptr, nullptr);
     else
         PyEval_SetProfile(nullptr, nullptr);
 }
 
 /// Mapping of PyTrace_* to it's string representations
 /// List taken from CPythons sysmodule.c
-static const std::array<std::string, 8> whatStrings = { "call",     "exception", "line",
-                                                        "return",   "c_call",    "c_exception",
-                                                        "c_return", "opcode" };
+static const std::array<std::string, 8> WHAT_STRINGS = { "call",     "exception", "line",
+                                                         "return",   "c_call",    "c_exception",
+                                                         "c_return", "opcode" };
 
 // Required because:  `sys.getprofile()` returns the user object (2nd arg to PyEval_SetTrace)
 // So `sys.setprofile(sys.getprofile())` will not round-trip as it will try to call the
 // 2nd arg through pythons dispatch function. Hence make the object callable.
 // See https://nedbatchelder.com/text/trace-function.html for details
-PyObject* CInstrumenter::operator()(PyFrameObject& frame, const char* what, PyObject* arg)
+PyObject* CInstrumenter::operator()(PyFrameObject& frame, const char* what_string, PyObject* arg)
 {
-    const auto itWhat = std::find(whatStrings.begin(), whatStrings.end(), what);
-    const int iWhat = itWhat == whatStrings.end() ? -1 : std::distance(whatStrings.begin(), itWhat);
+    const auto it_what = std::find(WHAT_STRINGS.begin(), WHAT_STRINGS.end(), what_string);
+    const int what =
+        it_what == WHAT_STRINGS.end() ? -1 : std::distance(WHAT_STRINGS.begin(), it_what);
     // To speed up further event processing install this class directly as the handler
     // But we might be inside a `sys.settrace` call where the user wanted to set another function
     // which would then be overwritten here. Hence use the CALL event which avoids the problem
-    if (iWhat == PyTrace_CALL)
+    if (what == PyTrace_CALL)
         enable_instrumenter();
-    if (onEvent(frame, iWhat, arg))
+    if (on_event(frame, what, arg))
     {
-        Py_INCREF(toPyObject());
-        return toPyObject();
+        Py_INCREF(to_PyObject());
+        return to_PyObject();
     }
     else
         return nullptr;
 }
 
-bool CInstrumenter::onEvent(PyFrameObject& frame, int what, PyObject*)
+bool CInstrumenter::on_event(PyFrameObject& frame, int what, PyObject*)
 {
     switch (what)
     {
     case PyTrace_CALL:
     {
         const PyCodeObject& code = *frame.f_code;
         const char* name = PyUnicode_AsUTF8(code.co_name);
-        const char* moduleName = get_module_name(frame);
+        const char* module_name = get_module_name(frame);
         assert(name);
-        assert(moduleName);
+        assert(module_name);
         // TODO: Use string_view/CString comparison?
-        if (std::string(name) != "_unsetprofile" && std::string(moduleName, 0, 6) != "scorep")
+        if (std::string(name) != "_unsetprofile" && std::string(module_name, 0, 6) != "scorep")
         {
-            const int lineNumber = code.co_firstlineno;
-            const auto& regionName = make_region_name(moduleName, name);
-            const auto fileName = get_file_name(frame);
-            region_begin(regionName, moduleName, fileName, lineNumber);
+            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);
         }
         break;
     }
     case PyTrace_RETURN:
     {
         const PyCodeObject& code = *frame.f_code;
         const char* name = PyUnicode_AsUTF8(code.co_name);
-        const char* moduleName = get_module_name(frame);
+        const char* module_name = get_module_name(frame);
         assert(name);
-        assert(moduleName);
+        assert(module_name);
         // TODO: Use string_view/CString comparison?
-        if (std::string(name) != "_unsetprofile" && std::string(moduleName, 0, 6) != "scorep")
+        if (std::string(name) != "_unsetprofile" && std::string(module_name, 0, 6) != "scorep")
         {
-            const auto& regionName = make_region_name(moduleName, name);
-            region_end(regionName);
+            const auto& region_name = make_region_name(module_name, name);
+            region_end(region_name);
         }
         break;
     }
diff --git a/src/scorepy/cInstrumenter.hpp b/src/scorepy/cInstrumenter.hpp
@@ -8,11 +8,11 @@ namespace scorepy
 struct CInstrumenter
 {
     PyObject_HEAD;
-    bool tracingOrProfiling;
+    bool tracing_or_profiling;
 
-    void init(bool tracingOrProfiling)
+    void init(bool tracing_or_profiling)
     {
-        this->tracingOrProfiling = tracingOrProfiling;
+        this->tracing_or_profiling = tracing_or_profiling;
     }
     void enable_instrumenter();
     void disable_instrumenter();
@@ -21,18 +21,18 @@ struct CInstrumenter
     PyObject* operator()(PyFrameObject& frame, const char* what, PyObject* arg);
 
     /// These casts are valid as long as `PyObject_HEAD` is the first entry in this struct
-    PyObject* toPyObject()
+    PyObject* to_PyObject()
     {
         return reinterpret_cast<PyObject*>(this);
     }
-    static CInstrumenter* fromPyObject(PyObject* o)
+    static CInstrumenter* from_PyObject(PyObject* o)
     {
         return reinterpret_cast<CInstrumenter*>(o);
     }
 
 private:
     /// Callback for Python trace/profile events. Return true for success
-    bool onEvent(PyFrameObject& frame, int what, PyObject* arg);
+    bool on_event(PyFrameObject& frame, int what, PyObject* arg);
 };
 
 } // namespace scorepy
diff --git a/src/scorepy/pythonHelpers.cpp b/src/scorepy/pythonHelpers.cpp
@@ -5,9 +5,9 @@ namespace scorepy
 {
 const char* get_module_name(const PyFrameObject& frame)
 {
-    PyObject* moduleName = PyDict_GetItemString(frame.f_globals, "__name__");
-    if (moduleName)
-        return PyUnicode_AsUTF8(moduleName);
+    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
@@ -20,11 +20,11 @@ const char* get_module_name(const PyFrameObject& frame)
 
 std::string get_file_name(const PyFrameObject& frame)
 {
-    PyObject* fileName = frame.f_code->co_filename;
-    if (fileName == Py_None)
+    PyObject* filename = frame.f_code->co_filename;
+    if (filename == Py_None)
         return "None";
-    char actualpath[PATH_MAX];
-    const char* full_file_name = realpath(PyUnicode_AsUTF8(fileName), actualpath);
+    char actual_path[PATH_MAX];
+    const char* full_file_name = realpath(PyUnicode_AsUTF8(filename), actual_path);
     return full_file_name ? full_file_name : "ErrorPath";
 }
 } // namespace scorepy
diff --git a/src/scorepy/pythonHelpers.hpp b/src/scorepy/pythonHelpers.hpp
@@ -66,7 +66,7 @@ namespace detail
 /// Cast a function pointer to a python-bindings compatible function pointer
 /// Replaces all Foo* by PyObject* for all types Foo that are PyObject compatible
 template <typename TFunc>
-auto castToPyFunc(TFunc* func) -> detail::ReplaceArgsToPyObject_t<TFunc>*
+auto cast_to_PyFunc(TFunc* func) -> detail::ReplaceArgsToPyObject_t<TFunc>*
 {
     return reinterpret_cast<detail::ReplaceArgsToPyObject_t<TFunc>*>(func);
 }
@@ -99,7 +99,7 @@ namespace detail
     };
 
     template <class T>
-    struct IsPyObject<T, void_t<decltype(std::declval<T>().toPyObject())>> : std::true_type
+    struct IsPyObject<T, void_t<decltype(std::declval<T>().to_PyObject())>> : std::true_type
     {
     };
 

Original file line number	Diff line number	Diff line change
`@@ -19,87 +19,88 @@ static const std::string& make_region_name(const char* moduleName, const char* n`
`19`	`19`	`void CInstrumenter::enable_instrumenter()`
`20`	`20`	`{`
`21`	`21`	`const auto callback = [](PyObject* obj, PyFrameObject* frame, int what, PyObject* arg) -> int {`
`22`		`- return fromPyObject(obj)->onEvent(*frame, what, arg) ? 0 : -1;`
	`22`	`+ return from_PyObject(obj)->on_event(*frame, what, arg) ? 0 : -1;`
`23`	`23`	`};`
`24`		`- if (tracingOrProfiling)`
	`24`	`+ if (tracing_or_profiling)`
`25`	`25`	`{`
`26`		`- PyEval_SetTrace(callback, toPyObject());`
	`26`	`+ PyEval_SetTrace(callback, to_PyObject());`
`27`	`27`	`}`
`28`	`28`	`else`
`29`	`29`	`{`
`30`		`- PyEval_SetProfile(callback, toPyObject());`
	`30`	`+ PyEval_SetProfile(callback, to_PyObject());`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`void CInstrumenter::disable_instrumenter()`
`35`	`35`	`{`
`36`		`- if (tracingOrProfiling)`
	`36`	`+ if (tracing_or_profiling)`
`37`	`37`	`PyEval_SetTrace(nullptr, nullptr);`
`38`	`38`	`else`
`39`	`39`	`PyEval_SetProfile(nullptr, nullptr);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`/// Mapping of PyTrace_* to it's string representations`
`43`	`43`	`/// List taken from CPythons sysmodule.c`
`44`		`-static const std::array<std::string, 8> whatStrings = { "call", "exception", "line",`
`45`		`- "return", "c_call", "c_exception",`
`46`		`- "c_return", "opcode" };`
	`44`	`+static const std::array<std::string, 8> WHAT_STRINGS = { "call", "exception", "line",`
	`45`	`+ "return", "c_call", "c_exception",`
	`46`	`+ "c_return", "opcode" };`
`47`	`47`
`48`	`48`	// Required because: `sys.getprofile()` returns the user object (2nd arg to PyEval_SetTrace)
`49`	`49`	// So `sys.setprofile(sys.getprofile())` will not round-trip as it will try to call the
`50`	`50`	`// 2nd arg through pythons dispatch function. Hence make the object callable.`
`51`	`51`	`// See https://nedbatchelder.com/text/trace-function.html for details`
`52`		`-PyObject* CInstrumenter::operator()(PyFrameObject& frame, const char* what, PyObject* arg)`
	`52`	`+PyObject* CInstrumenter::operator()(PyFrameObject& frame, const char* what_string, PyObject* arg)`
`53`	`53`	`{`
`54`		`- const auto itWhat = std::find(whatStrings.begin(), whatStrings.end(), what);`
`55`		`- const int iWhat = itWhat == whatStrings.end() ? -1 : std::distance(whatStrings.begin(), itWhat);`
	`54`	`+ const auto it_what = std::find(WHAT_STRINGS.begin(), WHAT_STRINGS.end(), what_string);`
	`55`	`+ const int what =`
	`56`	`+ it_what == WHAT_STRINGS.end() ? -1 : std::distance(WHAT_STRINGS.begin(), it_what);`
`56`	`57`	`// To speed up further event processing install this class directly as the handler`
`57`	`58`	// But we might be inside a `sys.settrace` call where the user wanted to set another function
`58`	`59`	`// which would then be overwritten here. Hence use the CALL event which avoids the problem`
`59`		`- if (iWhat == PyTrace_CALL)`
	`60`	`+ if (what == PyTrace_CALL)`
`60`	`61`	`enable_instrumenter();`
`61`		`- if (onEvent(frame, iWhat, arg))`
	`62`	`+ if (on_event(frame, what, arg))`
`62`	`63`	`{`
`63`		`- Py_INCREF(toPyObject());`
`64`		`- return toPyObject();`
	`64`	`+ Py_INCREF(to_PyObject());`
	`65`	`+ return to_PyObject();`
`65`	`66`	`}`
`66`	`67`	`else`
`67`	`68`	`return nullptr;`
`68`	`69`	`}`
`69`	`70`
`70`		`-bool CInstrumenter::onEvent(PyFrameObject& frame, int what, PyObject*)`
	`71`	`+bool CInstrumenter::on_event(PyFrameObject& frame, int what, PyObject*)`
`71`	`72`	`{`
`72`	`73`	`switch (what)`
`73`	`74`	`{`
`74`	`75`	`case PyTrace_CALL:`
`75`	`76`	`{`
`76`	`77`	`const PyCodeObject& code = *frame.f_code;`
`77`	`78`	`const char* name = PyUnicode_AsUTF8(code.co_name);`
`78`		`- const char* moduleName = get_module_name(frame);`
	`79`	`+ const char* module_name = get_module_name(frame);`
`79`	`80`	`assert(name);`
`80`		`- assert(moduleName);`
	`81`	`+ assert(module_name);`
`81`	`82`	`// TODO: Use string_view/CString comparison?`
`82`		`- if (std::string(name) != "_unsetprofile" && std::string(moduleName, 0, 6) != "scorep")`
	`83`	`+ if (std::string(name) != "_unsetprofile" && std::string(module_name, 0, 6) != "scorep")`
`83`	`84`	`{`
`84`		`- const int lineNumber = code.co_firstlineno;`
`85`		`- const auto& regionName = make_region_name(moduleName, name);`
`86`		`- const auto fileName = get_file_name(frame);`
`87`		`- region_begin(regionName, moduleName, fileName, lineNumber);`
	`85`	`+ const int line_number = code.co_firstlineno;`
	`86`	`+ const auto& region_name = make_region_name(module_name, name);`
	`87`	`+ const auto file_name = get_file_name(frame);`
	`88`	`+ region_begin(region_name, module_name, file_name, line_number);`
`88`	`89`	`}`
`89`	`90`	`break;`
`90`	`91`	`}`
`91`	`92`	`case PyTrace_RETURN:`
`92`	`93`	`{`
`93`	`94`	`const PyCodeObject& code = *frame.f_code;`
`94`	`95`	`const char* name = PyUnicode_AsUTF8(code.co_name);`
`95`		`- const char* moduleName = get_module_name(frame);`
	`96`	`+ const char* module_name = get_module_name(frame);`
`96`	`97`	`assert(name);`
`97`		`- assert(moduleName);`
	`98`	`+ assert(module_name);`
`98`	`99`	`// TODO: Use string_view/CString comparison?`
`99`		`- if (std::string(name) != "_unsetprofile" && std::string(moduleName, 0, 6) != "scorep")`
	`100`	`+ if (std::string(name) != "_unsetprofile" && std::string(module_name, 0, 6) != "scorep")`
`100`	`101`	`{`
`101`		`- const auto& regionName = make_region_name(moduleName, name);`
`102`		`- region_end(regionName);`
	`102`	`+ const auto& region_name = make_region_name(module_name, name);`
	`103`	`+ region_end(region_name);`
`103`	`104`	`}`
`104`	`105`	`break;`
`105`	`106`	`}`
Original file line number	Diff line number	Diff line change
`@@ -8,11 +8,11 @@ namespace scorepy`
`8`	`8`	`struct CInstrumenter`
`9`	`9`	`{`
`10`	`10`	`PyObject_HEAD;`
`11`		`- bool tracingOrProfiling;`
	`11`	`+ bool tracing_or_profiling;`
`12`	`12`
`13`		`- void init(bool tracingOrProfiling)`
	`13`	`+ void init(bool tracing_or_profiling)`
`14`	`14`	`{`
`15`		`- this->tracingOrProfiling = tracingOrProfiling;`
	`15`	`+ this->tracing_or_profiling = tracing_or_profiling;`
`16`	`16`	`}`
`17`	`17`	`void enable_instrumenter();`
`18`	`18`	`void disable_instrumenter();`
`@@ -21,18 +21,18 @@ struct CInstrumenter`
`21`	`21`	`PyObject* operator()(PyFrameObject& frame, const char* what, PyObject* arg);`
`22`	`22`
`23`	`23`	/// These casts are valid as long as `PyObject_HEAD` is the first entry in this struct
`24`		`- PyObject* toPyObject()`
	`24`	`+ PyObject* to_PyObject()`
`25`	`25`	`{`
`26`	`26`	`return reinterpret_cast<PyObject*>(this);`
`27`	`27`	`}`
`28`		`- static CInstrumenter* fromPyObject(PyObject* o)`
	`28`	`+ static CInstrumenter* from_PyObject(PyObject* o)`
`29`	`29`	`{`
`30`	`30`	`return reinterpret_cast<CInstrumenter*>(o);`
`31`	`31`	`}`
`32`	`32`
`33`	`33`	`private:`
`34`	`34`	`/// Callback for Python trace/profile events. Return true for success`
`35`		`- bool onEvent(PyFrameObject& frame, int what, PyObject* arg);`
	`35`	`+ bool on_event(PyFrameObject& frame, int what, PyObject* arg);`
`36`	`36`	`};`
`37`	`37`
`38`	`38`	`} // namespace scorepy`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ namespace detail`
`66`	`66`	`/// Cast a function pointer to a python-bindings compatible function pointer`
`67`	`67`	`/// Replaces all Foo* by PyObject* for all types Foo that are PyObject compatible`
`68`	`68`	`template <typename TFunc>`
`69`		`-auto castToPyFunc(TFunc* func) -> detail::ReplaceArgsToPyObject_t<TFunc>*`
	`69`	`+auto cast_to_PyFunc(TFunc* func) -> detail::ReplaceArgsToPyObject_t<TFunc>*`
`70`	`70`	`{`
`71`	`71`	`return reinterpret_cast<detail::ReplaceArgsToPyObject_t<TFunc>*>(func);`
`72`	`72`	`}`
`@@ -99,7 +99,7 @@ namespace detail`
`99`	`99`	`};`
`100`	`100`
`101`	`101`	`template <class T>`
`102`		`- struct IsPyObject<T, void_t<decltype(std::declval<T>().toPyObject())>> : std::true_type`
	`102`	`+ struct IsPyObject<T, void_t<decltype(std::declval<T>().to_PyObject())>> : std::true_type`
`103`	`103`	`{`
`104`	`104`	`};`
`105`	`105`