test

frame/CMakeLists.txt

@@ -7,6 +7,7 @@ set(PUBLIC_HEADERS
     pluginmetadata.h
     pluginloader.h
     pluginfactory.h
+    startuptimingrecorder.h
     applet.h
     appletdata.h
     containment.h
@@ -55,6 +56,7 @@ add_library(dde-shell-frame SHARED
     pluginmetadata.cpp
     pluginloader.cpp
     pluginfactory.cpp
+    startuptimingrecorder.cpp
     applet.cpp
     containment.cpp
     panel.cpp

frame/pluginloader.cpp

@@ -3,6 +3,7 @@
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 #include "pluginloader.h"
+#include "startuptimingrecorder.h"
 
 #include "applet.h"
 #include "containment.h"
@@ -17,9 +18,11 @@
 #include <QLoggingCategory>
 #include <QPluginLoader>
 #include <QStandardPaths>
 #include <QThread>
 #include <QFuture>
 #include <QtConcurrent>
+#include <fcntl.h>
+#include <unistd.h>
 
 DS_BEGIN_NAMESPACE;
 
@@ -61,8 +64,31 @@
         m_loadMetaDatas = QtConcurrent::run(std::bind(&DPluginLoaderPrivate::initPlugins, this));
     }
 
+    void preloadPluginLibraries()
+    {
+        D_Q(DPluginLoader);
+        for (const auto &pluginId : m_plugins.keys()) {
+            for (const auto &dir : q->pluginDirs()) {
+                const QString soPath = QDir(dir).absoluteFilePath(pluginId + PluginSuffix);
+                if (!QFile::exists(soPath))
+                    continue;
+                const int fd = open(soPath.toUtf8().constData(), O_RDONLY | O_CLOEXEC);
+                if (fd >= 0) {
+                    if (posix_fadvise(fd, 0, 0, POSIX_FADV_WILLNEED) != 0) {
+                        qCDebug(dsLog) << "posix_fadvise failed for" << soPath;
+                    }
+                    close(fd);
+                } else {
+                    qCDebug(dsLog) << "Failed to open plugin library for preloading:" << soPath;
+                }
+                break;
+            }
+        }
+    }
+
     void initPlugins()
     {
+        StartupTimingScope timingScope(QStringLiteral("plugin_discovery"));
         for (const auto &item : m_pluginDirs) {
             const QDirIterator::IteratorFlags flags = QDirIterator::Subdirectories | QDirIterator::FollowSymlinks;
             const QStringList nameFilters = {MetaDataFileName};
@@ -94,6 +120,7 @@
                 m_plugins[info.pluginId()] = info;
             }
         }
+        preloadPluginLibraries();
     }
 
     QStringList builtinPackagePaths()
@@ -151,6 +178,7 @@
         if (!existPlugin(data))
             return nullptr;
 
+        StartupTimingScope timingScope(QStringLiteral("so_load"), data.pluginId());
         DAppletFactory *factory = nullptr;
         const QString fileName = data.pluginId();
         QPluginLoader loader(fileName);

frame/startuptimingrecorder.cpp

