Profiling tests for Hagen

cmake/megamol_options.cmake

@@ -45,6 +45,11 @@ if(ENABLE_CUDA)
   set(CMAKE_CUDA_ARCHITECTURES FALSE)
 endif()
 
+option(ENABLE_PROFILING "Enable profiling code" OFF)
+if (ENABLE_PROFILING)
+  add_compile_definitions(PROFILING)
+endif()
+
 # CUE
 if (WIN32)
   option(ENABLE_CUESDK "Enable CUE for highlighting hotkeys on Corsair Keyboards" OFF)

core/include/mmcore/Call.h

@@ -12,10 +12,14 @@
 #endif /* (defined(_MSC_VER) && (_MSC_VER > 1000)) */
 
 #include <memory>
+#include <utility>
+#include "CallCapabilities.h"
+#ifdef PROFILING
+#include "CallProfiling.h"
+#endif
 
 #include "mmcore/api/MegaMolCore.std.h"
 
-
 namespace megamol {
 namespace core {
 
@@ -96,6 +100,14 @@ namespace core {
             return this->className;
         }
 
+        const CallCapabilities& GetCapabilities() const {
+            return caps;
+        }
+
+#ifdef PROFILING
+        const CallProfiling& GetProfiling() const { return profiling; }
+#endif
+
     private:
 
         /** The callee connected by this call */
@@ -109,6 +121,18 @@ namespace core {
         /** The function id mapping */
         unsigned int *funcMap;
 
+#ifdef PROFILING
+        friend class MegaMolGraph;
+        friend class PerformanceQueryManager;
+
+        CallProfiling profiling;
+
+        void setProfilingInfo(std::vector<std::string> names) {
+            profiling.setProfilingInfo(std::move(names), this);
+        }
+#endif // PROFILING
+    protected:
+        CallCapabilities caps;
     };
 
 

core/include/mmcore/CallCapabilities.h

@@ -0,0 +1,44 @@
+/*
+ * Call.h
+ *
+ * Copyright (C) 2021 by Universitaet Stuttgart (VIS). 
+ * Alle Rechte vorbehalten.
+ */
+
+#pragma once
+#include <cstdint>
+
+namespace megamol {
+namespace core {
+
+    class CallCapabilities {
+    public:
+        enum caps {
+            REQUIRES_OPENGL = 1 << 0,
+            REQUIRES_CUDA = 1 << 1,
+            REQUIRES_OPENCL = 1 << 2,
+            REQUIRES_OPTIX = 1 << 3,
+            REQUIRES_OSPRAY = 1 << 4,
+            REQUIRES_VULKAN = 1 << 5
+        };
+
+        void RequireOpenGL();
+        void RequireCUDA();
+        void RequireOpenCL();
+        void RequireOptiX();
+        void RequireOSPRay();
+        void RequireVulkan();
+
+        bool OpenGLRequired() const;
+        bool CUDARequired() const;
+        bool OpenCLRequired() const;
+        bool OptiXRequired() const;
+        bool OSPRayRequired() const;
+        bool VulkanRequired() const;
+
+    private:
+        uint64_t cap_bits = 0;
+    };
+
+}
+}

core/include/mmcore/CallProfiling.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <vector>
+#include <array>
+#include <map>
+#include <string>
+
+#include "PerformanceQueryManager.h"
+#include "PerformanceHistory.h"
+
+namespace megamol {
+namespace core {
+
+    class Call;
+
+    class CallProfiling {
+    public:
+
+        CallProfiling();
+        ~CallProfiling();
+
+        static uint32_t GetSampleHistoryLength();
+
+        double GetLastCPUTime(uint32_t func) const;
+        double GetAverageCPUTime(uint32_t func) const;
+        uint32_t GetNumCPUSamples(uint32_t func) const;
+        std::array<double, PerformanceHistory::buffer_length> GetCPUHistory(uint32_t func) const;
+
+        double GetLastGPUTime(uint32_t func) const;
+        double GetAverageGPUTime(uint32_t func) const;
+        uint32_t GetNumGPUSamples(uint32_t func) const;
+        std::array<double, PerformanceHistory::buffer_length> GetGPUHistory(uint32_t func) const;
+
+        uint32_t GetFuncCount() const;
+        const std::string& GetFuncName(uint32_t i) const;
+
+        void ShutdownProfiling() const;
+
+        static void InitializeQueryManager();
+        static void CollectGPUPerformance();
+
+    private:
+        friend class Call;
+        friend class PerformanceQueryManager;
+
+        void setProfilingInfo(std::vector<std::string> names, Call *parent);
+
+        std::vector<PerformanceHistory> cpu_history;
+        std::vector<PerformanceHistory> gpu_history;
+        std::vector<std::string> callback_names;
+        Call *parent_call = nullptr;
+        // this only works since the MegaMol build is static, otherwise a global round-robin could be a problem...
+        inline static PerformanceQueryManager *qm = nullptr;
+        inline const static std::string err_oob = "out of bounds";
+    };
+
+}
+}

core/include/mmcore/PerformanceHistory.h

@@ -0,0 +1,66 @@
+#pragma once
+
+#include <array>
+#include <algorithm>
+
+namespace megamol {
+namespace core {
+
+class PerformanceHistory {
+public:
+    static const uint32_t buffer_length = 100;
+
+    PerformanceHistory();
+
+    void push_value(double val);
+
+    void reset();
+
+    double operator[](int index) const;
+
+    double last_value() const {
+        return time_buffer[offset(next_index, buffer_length - 1)];
+    }
+
+    double average() const {
+        return avg_time;
+    }
+
+    double buffer_average() const {
+        return window_avg;
+    }
+
+    uint32_t samples() const {
+        return num_samples;
+    }
+
+    std::array<double, buffer_length> copyHistory() const {
+        std::array<double, buffer_length> ret{};
+        std::copy(time_buffer.begin() + next_index, time_buffer.end(), ret.begin());
+        if (next_index > 0) {
+            std::copy_n(time_buffer.begin(), next_index, ret.begin() + (buffer_length - next_index));
+        }
+        return ret;
+    }
+
+private:
+    static int offset(const int index, const int offset);
+
+    static int next_wrap(const int index) {
+        return offset(index, 1);
+    }
+    static int prev_wrap(const int index) {
+        return offset(index, -1);
+    }
+
+    std::array<double, buffer_length> time_buffer{};
+    int next_index = 0;
+    //int last_index = 0;
+    double avg_time = 0;
+    double window_total = 0;
+    double window_avg = 0;
+    uint32_t num_samples = 0;
+};
+
+}
+}

core/include/mmcore/PerformanceQueryManager.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include <array>
+#include <vector>
+
+namespace megamol {
+namespace core {
+class Call;
+
+class PerformanceQueryManager {
+public:
+    PerformanceQueryManager();
+    ~PerformanceQueryManager();
+    PerformanceQueryManager(const PerformanceQueryManager&);
+
+    bool Start(megamol::core::Call *c, uint32_t frameId, int32_t funcIdx);
+    void Stop(uint32_t frameId);
+    void Collect();
+
+    void AddCall(megamol::core::Call *c);
+    void RemoveCall(megamol::core::Call *c);
+
+    void ResetGLProfiling();
+    void AdvanceGLProfiling();
+
+private:
+    struct query_info {
+        uint32_t id = 0;
+        bool started = false;
+        int32_t call_idx = -1;
+        int32_t func_idx = -1;
+
+    };
+    std::array<query_info, 2> query_infos;
+    std::vector<megamol::core::Call*> all_calls;
+    int32_t starting_call = -1, starting_func = -1;
+
+    int32_t next_query = 0;
+    int32_t running_query = -1;
+};
+
+
+} // namespace core
+} // namespace megamol
+

core/include/mmcore/view/CallRender3DGL.h

@@ -58,7 +58,7 @@ class CallRender3DGL : public CallRenderGL {
     static const char* FunctionName(unsigned int idx) { return AbstractCallRender::FunctionName(idx); }
 
     /** Ctor. */
-    CallRender3DGL(void) : CallRenderGL() { }
+    CallRender3DGL(void) = default;
 
     /** Dtor. */
     virtual ~CallRender3DGL(void) = default;

core/include/mmcore/view/ContextToGL.h

@@ -113,6 +113,72 @@ class ContextToGL : public Renderer3DModuleGL {
      */
     virtual bool Render(CallRender3DGL& call);
 
+    bool OnChar(unsigned codePoint) override {
+        auto* ci = this->_getContextSlot.template CallAs<InputCall>();
+        if (ci != nullptr) {
+            view::InputEvent evt;
+            evt.tag = view::InputEvent::Tag::Char;
+            evt.charData.codePoint = codePoint;
+            ci->SetInputEvent(evt);
+            return (*ci)(InputCall::FnOnChar);
+        }
+        return false; 
+    }
+
+    bool OnKey(Key key, KeyAction action, Modifiers mods) override {
+        auto* ci = this->_getContextSlot.template CallAs<InputCall>();
+        if (ci != nullptr) {
+            view::InputEvent evt;
+            evt.tag = view::InputEvent::Tag::Key;
+            evt.keyData.key = key;
+            evt.keyData.action = action;
+            evt.keyData.mods = mods;
+            ci->SetInputEvent(evt);
+            return (*ci)(InputCall::FnOnKey);
+        }
+        return false;
+    }
+
+    bool OnMouseButton(MouseButton button, MouseButtonAction action, Modifiers mods) override {
+        auto* ci = this->chainRenderSlot.template CallAs<InputCall>();
+        if (ci != nullptr) {
+            view::InputEvent evt;
+            evt.tag = view::InputEvent::Tag::MouseButton;
+            evt.mouseButtonData.button = button;
+            evt.mouseButtonData.action = action;
+            evt.mouseButtonData.mods = mods;
+            ci->SetInputEvent(evt);
+            return (*ci)(InputCall::FnOnMouseButton);
+        }
+        return false;
+    }
+
+    bool OnMouseMove(double x, double y) override {
+        auto* ci = this->chainRenderSlot.template CallAs<InputCall>();
+        if (ci != nullptr) {
+            view::InputEvent evt;
+            evt.tag = view::InputEvent::Tag::MouseMove;
+            evt.mouseMoveData.x = x;
+            evt.mouseMoveData.y = y;
+            ci->SetInputEvent(evt);
+            return (*ci)(InputCall::FnOnMouseMove);
+        }
+        return false; 
+    }
+
+    bool OnMouseScroll(double dx, double dy) override {
+        auto* ci = this->chainRenderSlot.template CallAs<InputCall>();
+        if (ci != nullptr) {
+            view::InputEvent evt;
+            evt.tag = view::InputEvent::Tag::MouseScroll;
+            evt.mouseScrollData.dx = dx;
+            evt.mouseScrollData.dy = dy;
+            ci->SetInputEvent(evt);
+            return (*ci)(InputCall::FnOnMouseScroll);
+        }
+        return false; 
+    }
+
 private:
     core::CallerSlot _getContextSlot;
 
@@ -168,26 +234,6 @@ bool ContextToGL<CALL, init_func, ren_func, CN, DESC>::Render(CallRender3DGL& ca
         viewport = {width, height};
     }
     cr->SetFramebuffer(_framebuffer);
-    cr->SetInputEvent(call.GetInputEvent());
-
-    auto const& ie = cr->GetInputEvent();
-    switch (ie.tag) {
-    case InputEvent::Tag::Char: {
-        (*cr)(CALL::FnOnChar);
-    } break;
-    case InputEvent::Tag::Key: {
-        (*cr)(CALL::FnOnKey);
-    } break;
-    case InputEvent::Tag::MouseButton: {
-        (*cr)(CALL::FnOnMouseButton);
-    } break;
-    case InputEvent::Tag::MouseMove: {
-        (*cr)(CALL::FnOnMouseMove);
-    } break;
-    case InputEvent::Tag::MouseScroll: {
-        (*cr)(CALL::FnOnMouseScroll);
-    } break;
-    }
 
     (*cr)(CALL::FnRender);