Persist multiple App-Configurations at once (#252)

Signed-off-by: Kartik Nema <kartnema@qti.qualcomm.com>

Author: kartnema

configs/PropertiesConfig.yaml

@@ -46,3 +46,7 @@ PropertyConfigs:
 
   - Name: urm.extensions_lib.count
     Value: "6"
+
+  - Name: urm.classifier.apply_mode
+    # Possible values: ACCEPT_AND_PERSIST, ACCEPT_AND_REPLACE
+    Value: "ACCEPT_AND_PERSIST"

contextual-classifier/Configs/classifier-blocklist.txt

@@ -1,3 +1,3 @@
-ls,cp,sh,mv,rm,id,mkdir,touch,find,irqbalance,cpuUsage.sh,which,sudo,cpu.sh,ln,uname,gst-plugin-scan,urmCli,UrmComponentTests,UrmIntegrationTests
+ls,cp,sh,mv,rm,id,mkdir,dirname,touch,find,irqbalance,cpuUsage.sh,which,sudo,cpu.sh,ln,uname,gst-plugin-scan,urmCli,UrmComponentTests,UrmIntegrationTests
 grep,sed,awk,cat,tail,head,less,more,sort,uniq,wc,cut,tr,tee
 ps,top,sleep,journalctl,xargs,logrotate,systemctl

contextual-classifier/ContextualClassifier.cpp

@@ -56,6 +56,13 @@ static ContextualClassifier *gClassifier = nullptr;
 static const int32_t pendingQueueControlSize = 30;
 
 ContextualClassifier::ContextualClassifier() {
+    this->mClientTracker = 0;
+    this->mActiveAppThreshold = 1; // single-app mode
+
+    // In multi-app mode, at most 3 concurrent apps are supported
+    if(UrmSettings::metaConfigs.mAcceptMode & ACCEPT_AND_PERSIST) {
+        this->mActiveAppThreshold = 3;
+    }
     this->mInference = GetInferenceObject();
 }
 
@@ -179,49 +186,45 @@ void ContextualClassifier::ClassifierMain() {
         this->mPendingEv.pop();
 
         if(ev.type == CC_APP_OPEN) {
-            std::string comm;
-            uint32_t sigId = URM_SIG_APP_OPEN;
-            uint32_t sigType = DEFAULT_SIGNAL_TYPE;
-            uint32_t ctxDetails = 0U;
-
             if(ev.pid != -1) {
+                std::string comm;
+                uint32_t sigId = URM_SIG_APP_OPEN;
+                uint32_t sigType = DEFAULT_SIGNAL_TYPE;
+                uint32_t ctxDetails = 0U;
                 if(AuxRoutines::fetchComm(ev.pid, comm) != 0) {
                     continue;
                 }
 
-                // Step 1: Figure out workload type
-                int32_t contextType =
-                    this->ClassifyProcess(ev.pid, ev.tgid, comm, ctxDetails);
-				if(contextType == CC_IGNORE) {
-					// Ignore and wait for next event
-					continue;
-				}
-
-                // Identify if any signal configuration exists
-                // Will return the sigID based on the workload
-                // For example: game, browser, multimedia
-                sigId = this->GetSignalIDForWorkload(contextType);
-
-                // Step 2:
+                // Step 1:
                 // Untune any Configurations from the last proc-invocation
-                for(int64_t handle: this->mCurrRestuneHandles) {
-                    if(handle > 0) {
-                        this->untuneRequestHelper(handle);
+                uint64_t currActiveCount = 0;
+                if(!this->mCurrRestuneHandles.empty()) {
+                    currActiveCount =
+                        this->mClientTracker - this->mCurrRestuneHandles.front().first;
+                }
+
+                if(currActiveCount == this->mActiveAppThreshold) {
+                    uint64_t minClientId = this->mCurrRestuneHandles.front().first;
+                    while(!this->mCurrRestuneHandles.empty()) {
+                        if(minClientId == this->mCurrRestuneHandles.front().first) {
+                            this->mCurrRestuneHandles.pop();
+                        } else {
+                            break;
+                        }
                     }
                 }
-                this->mCurrRestuneHandles.clear();
 
-                // Step 3:
+                // Step 2:
                 // - Move the process to focused-cgroup, Also involves removing the process
                 //  already there from the cgroup.
                 // - Move the "threads" from per-app config to appropriate cgroups
                 this->MoveAppThreadsToCGroup(ev.pid, ev.tgid, comm, FOCUSED_CGROUP_IDENTIFIER);
 
-                // Step 4:
+                // Step 3:
                 // Configure any per-app config specified signals.
                 this->configureAppSignals(ev.pid, ev.tgid, comm);
 
-                // Step 5: If the post processing block exists, call it
+                // Step 4: If the post processing block exists, call it
                 // It might provide us a more specific sigID or sigType
                 PostProcessingCallback postCb =
                     Extensions::getPostProcessingCallback(comm);
@@ -237,11 +240,43 @@ void ContextualClassifier::ClassifierMain() {
                     postCb((void*)&postProcessData);
 
                     // Record any Configurations made
-                    if(postProcessData.mHandleAcq != - 1) {
-                        this->mCurrRestuneHandles.push_back(postProcessData.mHandleAcq);
+                    if(postProcessData.mHandleAcq != -1) {
+                        this->mCurrRestuneHandles.push(
+                            {this->mClientTracker, postProcessData.mHandleAcq}
+                        );
+                    }
+                } else {
+                    // Figure out workload type
+                    int32_t contextType =
+                        this->ClassifyProcess(ev.pid, ev.tgid, comm, ctxDetails);
+                    if(contextType == CC_IGNORE) {
+                        // Ignore and wait for next event
+                        continue;
+                    }
+
+                    // Identify if any signal configuration exists
+                    // Will return the sigID based on the workload
+                    // For example: game, browser, multimedia
+                    sigId = this->GetSignalIDForWorkload(contextType);
+    
+                    int64_t handle = acquireSignal(
+                        sigId,
+                        sigType,
+                        ev.pid,
+                        ev.tgid
+                    );
+                    if(handle != -1) {
+                        this->mCurrRestuneHandles.push(
+                            {this->mClientTracker, handle}
+                        );
                     }
                 }
             }
+
+            // Increment client count, this helps in tracking older Requests,
+            // which will need to be untuned once the active threshold is hit.
+            this->mClientTracker++;
+
         } else if(ev.type == CC_APP_CLOSE) {
             // No Action Needed, Pulse Monitor to take care of cleanup
             ClientGarbageCollector::getInstance()->submitClientForCleanup(ev.pid);
@@ -462,7 +497,7 @@ void ContextualClassifier::MoveAppThreadsToCGroup(pid_t incomingPID,
         // Anything to issue
         if(request->getResourcesCount() > 0) {
             // Record:
-            this->mCurrRestuneHandles.push_back(request->getHandle());
+            this->mCurrRestuneHandles.push({this->mClientTracker, request->getHandle()});
 
             // fast path to Request Queue
             submitResProvisionRequest(request, true);
@@ -493,7 +528,7 @@ void ContextualClassifier::configureAppSignals(pid_t incomingPID,
             );
 
             if(handle != -1) {
-                this->mCurrRestuneHandles.push_back(handle);
+                this->mCurrRestuneHandles.push({this->mClientTracker, handle});
             }
         }
     }

contextual-classifier/Include/ContextualClassifier.h

@@ -45,9 +45,11 @@ class ContextualClassifier {
     int8_t mDebugMode = false;
     volatile int8_t mNeedExit = false;
 
+    uint64_t mClientTracker;
+    uint64_t mActiveAppThreshold;
     NetLinkComm mNetLinkComm;
     Inference* mInference;
-    std::vector<int64_t> mCurrRestuneHandles;
+    std::queue<std::pair<uint64_t, int64_t>> mCurrRestuneHandles;
 
     // PID cache to check for duplicates
     MinLRUCache mClassifierPidCache;

modula/Common/Include/Utils.h

@@ -87,6 +87,14 @@ enum TranslationUnit {
     U_GHz = 1000 * 1000 * 1000,
 };
 
+/**
+ * @enum ClassifierOpMode
+ */
+enum ClassifierOpMode {
+    ACCEPT_AND_PERSIST = 0x01,
+    ACCEPT_AND_REPLACE = 0x02,
+};
+
 typedef struct {
     int8_t mModuleID;
     int8_t mRequestType;
@@ -124,6 +132,7 @@ typedef void (*MessageReceivedCallback)(int32_t, MsgForwardInfo*);
 #define LOGGER_LOGGING_LEVEL_TYPE "urm.logging.level.exact"
 #define LOGGER_LOGGING_OUTPUT_REDIRECT "urm.logging.redirect_to"
 #define URM_MAX_PLUGIN_COUNT "urm.extensions_lib.count"
+#define CLASSIFIER_APPLY_MODE "urm.classifier.apply_mode"
 
 #define COMM(pid) ("/proc/" + std::to_string(pid) + "/comm")
 #define COMM_S(pidstr) ("/proc/" + pidstr + "/comm")

modula/CoreModules/Include/UrmSettings.h

@@ -26,6 +26,7 @@ typedef struct {
     double mPenaltyFactor;
     double mRewardFactor;
     uint32_t mPluginCount;
+    uint32_t mAcceptMode;
 } MetaConfigs;
 
 typedef struct {

resource-tuner/init/RestuneInit.cpp

@@ -175,6 +175,16 @@ static ErrCode fetchMetaConfigs() {
         submitPropGetRequest(URM_MAX_PLUGIN_COUNT, resultBuffer, "3");
         UrmSettings::metaConfigs.mPluginCount = (uint32_t)std::stol(resultBuffer);
 
+        // Start classifier in multi-app mode by default
+        UrmSettings::metaConfigs.mAcceptMode = ACCEPT_AND_PERSIST;
+        submitPropGetRequest(CLASSIFIER_APPLY_MODE, resultBuffer, "ACCEPT_AND_PERSIST");
+        std::string mode = std::string(resultBuffer);
+
+        // Move to single-app mode if so configured
+        if(mode == "ACCEPT_AND_REPLACE") {
+            UrmSettings::metaConfigs.mAcceptMode = ACCEPT_AND_REPLACE;
+        }
+
         if(UrmSettings::metaConfigs.mDesiredThreadCount < 1) {
             UrmSettings::metaConfigs.mDesiredThreadCount = 5; // Reset to default
         }