Merge branch 'main' of https://github.com/kartnema/resource-tuner into dev/classifier-app-persistence

Author: kartnema

configs/ResourcesConfig.yaml

@@ -142,6 +142,16 @@ ResourceConfigs:
     Policy: "lower_is_better"
     ApplyType: "cluster"
 
+  - ResType: "0x04"
+    ResID: "0x0003"
+    Name: "RES_CPU_ONLINE_PER_CORE"
+    Path: "/sys/devices/system/cpu/cpu%d/online"
+    Supported: true
+    Permissions: "third_party"
+    Modes: ["display_on", "doze"]
+    Policy: "instant_apply"
+    ApplyType: "core"
+
   - ResType: "0x05"
     ResID: "0x0000"
     Name: "RES_DEVFREQ_GPU_MAX"

contextual-classifier/ContextualClassifier.cpp

@@ -19,6 +19,7 @@
 #include "Extensions.h"
 #include "AuxRoutines.h"
 #include "UrmPlatformAL.h"
+#include "SignalInternal.h"
 #include "SignalRegistry.h"
 #include "RestuneInternal.h"
 #include "ContextualClassifier.h"
@@ -97,67 +98,6 @@ static ResIterable* createMovePidResource(int32_t cGroupdId, pid_t pid) {
     return resIterable;
 }
 
