app_profiler.hpp

Go to the documentation of this file.

/**
 * \file app_profiler.hpp
 * \brief Global application profiling instrumentation.
 * \author Le Bars, Yoann
 *
 * This file provides profiling instrumentation for application-wide phases:
 * - Qt initialization
 * - 3D window creation
 * - Frame rendering
 * - Cleanup
 */
 
#ifndef APP_PROFILER_HPP
#define APP_PROFILER_HPP
 
#include <QDebug>
#include <chrono>
 
namespace AppUtils {
    /**
     * \brief Global application profiler for measuring non-physics phases.
     *
     * This class accumulates timing data for application-wide operations
     * that are not part of the physics simulation itself.
     */
    class AppProfiler {
       public:
        using Clock = std::chrono::high_resolution_clock;
        using TimePoint = Clock::time_point;
 
        /**
         * \brief Starts timing Qt initialization.
         */
        static void startQtInit() { instance().qtInitStart_ = Clock::now(); }
 
        /**
         * \brief Stops timing Qt initialization.
         */
        static void stopQtInit() {
            auto& inst = instance();
            if (inst.qtInitStart_ != TimePoint{}) {
                inst.qtInitTime_ += std::chrono::duration<double>(
                                        Clock::now() - inst.qtInitStart_)
                                        .count();
                inst.qtInitStart_ = TimePoint{};
            }
        }
 
        /**
         * \brief Starts timing 3D window creation.
         */
        static void startWindowCreation() {
            instance().windowCreationStart_ = Clock::now();
        }
 
        /**
         * \brief Stops timing 3D window creation.
         */
        static void stopWindowCreation() {
            auto& inst = instance();
            if (inst.windowCreationStart_ != TimePoint{}) {
                inst.windowCreationTime_ +=
                    std::chrono::duration<double>(Clock::now() -
                                                  inst.windowCreationStart_)
                        .count();
                inst.windowCreationStart_ = TimePoint{};
            }
        }
 
        /**
         * \brief Starts timing a frame render.
         */
        static void startFrameRender() {
            instance().frameRenderStart_ = Clock::now();
        }
 
        /**
         * \brief Stops timing a frame render.
         */
        static void stopFrameRender() {
            auto& inst = instance();
            if (inst.frameRenderStart_ != TimePoint{}) {
                inst.frameRenderTime_ +=
                    std::chrono::duration<double>(Clock::now() -
                                                  inst.frameRenderStart_)
                        .count();
                inst.frameRenderCount_++;
                inst.frameRenderStart_ = TimePoint{};
            }
        }
 
        /**
         * \brief Starts timing the Qt event loop.
         */
        static void startEventLoop() {
            instance().eventLoopStart_ = Clock::now();
        }
 
        /**
         * \brief Stops timing the Qt event loop.
         */
        static void stopEventLoop() {
            auto& inst = instance();
            if (inst.eventLoopStart_ != TimePoint{}) {
                inst.eventLoopTime_ += std::chrono::duration<double>(
                                           Clock::now() - inst.eventLoopStart_)
                                           .count();
                inst.eventLoopStart_ = TimePoint{};
            }
        }
 
        /**
         * \brief Starts timing cleanup.
         */
        static void startCleanup() { instance().cleanupStart_ = Clock::now(); }
 
        /**
         * \brief Stops timing cleanup.
         */
        static void stopCleanup() {
            auto& inst = instance();
            if (inst.cleanupStart_ != TimePoint{}) {
                inst.cleanupTime_ += std::chrono::duration<double>(
                                         Clock::now() - inst.cleanupStart_)
                                         .count();
                inst.cleanupStart_ = TimePoint{};
            }
        }
 
        /**
         * \brief Adds measured time for Display cleanup preparation.
         *
         * This phase includes stopping timers, disconnecting signals and
         * stopping simulation scheduling.
         */
        static void addCleanupDisplayPrep(double seconds) {
            instance().cleanupDisplayPrepTime_ += seconds;
        }
 
        /**
         * \brief Adds measured time spent in Display cleanup processEvents.
         */
        static void addCleanupDisplayProcessEvents(double seconds) {
            instance().cleanupDisplayProcessEventsTime_ += seconds;
        }
 
        /**
         * \brief Adds measured time for stopping the physics thread.
         */
        static void addCleanupDisplayThreadStop(double seconds) {
            instance().cleanupDisplayThreadStopTime_ += seconds;
        }
 
        /**
         * \brief Adds measured time for physics worker cleanup.
         */
        static void addCleanupDisplayWorkerCleanup(double seconds) {
            instance().cleanupDisplayWorkerCleanupTime_ += seconds;
        }
 
        /**
         * \brief Adds measured time spent in bridge/display cleanup call.
         */
        static void addCleanupAppBridgeCleanup(double seconds) {
            instance().cleanupAppBridgeCleanupTime_ += seconds;
        }
 
