Consume fewer resources in AssetServer when interface is running locally

assignment-client/src/assets/AssetServer.cpp

@@ -12,6 +12,8 @@
 
 #include "AssetServer.h"
 
+#include <thread>
+
 #include <QtCore/QCoreApplication>
 #include <QtCore/QCryptographicHash>
 #include <QtCore/QDateTime>
@@ -21,6 +23,7 @@
 #include <QtCore/QJsonDocument>
 #include <QtCore/QString>
 
+#include <SharedUtil.h>
 #include <ServerPathUtils.h>
 
 #include "NetworkLogging.h"
@@ -30,6 +33,37 @@
 
 const QString ASSET_SERVER_LOGGING_TARGET_NAME = "asset-server";
 
+bool interfaceRunning() {
+    bool result = false;
+
+#ifdef Q_OS_WIN
+    QSharedMemory sharedMemory { getInterfaceSharedMemoryName() };
+    result = sharedMemory.attach(QSharedMemory::ReadOnly);
+    if (result) {
+        sharedMemory.detach();
+    }
+#endif
+    return result;
+}
+
+void updateConsumedCores() {
+    static bool wasInterfaceRunning = false;
+    bool isInterfaceRunning = interfaceRunning();
+    // If state is unchanged, return early
+    if (isInterfaceRunning == wasInterfaceRunning) {
+        return;
+    }
+
+    wasInterfaceRunning = isInterfaceRunning;
+    auto coreCount = std::thread::hardware_concurrency();
+    if (isInterfaceRunning) {
+        coreCount = coreCount > 4 ? 2 : 1;
+    } 
+    qDebug() << "Setting max consumed cores to " << coreCount;
+    setMaxCores(coreCount);
+}
+
+
 AssetServer::AssetServer(ReceivedMessage& message) :
     ThreadedAssignment(message),
     _taskPool(this)
@@ -45,6 +79,20 @@ AssetServer::AssetServer(ReceivedMessage& message) :
     packetReceiver.registerListener(PacketType::AssetGetInfo, this, "handleAssetGetInfo");
     packetReceiver.registerListener(PacketType::AssetUpload, this, "handleAssetUpload");
     packetReceiver.registerListener(PacketType::AssetMappingOperation, this, "handleAssetMappingOperation");
+    
+#ifdef Q_OS_WIN
+    updateConsumedCores();
+    QTimer* timer = new QTimer(this);
+    auto timerConnection = connect(timer, &QTimer::timeout, [] {
+        updateConsumedCores();
+    });
+    connect(qApp, &QCoreApplication::aboutToQuit, [this, timerConnection] {
+        disconnect(timerConnection);
+    });
+    timer->setInterval(1000);
+    timer->setTimerType(Qt::CoarseTimer);
+    timer->start();
+#endif
 }
 
 void AssetServer::run() {

interface/src/main.cpp

@@ -56,7 +56,7 @@ int main(int argc, const char* argv[]) {
     QCoreApplication::setOrganizationDomain(BuildInfo::ORGANIZATION_DOMAIN);
     QCoreApplication::setApplicationVersion(BuildInfo::VERSION);
 
-    QString applicationName = "High Fidelity Interface - " + qgetenv("USERNAME");
+    const QString& applicationName = getInterfaceSharedMemoryName();
 
     bool instanceMightBeRunning = true;
 

libraries/shared/src/SharedUtil.cpp

@@ -18,6 +18,8 @@
 #include <cctype>
 #include <time.h>
 #include <mutex>
+#include <thread>
+#include <set>
 
 #include <glm/glm.hpp>
 
@@ -1022,4 +1024,54 @@ bool getProcessorInfo(ProcessorInfo& info) {
 #endif
 
     return false;
-}
+}
+
+
+const QString& getInterfaceSharedMemoryName() {
+    static const QString applicationName = "High Fidelity Interface - " + qgetenv("USERNAME");
+    return applicationName;
+}
+
+const std::vector<uint8_t>& getAvailableCores() {
+    static std::vector<uint8_t> availableCores;
+#ifdef Q_OS_WIN
+    static std::once_flag once;
+    std::call_once(once, [&] {
+        DWORD_PTR defaultProcessAffinity = 0, defaultSystemAffinity = 0;
+        HANDLE process = GetCurrentProcess();
+        GetProcessAffinityMask(process, &defaultProcessAffinity, &defaultSystemAffinity);
+        for (uint64_t i = 0; i < sizeof(DWORD_PTR) * 8; ++i) {
+            DWORD_PTR coreMask = 1;
+            coreMask <<= i;
+            if (0 != (defaultSystemAffinity & coreMask)) {
+                availableCores.push_back(i);
+            }
+        }
+    });
+#endif
+    return availableCores;
+}
+
+void setMaxCores(uint8_t maxCores) {
+#ifdef Q_OS_WIN
+    HANDLE process = GetCurrentProcess();
+    auto availableCores = getAvailableCores();
+    if (availableCores.size() <= maxCores) {
+        DWORD_PTR currentProcessAffinity = 0, currentSystemAffinity = 0;
+        GetProcessAffinityMask(process, &currentProcessAffinity, &currentSystemAffinity);
+        SetProcessAffinityMask(GetCurrentProcess(), currentSystemAffinity);
+        return;
+    }
+
+    DWORD_PTR newProcessAffinity = 0;
+    while (maxCores) {
+        int index = randIntInRange(0, (int)availableCores.size() - 1);
+        DWORD_PTR coreMask = 1;
+        coreMask <<= availableCores[index];
+        newProcessAffinity |= coreMask;
+        availableCores.erase(availableCores.begin() + index);
+        maxCores--;
+    }
+    SetProcessAffinityMask(process, newProcessAffinity);
+#endif
+}

libraries/shared/src/SharedUtil.h

@@ -231,4 +231,8 @@ struct ProcessorInfo {
 
 bool getProcessorInfo(ProcessorInfo& info);
 
+const QString& getInterfaceSharedMemoryName();
+
+void setMaxCores(uint8_t maxCores);
+
 #endif // hifi_SharedUtil_h