-static Request* createTuneRequestFromSignal(uint32_t sigId,
-                                            uint32_t sigType,
-                                            pid_t incomingPID,
-                                            pid_t incomingTID,
-                                            int32_t numArgs,
-                                            int32_t* args) {
-    try {
-        std::shared_ptr<SignalRegistry> sigRegistry = SignalRegistry::getInstance();
-
-        // Check if a Signal with the given ID exists in the Registry
-        SignalInfo* signalInfo = sigRegistry->getSignalConfigById(sigId, sigType);
-
-        if(signalInfo == nullptr) return nullptr;
-
-        Request* request = MPLACED(Request);
-
-        int64_t handleGenerated = AuxRoutines::generateUniqueHandle();
-        request->setHandle(handleGenerated);
-
-        request->setRequestType(REQ_RESOURCE_TUNING);
-        request->setDuration(signalInfo->mTimeout);
-        request->setProperties(SYSTEM_HIGH);
-        request->setClientPID(incomingPID);
-        request->setClientTID(incomingTID);
-
-        std::vector<Resource*>* signalLocks = signalInfo->mSignalResources;
-
-        for(int32_t i = 0; i < (int32_t)signalLocks->size(); i++) {
-            if((*signalLocks)[i] == nullptr) {
-                continue;
-            }
-
-            // Copy
-            Resource* resource = MPLACEV(Resource, (*((*signalLocks)[i])));
-
-            // fill placeholders if any
-            int32_t listIndex = 0;
-            for(int32_t j = 0; j < resource->getValuesCount(); j++) {
-                if(resource->getValueAt(j) == -1) {
-                    if(args == nullptr) return nullptr;
-                    if(listIndex >= 0 && listIndex < numArgs) {
-                        resource->setValueAt(j, args[listIndex]);
-                        listIndex++;
-                    }
-                }
-            }
-
-            ResIterable* resIterable = MPLACED(ResIterable);
-            resIterable->mData = resource;
-            request->addResource(resIterable);
-        }
-
-        return request;
-
-    } catch(const std::bad_alloc& e) {
-        return nullptr;
-    }
-
-    return nullptr;
-}
-
 ContextualClassifier::~ContextualClassifier() {
     this->Terminate();
     if(this->mInference) {
@@ -242,8 +182,6 @@ void ContextualClassifier::ClassifierMain() {
             std::string comm;
             uint32_t sigId = URM_SIG_APP_OPEN;
             uint32_t sigType = DEFAULT_SIGNAL_TYPE;
-            int32_t numArgs = 0;
-            int32_t* args = nullptr;
             uint32_t ctxDetails = 0U;
 
             if(ev.pid != -1) {
@@ -294,19 +232,17 @@ void ContextualClassifier::ClassifierMain() {
                         .mPid = ev.pid,
                         .mSigId = sigId,
                         .mSigType = sigType,
-                        .mNumArgs = numArgs,
-                        .mArgs = args,
+                        .mNumArgs = 0,
+                        .mArgs = nullptr,
+                        .mHandleAcq = -1,
                     };
                     postCb((void*)&postProcessData);
 
-                    sigId = postProcessData.mSigId;
-                    sigType = postProcessData.mSigType;
-                    numArgs = postProcessData.mNumArgs;
-                    args = postProcessData.mArgs;
+                    // Record any Configurations made
+                    if(postProcessData.mHandleAcq != - 1) {
+                        this->mCurrRestuneHandles.push_back(postProcessData.mHandleAcq);
+                    }
                 }
-
-                // Apply actions, call tuneSignal
-                this->ApplyActions(sigId, sigType, ev.pid, ev.tgid, numArgs, args);
             }
         } else if(ev.type == CC_APP_CLOSE) {
             // No Action Needed, Pulse Monitor to take care of cleanup
@@ -407,35 +343,6 @@ int32_t ContextualClassifier::ClassifyProcess(pid_t processPid,
     return context;
 }
 
-void ContextualClassifier::ApplyActions(uint32_t sigId,
-                                        uint32_t sigType,
-                                        pid_t incomingPID,
-                                        pid_t incomingTID,
-                                        int32_t numArgs,
-                                        int32_t* args) {
-    Request* request =
-        createTuneRequestFromSignal(sigId, sigType, incomingPID, incomingTID, numArgs, args);
-    if(request != nullptr) {
-        if(request->getResourcesCount() > 0) {
-            // Record:
-            this->mCurrRestuneHandles.push_back(request->getHandle());
-
-            // fast path to Request Queue
-            submitResProvisionRequest(request, false);
-
-        } else {
-            Request::cleanUpRequest(request);
-        }
-    }
-}
-
-void ContextualClassifier::RemoveActions(pid_t processPid, pid_t processTgid) {
-	(void)processPid;
-    (void)processTgid;
-
-    return;
-}
-
 uint32_t ContextualClassifier::GetSignalIDForWorkload(int32_t contextType) {
     switch(contextType) {
         case CC_MULTIMEDIA:
@@ -498,7 +405,7 @@ int8_t ContextualClassifier::shouldProcBeIgnored(int32_t evType, pid_t pid) {
     }
 
     std::string procName = "";
-    if(!AuxRoutines::getProcName(pid, procName)) {
+    if(AuxRoutines::fetchComm(pid, procName) != 0) {
         return true;
     }
 
@@ -575,36 +482,22 @@ void ContextualClassifier::MoveAppThreadsToCGroup(pid_t incomingPID,
 void ContextualClassifier::configureAppSignals(pid_t incomingPID,
                                                pid_t incomingTID,
                                                const std::string& comm) {
-    try {
-        // Configure any associated signal
-        AppConfig* appConfig = AppConfigs::getInstance()->getAppConfig(comm);
-        if(appConfig != nullptr && appConfig->mSignalCodes != nullptr) {
-            int32_t numSignals = appConfig->mNumSignals;
-            // Go over the list of proc names (comm) and get their pids
-            for(int32_t i = 0; i < numSignals; i++) {
-                Request* request = createTuneRequestFromSignal(
-                    appConfig->mSignalCodes[i],
-                    0,
-                    incomingPID,
-                    incomingTID,
-                    0,
-                    nullptr);
-
-                if(request != nullptr) {
-                    if(request->getResourcesCount() > 0) {
-                        // fast path to Request Queue
-                        this->mCurrRestuneHandles.push_back(request->getHandle());
-                        submitResProvisionRequest(request, false);
-
-                    } else {
-                        Request::cleanUpRequest(request);
-                    }
-                }
+    // Configure any associated signal
+    AppConfig* appConfig = AppConfigs::getInstance()->getAppConfig(comm);
+    if(appConfig != nullptr && appConfig->mSignalCodes != nullptr) {
+        // Go over the list of proc names (comm) and get their pids
+        for(int32_t i = 0; i < appConfig->mNumSignals; i++) {
+            int64_t handle = acquireSignal(
+                appConfig->mSignalCodes[i],
+                0,
+                incomingPID,
+                incomingTID
+            );
+
+            if(handle != -1) {
+                this->mCurrRestuneHandles.push_back(handle);
             }
         }
-    } catch(const std::exception& e) {
-        LOGE(CLASSIFIER_TAG,
-             "Failed to acquire per-app config signal, Error: " + std::string(e.what()));
     }
 }
 

contextual-classifier/Include/ContextualClassifier.h

@@ -74,15 +74,6 @@ class ContextualClassifier {
     // Fetch signal configuration info
     uint32_t GetSignalIDForWorkload(int32_t contextType);
 
-    // Methods for tuning / untuning signals based on the workload
-    void ApplyActions(uint32_t sigId,
-                      uint32_t sigType,
-                      pid_t incomingPID,
-                      pid_t incomingTID,
-                      int32_t numArgs,
-                      int32_t* arg);
-    void RemoveActions(pid_t pid, int32_t tgid);
-
     // blacklisting mechanism
     void LoadIgnoredProcesses();
     int8_t shouldProcBeIgnored(int32_t evType, pid_t pid);

docs/README.md

@@ -247,6 +247,7 @@ The following resource codes are supported resources or operations on upstream L
 |   RES_SCALE_MIN_FREQ                |   0x 00 04 0000   |
 |   RES_SCALE_MAX_FREQ                |   0x 00 04 0001   |
 |   RES_RATE_LIMIT_US                 |   0x 00 04 0002   |
+|   RES_CPU_ONLINE_PER_CORE           |   0x 00 04 0003   |
 |   RES_DEVFREQ_GPU_MAX               |   0x 00 05 0000   |
 |   RES_DEVFREQ_GPU_MIN               |   0x 00 05 0001   |
 |   RES_DEVFREQ_GPU_POLL_INTV         |   0x 00 05 0002   |

extensions/Include/Extensions.h

@@ -24,7 +24,8 @@ typedef struct {
     uint32_t mSigId;
     uint32_t mSigType;
     int32_t mNumArgs;
-    int32_t* mArgs;
+    uint32_t* mArgs;
+    int64_t mHandleAcq;
 } PostProcessCBData;
 
 /**

modula/Common/Include/UrmPlatformAL.h

@@ -166,9 +166,10 @@ enum Modes {
 X(RES_SCALE_MIN_FREQ,         0x00040000) \
 X(RES_SCALE_MAX_FREQ,         0x00040001) \
 X(RES_RATE_LIMIT_US,          0x00040002) \
-X(RES_CPU_IDLE_DISABLE_ST0,   0x00040003) \
-X(RES_CPU_IDLE_DISABLE_ST1,   0x00040004) \
-X(RES_CPU_IDLE_DISABLE_ST2,   0x00040005) \
+X(RES_CPU_ONLINE_PER_CORE,    0x00040003) \
+X(RES_CPU_IDLE_DISABLE_ST0,   0x00010002) \
+X(RES_CPU_IDLE_DISABLE_ST1,   0x00010003) \
+X(RES_CPU_IDLE_DISABLE_ST2,   0x00010004) \
 X(RES_SCHED_UTIL_CLAMP_MIN,   0x00030000) \
 X(RES_SCHED_UTIL_CLAMP_MAX,   0x00030001) \
 X(RES_SCHED_ENERGY_AWARE,     0x00030002) \

modula/CoreModules/AuxRoutines.cpp

@@ -131,50 +131,6 @@ pid_t AuxRoutines::fetchPid(const std::string& process_name) {
     return -1;
 }
 
-int8_t AuxRoutines::getProcName(pid_t pid, std::string& procName) {
-    std::string cmdlinePath = "/proc/" + std::to_string(pid) + "/cmdline";
-    std::ifstream cmdlineFile(cmdlinePath);
-    
-    if(cmdlineFile.is_open()) {
-        std::string cmdline;
-        std::getline(cmdlineFile, cmdline, '\0');
-        
-        if(!cmdline.empty()) {
-            size_t lastSlash = cmdline.find_last_of('/');
-            if(lastSlash != std::string::npos) {
-                procName = cmdline.substr(lastSlash + 1);
-            } else {
-                procName = cmdline;
-            }
-            
-            size_t first = procName.find_first_not_of(" \t\n\r");
-            if(first != std::string::npos) {
-                size_t last = procName.find_last_not_of(" \t\n\r");
-                procName = procName.substr(first, (last - first + 1));
-            }
-            
-            return true;
-        }
-    }
-
-    std::string commPath = "/proc/" + std::to_string(pid) + "/comm";
-    std::ifstream commFile(commPath);
-    
-    if(commFile.is_open()) {
-        std::string processName;
-        std::getline(commFile, processName);
-
-        size_t first = processName.find_first_not_of(" \t\n\r");
-        if(first != std::string::npos) {
-            size_t last = processName.find_last_not_of(" \t\n\r");
-            procName = processName.substr(first, (last - first + 1));
-            return true;
-        }
-    }
-
-    return false;
-}
-
 int32_t AuxRoutines::fetchComm(pid_t pid, std::string &comm) {
     std::string proc_path = "/proc/" + std::to_string(pid);
     if(!AuxRoutines::fileExists(proc_path)) {

modula/CoreModules/Include/AuxRoutines.h

@@ -38,7 +38,6 @@ class AuxRoutines {
     static int8_t isNumericString(const std::string& str);
 	static pid_t fetchPid(const std::string& processName);
     static int32_t fetchComm(pid_t pid, std::string &comm);
-    static int8_t getProcName(pid_t pid, std::string& procName);
 
     static int64_t generateUniqueHandle();
     static int64_t getCurrentTimeInMilliseconds();

resource-tuner/CMakeLists.txt

@@ -64,6 +64,7 @@ install(TARGETS RestuneCore LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
 set(HEADER_FILES "")
 list(APPEND HEADER_FILES
   ${CMAKE_CURRENT_SOURCE_DIR}/core/Include/ResourceRegistry.h
+  ${CMAKE_CURRENT_SOURCE_DIR}/signals/Include/SignalInternal.h
   ${CMAKE_CURRENT_SOURCE_DIR}/core/Include/TargetRegistry.h
 )
 

resource-tuner/init/Include/RestuneParser.h

@@ -105,6 +105,10 @@
 #define SIGNAL_CONFIGS_ELEM_RESOURCE_CODE "ResCode"
 #define SIGNAL_CONFIGS_ELEM_RESOURCE_RESINFO "ResInfo"
 #define SIGNAL_CONFIGS_ELEM_RESOURCE_VALUES "Values"
+#define SIGNAL_CONFIGS_ELEM_EXTRA_ATTRS "ExtraAttrs"
+#define SIGNAL_CONFIGS_ELEM_FPS "Fps"
+#define SIGNAL_CONFIGS_ELEM_HEIGHT "Height"
+#define SIGNAL_CONFIGS_ELEM_WIDTH "Width"
 
 // Ext-Features
 #define EXT_FEATURE_CONFIGS_ROOT "FeatureConfigs"