Avoid duplicate Netlink events

contextual-classifier/ContextualClassifier.cpp

@@ -326,7 +326,12 @@ int32_t ContextualClassifier::HandleProcEv() {
             case CC_APP_OPEN:
                 if(!this->shouldProcBeIgnored(ev.type, ev.pid)) {
                     const std::lock_guard<std::mutex> lock(mQueueMutex);
+                    if(this->mClassifierPidCache.isPresent(ev.pid)) {
+                        // Duplicate Notification, skip.
+                        break;
+                    }
                     this->mPendingEv.push(ev);
+                    this->mClassifierPidCache.insert(ev.pid);
                     if(this->mPendingEv.size() > pendingQueueControlSize) {
                         this->mPendingEv.pop();
                     }
@@ -384,7 +389,8 @@ void ContextualClassifier::ApplyActions(uint32_t sigId,
                                         uint32_t sigType,
                                         pid_t incomingPID,
                                         pid_t incomingTID) {
-    Request* request = createTuneRequestFromSignal(sigId, sigType, incomingPID, incomingTID);
+    Request* request =
+        createTuneRequestFromSignal(sigId, sigType, incomingPID, incomingTID);
     if(request != nullptr) {
         if(request->getResourcesCount() > 0) {
             // Record:

contextual-classifier/Include/ContextualClassifier.h

@@ -4,19 +4,20 @@
 #ifndef CONTEXTUAL_CLASSIFIER_H
 #define CONTEXTUAL_CLASSIFIER_H
 
-#include "ComponentRegistry.h"
-#include "NetLinkComm.h"
-#include "AppConfigs.h"
-#include "Resource.h"
-
-#include <condition_variable>
 #include <mutex>
 #include <queue>
 #include <string>
+#include <vector>
 #include <thread>
 #include <unordered_map>
 #include <unordered_set>
-#include <vector>
+#include <condition_variable>
+
+#include "Resource.h"
+#include "AppConfigs.h"
+#include "NetLinkComm.h"
+#include "AuxRoutines.h"
+#include "ComponentRegistry.h"
 
 class Inference;
 
@@ -65,6 +66,9 @@ class ContextualClassifier {
     Inference *mInference;
     std::vector<int64_t> mCurrRestuneHandles;
 
+    // PID cache to check for duplicates
+    MinLRUCache mClassifierPidCache;
+
     // Event queue for classifier main thread
     std::queue<ProcEvent> mPendingEv;
     std::mutex mQueueMutex;
@@ -109,17 +113,14 @@ class ContextualClassifier {
                                 int32_t cgroupIdentifier);
 
     void configureAppSignals(pid_t incomingPID,
-                                       pid_t incomingTID,
-                                       const std::string& comm);
+                             pid_t incomingTID,
+                             const std::string& comm);
 
     void untuneRequestHelper(int64_t handle);
 
 public:
     ContextualClassifier();
     ~ContextualClassifier();
-    Inference *getInference() {
-        return mInference;
-    }
 
     ErrCode Init();
     ErrCode Terminate();

modula/CoreModules/AuxRoutines.cpp

@@ -244,3 +244,23 @@ int64_t AuxRoutines::getCurrentTimeInMilliseconds() {
     auto now = std::chrono::system_clock::now();
     return std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
 }
+
+MinLRUCache::MinLRUCache(int32_t maxSize) {
+    this->mMaxSize = maxSize;
+    this->mDataSet.reserve(this->mMaxSize);
+}
+
+void MinLRUCache::insert(int64_t data) {
+    if(this->mDataSet.size() >= this->mMaxSize) {
+        int64_t oldestElement = this->mRecencyQueue.front();
+        this->mRecencyQueue.pop();
+        this->mDataSet.erase(oldestElement);
+    }
+
+    this->mDataSet.insert(data);
+    this->mRecencyQueue.push(data);
+}
+
+int8_t MinLRUCache::isPresent(int64_t data) {
+    return (this->mDataSet.find(data) != this->mDataSet.end());
+}

modula/CoreModules/Include/AuxRoutines.h

@@ -4,19 +4,21 @@
 #ifndef AUX_ROUTINES_H
 #define AUX_ROUTINES_H
 
+#include <mutex>
+#include <queue>
 #include <string>
 #include <cstring>
 #include <sstream>
 #include <fstream>
 #include <unistd.h>
 #include <getopt.h>
-#include <mutex>
 #include <dirent.h>
 #include <algorithm>
+#include <unordered_set>
 
 #include "Logger.h"
-#include "Request.h"
 #include "Signal.h"
+#include "Request.h"
 #include "UrmSettings.h"
 #include "ClientEndpoint.h"
 
@@ -98,4 +100,17 @@ class ConnectionManager {
     }
 };
 
+class MinLRUCache {
+private:
+    size_t mMaxSize;
+    std::unordered_set<int64_t> mDataSet;
+    std::queue<int64_t> mRecencyQueue;
+
+public:
+    MinLRUCache(int32_t maxSize = 30);
+
+    void insert(int64_t data);
+    int8_t isPresent(int64_t data);
+};
+
 #endif

modula/CoreModules/Include/UrmSettings.h

@@ -79,7 +79,6 @@ class UrmSettings {
     static const std::string mDeviceNamePath;
     static const std::string mBaseCGroupPath;
     static const std::string mPersistenceFile;
-    static const std::string mExtensionPluginsLibPath;
 
     // Target Information Stores
     static MetaConfigs metaConfigs;

modula/CoreModules/UrmSettings.cpp

@@ -52,9 +52,6 @@ const std::string UrmSettings::mCustomAppConfigPath =
 const std::string UrmSettings::mDevIndexedAppPath =
                                     "/etc/urm/target/PerApp.yaml";
 
-const std::string UrmSettings::mExtensionPluginsLibPath =
-                                    "/usr/lib/urm/";
-
 const std::string UrmSettings::mDeviceNamePath =
                                     "/sys/devices/soc0/machine";
 const std::string UrmSettings::mBaseCGroupPath =

resource-tuner/core/Include/RequestManager.h

@@ -26,19 +26,6 @@ enum RequestProcessingStatus : int8_t {
     REQ_NOT_FOUND = 0x08,
 };
 
-class HandleCache {
-private:
-    size_t mMaxSize;
-    std::unordered_set<int64_t> mHandleSet;
-    std::queue<int64_t> mRecencyQueue;
-
-public:
-    HandleCache(int32_t maxSize = 30);
-
-    void insert(int64_t handle);
-    int8_t isPresent(int64_t handle);
-};
-
 /**
  * @brief RequestManager
  * @details Responsible for Tracking and Maintaining all the active Requests, currently
@@ -54,7 +41,7 @@ class RequestManager {
     int64_t mTotalRequestServed;
     std::unordered_set<Request*> mRequestsList[2];
     std::unordered_map<int64_t, RequestInfo> mActiveRequests;
-    HandleCache mUntuneCache;
+    MinLRUCache mUntuneCache;
     std::shared_timed_mutex mRequestMapMutex;
 
     RequestManager();

resource-tuner/core/RequestManager.cpp

@@ -291,23 +291,3 @@ void RequestManager::clearPending() {
 }
 
 RequestManager::~RequestManager() {}
-
-HandleCache::HandleCache(int32_t maxSize) {
-    this->mMaxSize = maxSize;
-    this->mHandleSet.reserve(this->mMaxSize);
-}
-
-void HandleCache::insert(int64_t handle) {
-    if(this->mHandleSet.size() >= this->mMaxSize) {
-        int64_t oldestHandle = this->mRecencyQueue.front();
-        this->mRecencyQueue.pop();
-        this->mHandleSet.erase(oldestHandle);
-    }
-
-    this->mHandleSet.insert(handle);
-    this->mRecencyQueue.push(handle);
-}
-
-int8_t HandleCache::isPresent(int64_t handle) {
-    return (this->mHandleSet.find(handle) != this->mHandleSet.end());
-}