@@ -0,0 +1,111 @@
+// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "startuptimingrecorder.h"
+
+#include <dobject_p.h>
+#include <QApplicationStatic>
+
+#include <QCoreApplication>
+#include <QDateTime>
+#include <QFile>
+#include <QJsonDocument>
+#include <QJsonObject>
+#include <QLoggingCategory>
+#include <QMutexLocker>
+
+DS_BEGIN_NAMESPACE
+
+Q_LOGGING_CATEGORY(dsBenchmarkLog, "org.deepin.dde.shell.benchmark")
+
+Q_APPLICATION_STATIC(StartupTimingRecorder, g_instance)
+
+StartupTimingRecorder::StartupTimingRecorder()
+    : QObject()
+{
+}
+
+StartupTimingRecorder::~StartupTimingRecorder() = default;
+
+StartupTimingRecorder *StartupTimingRecorder::instance()
+{
+    return g_instance;
+}
+
+void StartupTimingRecorder::record(const QString &phase, qint64 elapsedMs,
+                                   const QString &pluginId, const QVariantMap &metadata)
+{
+    QMutexLocker locker(&m_mutex);
+    m_samples.append({phase, pluginId, elapsedMs, metadata});
+}
+
+QJsonArray StartupTimingRecorder::toJson() const
+{
+    QMutexLocker locker(&m_mutex);
+    QJsonArray array;
+    for (const auto &sample : m_samples) {
+        QJsonObject obj;
+        obj["phase"] = sample.phase;
+        if (!sample.pluginId.isEmpty())
+            obj["plugin_id"] = sample.pluginId;
+        obj["elapsed_ms"] = sample.elapsedMs;
+        if (!sample.metadata.isEmpty())
+            obj["metadata"] = QJsonObject::fromVariantMap(sample.metadata);
+        array.append(obj);
+    }
+    return array;
+}
+
+bool StartupTimingRecorder::isEnabled() const
+{
+    return qgetenv("DDE_SHELL_BENCHMARK") == "1";
+}
+
+void StartupTimingRecorder::dumpToFile(const QString &path) const
+{
+    QJsonObject root;
+    root["timestamp"] = QDateTime::currentDateTimeUtc().toString(Qt::ISODate);
+    root["version"] = "1.0";
+    root["pid"] = QCoreApplication::applicationPid();
+    root["samples"] = toJson();
+
+    QFile file(path);
+    if (file.open(QIODevice::WriteOnly)) {
+        file.write(QJsonDocument(root).toJson(QJsonDocument::Indented));
+        file.close();
+    } else {
+        qCWarning(dsBenchmarkLog) << "Cannot open benchmark output:" << path;
+    }
+}
+
+StartupTimingScope::StartupTimingScope(const QString &phase, const QString &pluginId,
+                                       const QVariantMap &metadata, int timeoutMs)
+    : m_phase(phase)
+    , m_pluginId(pluginId)
+    , m_metadata(metadata)
+    , m_timeoutMs(timeoutMs)
+{
+    if (StartupTimingRecorder::instance()->isEnabled()) {
+        m_enabled = true;
+        m_timer.start();
+    }
+}
+
+StartupTimingScope::~StartupTimingScope()
+{
+    if (!m_enabled)
+        return;
+
+    const qint64 elapsed = m_timer.elapsed();
+    StartupTimingRecorder::instance()->record(m_phase, elapsed, m_pluginId, m_metadata);
+
+    if (m_timeoutMs > 0 && elapsed >= m_timeoutMs) {
+        if (m_pluginId.isEmpty())
+            qCWarning(dsBenchmarkLog) << m_phase << ": elapsed time [" << elapsed << "ms ].";
+        else
+            qCWarning(dsBenchmarkLog) << m_phase << ":" << m_pluginId << ": elapsed time [" << elapsed << "ms ].";
+    }
+}
+
+DS_END_NAMESPACE

frame/startuptimingrecorder.h

@@ -0,0 +1,64 @@
+// SPDX-FileCopyrightText: 2026 UnionTech Software Technology Co., Ltd.
+//
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#pragma once
+
+#include "dsglobal.h"
+
+#include <QObject>
+#include <QElapsedTimer>
+#include <QJsonArray>
+#include <QMutex>
+#include <QVariantMap>
+#include <QVector>
+#include <QString>
+
+DS_BEGIN_NAMESPACE
+
+struct TimingSample
+{
+    QString phase;
+    QString pluginId;
+    qint64 elapsedMs = 0;
+    QVariantMap metadata;
+};
+
+class DS_SHARE StartupTimingRecorder : public QObject
+{
+    Q_OBJECT
+public:
+    StartupTimingRecorder();
+    ~StartupTimingRecorder() override;
+    static StartupTimingRecorder *instance();
+
+    void record(const QString &phase, qint64 elapsedMs,
+                const QString &pluginId = {}, const QVariantMap &metadata = {});
+    QJsonArray toJson() const;
+    bool isEnabled() const;
+    void dumpToFile(const QString &path) const;
+
+private:
+    Q_DISABLE_COPY(StartupTimingRecorder)
+
+    QVector<TimingSample> m_samples;
+    mutable QMutex m_mutex;
+};
+
+class StartupTimingScope
+{
+public:
+    explicit StartupTimingScope(const QString &phase, const QString &pluginId = {},
+                                const QVariantMap &metadata = {}, int timeoutMs = 0);
+    ~StartupTimingScope();
+
+private:
+    QString m_phase;
+    QString m_pluginId;
+    QVariantMap m_metadata;
+    int m_timeoutMs = 0;
+    bool m_enabled = false;
+    QElapsedTimer m_timer;
+};
+
+DS_END_NAMESPACE