        /**
         * \brief Adds measured time for manual destroy operations.
         *
         * This phase includes detach-from-window, display release and
         * container deletion, but excludes processEvents.
         */
        static void addCleanupAppManualDestroy(double seconds) {
            instance().cleanupAppManualDestroyTime_ += seconds;
        }
 
        /**
         * \brief Adds measured time for detaching the display container.
         */
        static void addCleanupAppDetachContainer(double seconds) {
            instance().cleanupAppDetachContainerTime_ += seconds;
        }
 
        /**
         * \brief Adds measured time for explicit display release.
         */
        static void addCleanupAppReleaseDisplay(double seconds) {
            instance().cleanupAppReleaseDisplayTime_ += seconds;
        }
 
        /**
         * \brief Adds measured time for container delete action.
         *
         * In fast mode this is deleteLater() scheduling, in strict mode this is
         * immediate deletion.
         */
        static void addCleanupAppContainerDeleteSchedule(double seconds) {
            instance().cleanupAppContainerDeleteScheduleTime_ += seconds;
        }
 
        /**
         * \brief Adds measured time spent in AppManager cleanup processEvents.
         */
        static void addCleanupAppProcessEvents(double seconds) {
            instance().cleanupAppProcessEventsTime_ += seconds;
        }
 
        /**
         * \brief Prints the profiling report.
         */
        static void printReport() {
            const auto& inst = instance();
            const double totalTime =
                inst.qtInitTime_ + inst.windowCreationTime_ +
                inst.eventLoopTime_ + inst.frameRenderTime_ + inst.cleanupTime_;
 
            if (totalTime < 1e-9) {
                qDebug().noquote()
                    << "\n--- Application Profiling Report (No data) ---";
                return;
            }
 
            const double avgFrameMs =
                inst.frameRenderCount_ > 0
                    ? inst.frameRenderTime_ / inst.frameRenderCount_ * 1000.0
                    : 0.0;
            const QString msg =
                QString(
                    "\n--- Application Profiling Report ---\nQt "
                    "Initialization:      %1s (%2%%)\n3D Window Creation:      "
                    "%3s (%4%%)\nQt Event Loop:          %5s (%6%%)\nFrame "
                    "Rendering:         %7s (%8%%) (%9 frames, avg: "
                    "%10ms/frame)\nCleanup:                 %11s "
                    "(%12%%)\n------------------------\nTotal Application "
                    "Time:  %13s")
                    .arg(inst.qtInitTime_, 9, 'f', 4)
                    .arg(inst.qtInitTime_ / totalTime * 100.0, 5, 'f', 1)
                    .arg(inst.windowCreationTime_, 9, 'f', 4)
                    .arg(inst.windowCreationTime_ / totalTime * 100.0, 5, 'f',
                         1)
                    .arg(inst.eventLoopTime_, 9, 'f', 4)
                    .arg(inst.eventLoopTime_ / totalTime * 100.0, 5, 'f', 1)
                    .arg(inst.frameRenderTime_, 9, 'f', 4)
                    .arg(inst.frameRenderTime_ / totalTime * 100.0, 5, 'f', 1)
                    .arg(inst.frameRenderCount_)
                    .arg(avgFrameMs, 0, 'f', 4)
                    .arg(inst.cleanupTime_, 9, 'f', 4)
                    .arg(inst.cleanupTime_ / totalTime * 100.0, 5, 'f', 1)
                    .arg(totalTime, 9, 'f', 4);
            qDebug().noquote() << msg;
 
            if (inst.cleanupTime_ > 1e-9) {
                const QString cleanupMsg =
                    QString(
                        "\n--- Cleanup Breakdown ---\nDisplay Prep:       "
                        "%1s (%2%%)\nDisplay processEvents:%3s "
                        "(%4%%)\nDisplay Thread Stop:%5s (%6%%)\nDisplay "
                        "Worker Cleanup:%7s (%8%%)\nBridge "
                        "Cleanup*:     %9s (%10%%)\nManual "
                        "Destroy:      %11s (%12%%)\nApp processEvents:   "
                        "%13s (%14%%)\n*Bridge Cleanup includes Display "
                        "sub-phases\n------------------------")
                        .arg(inst.cleanupDisplayPrepTime_, 9, 'f', 4)
                        .arg(inst.cleanupDisplayPrepTime_ / inst.cleanupTime_ *
                                 100.0,
                             5, 'f', 1)
                        .arg(inst.cleanupDisplayProcessEventsTime_, 9, 'f', 4)
                        .arg(inst.cleanupDisplayProcessEventsTime_ /
                                 inst.cleanupTime_ * 100.0,
                             5, 'f', 1)
                        .arg(inst.cleanupDisplayThreadStopTime_, 9, 'f', 4)
                        .arg(inst.cleanupDisplayThreadStopTime_ /
                                 inst.cleanupTime_ * 100.0,
                             5, 'f', 1)
                        .arg(inst.cleanupDisplayWorkerCleanupTime_, 9, 'f', 4)
                        .arg(inst.cleanupDisplayWorkerCleanupTime_ /
                                 inst.cleanupTime_ * 100.0,
                             5, 'f', 1)
                        .arg(inst.cleanupAppBridgeCleanupTime_, 9, 'f', 4)
                        .arg(inst.cleanupAppBridgeCleanupTime_ /
                                 inst.cleanupTime_ * 100.0,
                             5, 'f', 1)
                        .arg(inst.cleanupAppManualDestroyTime_, 9, 'f', 4)
                        .arg(inst.cleanupAppManualDestroyTime_ /
                                 inst.cleanupTime_ * 100.0,
                             5, 'f', 1)
                        .arg(inst.cleanupAppProcessEventsTime_, 9, 'f', 4)
                        .arg(inst.cleanupAppProcessEventsTime_ /
                                 inst.cleanupTime_ * 100.0,
                             5, 'f', 1);
                qDebug().noquote() << cleanupMsg;
 
                if (inst.cleanupAppManualDestroyTime_ > 1e-9) {
                    const QString manualDestroyMsg =
                        QString(
                            "\n--- Manual Destroy Breakdown ---\nDetach "
                            "Container: %1s (%2%%)\nRelease Display:   %3s "
                            "(%4%%)\nContainer Delete:  %5s "
                            "(%6%%)\n------------------------")
                            .arg(inst.cleanupAppDetachContainerTime_, 9, 'f', 4)
                            .arg(inst.cleanupAppDetachContainerTime_ /
                                     inst.cleanupAppManualDestroyTime_ * 100.0,
                                 5, 'f', 1)
                            .arg(inst.cleanupAppReleaseDisplayTime_, 9, 'f', 4)
                            .arg(inst.cleanupAppReleaseDisplayTime_ /
                                     inst.cleanupAppManualDestroyTime_ * 100.0,
                                 5, 'f', 1)
                            .arg(inst.cleanupAppContainerDeleteScheduleTime_, 9,
                                 'f', 4)
                            .arg(inst.cleanupAppContainerDeleteScheduleTime_ /
                                     inst.cleanupAppManualDestroyTime_ * 100.0,
                                 5, 'f', 1);
                    qDebug().noquote() << manualDestroyMsg;
                }
            }
        }
 
