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,16 @@
 #endif /* (defined(_MSC_VER) && (_MSC_VER > 1000)) */
 
 #include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+#include "CallCapabilities.h"
+#ifdef PROFILING
+#include "CallProfiling.h"
+#endif
 
 #include "mmcore/api/MegaMolCore.std.h"
 
-
 namespace megamol {
 namespace core {
 
@@ -96,8 +102,23 @@ namespace core {
             return this->className;
         }
 
-    private:
+        const CallCapabilities& GetCapabilities() const {
+            return caps;
+        }
+
+        void SetCallbackNames(std::vector<std::string> names);
+
+        const std::string& GetCallbackName(uint32_t idx) const;
+
+        uint32_t GetCallbackCount() const {
+            return static_cast<uint32_t>(callback_names.size());
+        }
+
+#ifdef PROFILING
+        const CallProfiling& GetProfiling() const { return profiling; }
+#endif
 
+    private:
         /** The callee connected by this call */
         CalleeSlot *callee;
 
@@ -109,6 +130,17 @@ namespace core {
         /** The function id mapping */
         unsigned int *funcMap;
 
+        std::vector<std::string> callback_names;
+
+        inline static std::string err_out_of_bounds = "index out of bounds";
+
+#ifdef PROFILING
+        friend class PerformanceQueryManager;
+
+        CallProfiling profiling;
+#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,54 @@
+#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;
+
+        void SetParent(Call *parent);
+
+        void ShutdownProfiling() const;
+
+        static void InitializeQueryManager();
+        static void CollectGPUPerformance();
+
+    private:
+        friend class Call;
+        friend class PerformanceQueryManager;
+
+        std::vector<PerformanceHistory> cpu_history;
+        std::vector<PerformanceHistory> gpu_history;
+        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/factories/CallAutoDescription.h

@@ -10,6 +10,9 @@
 
 #include "CallDescription.h"
 
+#include <string>
+#include <vector>
+
 namespace megamol::core::factories {
 
     /**
@@ -50,6 +53,11 @@ namespace megamol::core::factories {
         Call* CreateCall() const override {
             T* c = new T();
             c->SetClassName(this->ClassName());
+            std::vector<std::string> callbacks(this->FunctionCount());
+            for (uint32_t x = 0; x < this->FunctionCount(); ++x) {
+                callbacks[x] = this->FunctionName(x);
+            }
+            c->SetCallbackNames(callbacks);
             return this->describeCall(c);
         }
 

core/include/mmcore/view/CallRender2DGL.h

@@ -42,7 +42,9 @@ namespace view {
     class CallRender2DGL : public BaseCallRender<glowl::FramebufferObject, callrender2dgl_name, callrender2dgl_desc> {
     public:
         /** Ctor. */
-        CallRender2DGL(void) = default;
+        CallRender2DGL(void) : BaseCallRender<glowl::FramebufferObject, callrender2dgl_name, callrender2dgl_desc>() {
+            this->caps.RequireOpenGL();
+        }
 
         /** Dtor. */
         virtual ~CallRender2DGL(void) = default;

core/include/mmcore/view/CallRender3DGL.h

@@ -35,7 +35,9 @@ namespace view {
             : public BaseCallRender<glowl::FramebufferObject, callrender3dgl_name, callrender3dgl_desc> {
     public:
         /** Ctor. */
-        CallRender3DGL(void) = default;
+        CallRender3DGL(void) : BaseCallRender<glowl::FramebufferObject, callrender3dgl_name, callrender3dgl_desc>() {
+            this->caps.RequireOpenGL();
+        }
 
         /** Dtor. */
         virtual ~CallRender3DGL(void) = default;

core/include/mmcore/view/CallRenderViewGL.h

@@ -24,13 +24,23 @@ namespace view {
 
     /**
      * Call for rendering visual elements (from separate sources) into a single target, i.e.,
-	 * FBO-based compositing and cluster display.
+     * FBO-based compositing and cluster display.
      */
-    using CallRenderViewGL = AbstractCallRenderView<glowl::FramebufferObject, callrenderviewgl_name, callrenderviewgl_desc>;
+    class CallRenderViewGL
+            : public AbstractCallRenderView<glowl::FramebufferObject, callrenderviewgl_name, callrenderviewgl_desc> {
+    public:
+        /** Ctor. */
+        CallRenderViewGL(void)
+                : AbstractCallRenderView<glowl::FramebufferObject, callrenderviewgl_name, callrenderviewgl_desc>() {
+            this->caps.RequireOpenGL();
+        }
+
+        /** Dtor. */
+        virtual ~CallRenderViewGL(void) = default;
+    };
 
     /** Description class typedef */
-    typedef factories::CallAutoDescription<CallRenderViewGL>
-        CallRenderViewGLDescription;
+    typedef factories::CallAutoDescription<CallRenderViewGL> CallRenderViewGLDescription;
 
 
 } /* end namespace view */