shell/appletconfigmanager.cpp

@@ -5,10 +5,10 @@
 #include "appletconfigmanager.h"
 
 #include "pluginloader.h"
+#include "startuptimingrecorder.h"
 
 #include <DConfig>
 #include <QLoggingCategory>
-#include <QSet>
 
 DS_BEGIN_NAMESPACE
 
@@ -30,8 +30,9 @@ QStringList AppletConfigManager::disabledPlugins() const
     return m_disabledPlugins;
 }
 
-bool AppletConfigManager::isAppletEnabled(const QString &pluginId) const
+bool AppletConfigManager::isAppletEnabled(const QString &pluginId)
 {
+    ensureAppletConfig(pluginId);
     return !m_disabledPlugins.contains(pluginId);
 }
 
@@ -48,36 +49,28 @@ void AppletConfigManager::setAppletEnabled(const QString &pluginId, bool enabled
     Q_EMIT appletEnabledChanged(pluginId, enabled);
 }
 
-void AppletConfigManager::ensureAppletConfigs()
+void AppletConfigManager::ensureAppletConfig(const QString &pluginId)
 {
-    auto loader = DPluginLoader::instance();
-    const auto plugins = loader->plugins();
-    QSet<QString> pluginIds;
-    for (const auto &plugin : plugins) {
-        pluginIds.insert(plugin.pluginId());
-    }
+    if (m_appletConfigs.contains(pluginId))
+        return;
 
-    for (const auto &pluginId : pluginIds) {
-        if (m_appletConfigs.contains(pluginId))
-            continue;
-
-        auto config = DConfig::create(QLatin1String(AppId),
-                                      QLatin1String(ConfigName),
-                                      QLatin1Char('/') + pluginId,
-                                      this);
-        m_appletConfigs.insert(pluginId, config);
-        if (!config || !config->isValid()) {
-            qCWarning(dsLoaderLog) << "Unable to create applet DConfig; applet remains enabled:" << pluginId;
-            setAppletEnabled(pluginId, true);
-            continue;
-        }
-
-        setAppletEnabled(pluginId, config->value(QLatin1String(EnableKey), true).toBool());
-        QObject::connect(config, &DConfig::valueChanged, this, [this, pluginId, config](const QString &key) {
-            if (key == QLatin1String(EnableKey))
-                setAppletEnabled(pluginId, config->value(QLatin1String(EnableKey), true).toBool());
-        });
+    StartupTimingScope pluginScope(QStringLiteral("dconfig_create"), pluginId);
+    auto config = DConfig::create(QLatin1String(AppId),
+                                  QLatin1String(ConfigName),
+                                  QLatin1Char('/') + pluginId,
+                                  this);
+    m_appletConfigs.insert(pluginId, config);
+    if (!config || !config->isValid()) {
+        qCWarning(dsLoaderLog) << "Unable to create applet DConfig; applet remains enabled:" << pluginId;
+        setAppletEnabled(pluginId, true);
+        return;
     }
+
+    setAppletEnabled(pluginId, config->value(QLatin1String(EnableKey), true).toBool());
+    QObject::connect(config, &DConfig::valueChanged, this, [this, pluginId, config](const QString &key) {
+        if (key == QLatin1String(EnableKey))
+            setAppletEnabled(pluginId, config->value(QLatin1String(EnableKey), true).toBool());
+    });
 }
 
 DS_END_NAMESPACE

shell/appletconfigmanager.h

@@ -23,8 +23,8 @@ class AppletConfigManager : public QObject
     explicit AppletConfigManager(QObject *parent = nullptr);
 
     QStringList disabledPlugins() const;
-    bool isAppletEnabled(const QString &pluginId) const;
-    void ensureAppletConfigs();
+    bool isAppletEnabled(const QString &pluginId);
+    void ensureAppletConfig(const QString &pluginId);
 
 Q_SIGNALS:
     void appletEnabledChanged(const QString &pluginId, bool enabled);