        /**
         * \brief Resets all profiling data.
         */
        static void reset() {
            auto& inst = instance();
            inst.qtInitTime_ = 0.0;
            inst.windowCreationTime_ = 0.0;
            inst.eventLoopTime_ = 0.0;
            inst.frameRenderTime_ = 0.0;
            inst.cleanupTime_ = 0.0;
            inst.cleanupDisplayPrepTime_ = 0.0;
            inst.cleanupDisplayProcessEventsTime_ = 0.0;
            inst.cleanupDisplayThreadStopTime_ = 0.0;
            inst.cleanupDisplayWorkerCleanupTime_ = 0.0;
            inst.cleanupAppBridgeCleanupTime_ = 0.0;
            inst.cleanupAppManualDestroyTime_ = 0.0;
            inst.cleanupAppProcessEventsTime_ = 0.0;
            inst.cleanupAppDetachContainerTime_ = 0.0;
            inst.cleanupAppReleaseDisplayTime_ = 0.0;
            inst.cleanupAppContainerDeleteScheduleTime_ = 0.0;
            inst.frameRenderCount_ = 0;
            inst.qtInitStart_ = TimePoint{};
            inst.windowCreationStart_ = TimePoint{};
            inst.eventLoopStart_ = TimePoint{};
            inst.frameRenderStart_ = TimePoint{};
            inst.cleanupStart_ = TimePoint{};
        }
 
       private:
        AppProfiler() = default;
        ~AppProfiler() = default;
        AppProfiler(const AppProfiler&) = delete;
        AppProfiler& operator=(const AppProfiler&) = delete;
 
        static AppProfiler& instance() {
            static AppProfiler inst;
            return inst;
        }
 
        double qtInitTime_ = 0.0;
        double windowCreationTime_ = 0.0;
        double eventLoopTime_ = 0.0;
        double frameRenderTime_ = 0.0;
        double cleanupTime_ = 0.0;
        double cleanupDisplayPrepTime_ = 0.0;
        double cleanupDisplayProcessEventsTime_ = 0.0;
        double cleanupDisplayThreadStopTime_ = 0.0;
        double cleanupDisplayWorkerCleanupTime_ = 0.0;
        double cleanupAppBridgeCleanupTime_ = 0.0;
        double cleanupAppManualDestroyTime_ = 0.0;
        double cleanupAppProcessEventsTime_ = 0.0;
        double cleanupAppDetachContainerTime_ = 0.0;
        double cleanupAppReleaseDisplayTime_ = 0.0;
        double cleanupAppContainerDeleteScheduleTime_ = 0.0;
        std::size_t frameRenderCount_ = 0;
 
        TimePoint qtInitStart_{};
        TimePoint windowCreationStart_{};
        TimePoint eventLoopStart_{};
        TimePoint frameRenderStart_{};
        TimePoint cleanupStart_{};
    };
}  // namespace AppUtils
 
#endif  // APP_PROFILER_HPP