From 561d6f9fa5a619454659e5e62a28120ff7a01c20 Mon Sep 17 00:00:00 2001 From: kartnema Date: Mon, 19 Jan 2026 11:25:28 +0530 Subject: [PATCH 1/4] Dropping requests at classifier based on PPID checks --- .../ContextualClassifier.cpp | 22 +++++++++++++++++++ contextual-classifier/NetLinkComm.cpp | 7 +++--- 2 files changed, 26 insertions(+), 3 deletions(-) diff --git a/contextual-classifier/ContextualClassifier.cpp b/contextual-classifier/ContextualClassifier.cpp index 2d8e04c33..375188b26 100644 --- a/contextual-classifier/ContextualClassifier.cpp +++ b/contextual-classifier/ContextualClassifier.cpp @@ -49,6 +49,28 @@ Inference *ContextualClassifier::GetInferenceObject() { } #endif +static pid_t getParent(pid_t pid) { + std::string statusFile = "/proc/" + std::to_string(pid) + "/status"; + std::ifstream file(statusFile); + std::string line; + + if(!file.is_open()) { + return 0; + } + + while(std::getline(file, line)) { + if(line.rfind("PPid:", 0) == 0) { + std::istringstream iss(line); + std::string label; + pid_t parentPid; + iss >> label >> parentPid; + return parentPid; + } + } + + return 0; +} + ContextualClassifier::ContextualClassifier() { this->mRestuneHandle = -1; this->mOurPid = this->mOurTid = 0; diff --git a/contextual-classifier/NetLinkComm.cpp b/contextual-classifier/NetLinkComm.cpp index 247cdb7d7..89f9bfc7e 100644 --- a/contextual-classifier/NetLinkComm.cpp +++ b/contextual-classifier/NetLinkComm.cpp @@ -12,6 +12,7 @@ #include "ContextualClassifier.h" #define CLASSIFIER_TAG "NetLinkComm" +#define PROCP_THRESH 50 NetLinkComm::NetLinkComm() { this->mNlSock = -1; @@ -98,7 +99,7 @@ int32_t NetLinkComm::recvEvent(ProcEvent &ev) { return 0; } if(rc == -1) { - if (errno == EINTR) { + if(errno == EINTR) { // Caller (ContextualClassifier::HandleProcEv) will handle EINTR. return -1; } @@ -125,7 +126,7 @@ int32_t NetLinkComm::recvEvent(ProcEvent &ev) { ev.type = CC_APP_OPEN; rc = CC_APP_OPEN; - if(!AuxRoutines::fileExists(COMM(ev.pid))) { + if(!AuxRoutines::fileExists(COMM(ev.pid)) || (getParent(ev.pid) <= PROCP_THRESH)) { rc = ev.type = CC_IGNORE; } break; @@ -136,7 +137,7 @@ int32_t NetLinkComm::recvEvent(ProcEvent &ev) { ev.type = CC_APP_CLOSE; rc = CC_APP_CLOSE; - if(!AuxRoutines::fileExists(COMM(ev.pid))) { + if(!AuxRoutines::fileExists(COMM(ev.pid)) || (getParent(ev.pid) <= PROCP_THRESH)) { rc = ev.type = CC_IGNORE; } break; From c93b28213070423a530af6f9d480eb27bbc061b7 Mon Sep 17 00:00:00 2001 From: kartnema Date: Mon, 19 Jan 2026 11:52:47 +0530 Subject: [PATCH 2/4] Minor Changes --- .../ContextualClassifier.cpp | 22 ------------------- contextual-classifier/NetLinkComm.cpp | 22 +++++++++++++++++++ modula/Common/Message.cpp | 4 ++-- 3 files changed, 24 insertions(+), 24 deletions(-) diff --git a/contextual-classifier/ContextualClassifier.cpp b/contextual-classifier/ContextualClassifier.cpp index 375188b26..2d8e04c33 100644 --- a/contextual-classifier/ContextualClassifier.cpp +++ b/contextual-classifier/ContextualClassifier.cpp @@ -49,28 +49,6 @@ Inference *ContextualClassifier::GetInferenceObject() { } #endif -static pid_t getParent(pid_t pid) { - std::string statusFile = "/proc/" + std::to_string(pid) + "/status"; - std::ifstream file(statusFile); - std::string line; - - if(!file.is_open()) { - return 0; - } - - while(std::getline(file, line)) { - if(line.rfind("PPid:", 0) == 0) { - std::istringstream iss(line); - std::string label; - pid_t parentPid; - iss >> label >> parentPid; - return parentPid; - } - } - - return 0; -} - ContextualClassifier::ContextualClassifier() { this->mRestuneHandle = -1; this->mOurPid = this->mOurTid = 0; diff --git a/contextual-classifier/NetLinkComm.cpp b/contextual-classifier/NetLinkComm.cpp index 89f9bfc7e..82ce5db0a 100644 --- a/contextual-classifier/NetLinkComm.cpp +++ b/contextual-classifier/NetLinkComm.cpp @@ -14,6 +14,28 @@ #define CLASSIFIER_TAG "NetLinkComm" #define PROCP_THRESH 50 +static pid_t getParent(pid_t pid) { + std::string statusFile = "/proc/" + std::to_string(pid) + "/status"; + std::ifstream file(statusFile); + std::string line; + + if(!file.is_open()) { + return 0; + } + + while(std::getline(file, line)) { + if(line.rfind("PPid:", 0) == 0) { + std::istringstream iss(line); + std::string label; + pid_t parentPid; + iss >> label >> parentPid; + return parentPid; + } + } + + return 0; +} + NetLinkComm::NetLinkComm() { this->mNlSock = -1; } diff --git a/modula/Common/Message.cpp b/modula/Common/Message.cpp index 3e0607d7e..b7696ebad 100644 --- a/modula/Common/Message.cpp +++ b/modula/Common/Message.cpp @@ -20,7 +20,7 @@ int32_t Message::getClientTID() const { } int8_t Message::getPriority() const { - return (int8_t)(this->mProperties & (((int32_t) 1 << 8)) - 1); + return (int8_t) ((this->mProperties) & (((int32_t)1 << 8) - 1)); } int64_t Message::getDuration() const { @@ -32,7 +32,7 @@ int32_t Message::getProperties() const { } int8_t Message::getProcessingModes() const { - return (int8_t) ((this->mProperties >> 8) & (((int32_t) 1 << 8)) - 1); + return (int8_t) ((this->mProperties >> 8) & (((int32_t)1 << 8) - 1)); } void Message::setRequestType(int8_t reqType) { From 91a696e326e76a4741a10f820a74f13f59eac02f Mon Sep 17 00:00:00 2001 From: kartnema Date: Mon, 19 Jan 2026 17:39:21 +0530 Subject: [PATCH 3/4] Send classifier requests with original proc pid's --- .../ContextualClassifier.cpp | 191 +++++++++--------- .../ContextualClassifierInit.cpp | 5 +- .../Include/ContextualClassifier.h | 7 +- extensions/Include/Extensions.h | 2 +- modula/CoreModules/AuxRoutines.cpp | 1 - 5 files changed, 98 insertions(+), 108 deletions(-) diff --git a/contextual-classifier/ContextualClassifier.cpp b/contextual-classifier/ContextualClassifier.cpp index 2d8e04c33..9ef020a19 100644 --- a/contextual-classifier/ContextualClassifier.cpp +++ b/contextual-classifier/ContextualClassifier.cpp @@ -51,11 +51,10 @@ Inference *ContextualClassifier::GetInferenceObject() { ContextualClassifier::ContextualClassifier() { this->mRestuneHandle = -1; - this->mOurPid = this->mOurTid = 0; mInference = GetInferenceObject(); } -static ContextualClassifier *g_classifier = nullptr; +static ContextualClassifier *gClassifier = nullptr; static const int32_t pendingQueueControlSize = 30; ContextualClassifier::~ContextualClassifier() { @@ -69,10 +68,6 @@ ContextualClassifier::~ContextualClassifier() { ErrCode ContextualClassifier::Init() { LOGI(CLASSIFIER_TAG, "Classifier module init."); - // Record PID and TID - this->mOurPid = getpid(); - this->mOurTid = gettid(); - this->LoadIgnoredProcesses(); // Single worker thread for classification @@ -125,26 +120,30 @@ ErrCode ContextualClassifier::Terminate() { } void ContextualClassifier::ClassifierMain() { - pthread_setname_np(pthread_self(), "uRMClassifierMain"); + pthread_setname_np(pthread_self(), "urmClassifier"); while (true) { ProcEvent ev{}; { - std::unique_lock lock(mQueueMutex); - mQueueCond.wait( - lock, [this] { return !mPendingEv.empty() || mNeedExit; }); + std::unique_lock lock(this->mQueueMutex); + this->mQueueCond.wait( + lock, + [this] { + return !mPendingEv.empty() || this->mNeedExit; + } + ); - if (mNeedExit) { + if(this->mNeedExit) { return; } - ev = mPendingEv.front(); - mPendingEv.pop(); + ev = this->mPendingEv.front(); + this->mPendingEv.pop(); } - if (ev.type == CC_APP_OPEN) { + if(ev.type == CC_APP_OPEN) { std::string comm; uint32_t sigId = CC_APP_OPEN; - uint32_t sigSubtype = DEFAULT_CONFIG; + uint32_t sigType = DEFAULT_SIGNAL_TYPE; uint32_t ctxDetails = 0U; if(ev.pid != -1) { @@ -153,43 +152,42 @@ void ContextualClassifier::ClassifierMain() { } // Step 1: Figure out workload type - int contextType = - ClassifyProcess(ev.pid, ev.tgid, comm, ctxDetails); - if (contextType == CC_IGNORE) { - //ignore and wait for next event + 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 - this->GetSignalDetailsForWorkload(contextType, sigId, sigSubtype); + sigId = this->GetSignalIDForWorkload(contextType); // 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, comm, FOCUSED_CGROUP_IDENTIFIER); + this->MoveAppThreadsToCGroup(ev.pid, ev.tgid, comm, FOCUSED_CGROUP_IDENTIFIER); // Step 3: If the post processing block exists, call it - // It might provide us a more specific sigSubtype - /* + // It might provide us a more specific sigID or sigType PostProcessingCallback postCb = Extensions::getPostProcessingCallback(comm); if(postCb != nullptr) { PostProcessCBData postProcessData = { .mPid = ev.pid, .mSigId = sigId, - .mSigSubtype = sigSubtype, + .mSigType = sigType, }; postCb((void*)&postProcessData); sigId = postProcessData.mSigId; - sigSubtype = postProcessData.mSigSubtype; + sigType = postProcessData.mSigType; } - */ // Step 4: Apply actions, call tuneSignal - this->ApplyActions(sigId, sigSubtype); + this->ApplyActions(sigId, sigType); } } else if (ev.type == CC_APP_CLOSE) { //Step1: move process to original cgroup @@ -215,7 +213,7 @@ int ContextualClassifier::HandleProcEv() { continue; } - if(mNeedExit) { + if(this->mNeedExit) { return 0; } @@ -230,7 +228,6 @@ int ContextualClassifier::HandleProcEv() { switch(rc) { case CC_APP_OPEN: - // TYPELOGV(NOTIFY_CLASSIFIER_PROC_EVENT, "CC_APP_OPEN", ev.pid); if(!this->isIgnoredProcess(ev.type, ev.pid)) { const std::lock_guard lock(mQueueMutex); this->mPendingEv.push(ev); @@ -238,14 +235,11 @@ int ContextualClassifier::HandleProcEv() { this->mPendingEv.pop(); } this->mQueueCond.notify_one(); - } else { - // TYPELOGV(NOTIFY_CLASSIFIER_PROC_IGNORE, ev.pid); } break; case CC_APP_CLOSE: - // TYPELOGV(NOTIFY_CLASSIFIER_PROC_EVENT, "CC_APP_CLOSE", ev.pid); if(!this->isIgnoredProcess(ev.type, ev.pid)) { const std::lock_guard lock(mQueueMutex); this->mPendingEv.push(ev); @@ -253,14 +247,11 @@ int ContextualClassifier::HandleProcEv() { this->mPendingEv.pop(); } this->mQueueCond.notify_one(); - } else { - // TYPELOGV(NOTIFY_CLASSIFIER_PROC_IGNORE, ev.pid); } break; default: - // log error?? break; } } @@ -268,29 +259,30 @@ int ContextualClassifier::HandleProcEv() { return 0; } -int32_t ContextualClassifier::ClassifyProcess(pid_t process_pid, pid_t process_tgid, +int32_t ContextualClassifier::ClassifyProcess(pid_t processPid, + pid_t processTgid, const std::string &comm, uint32_t &ctxDetails) { - (void)process_tgid; + (void)processTgid; (void)ctxDetails; CC_TYPE context = CC_APP; - if(mIgnoredProcesses.count(comm) != 0U) { + if(this->mIgnoredProcesses.count(comm) != 0U) { LOGD(CLASSIFIER_TAG, "Skipping inference for ignored process: "+ comm); return CC_IGNORE; } // Check if the process is still alive - if(!AuxRoutines::fileExists(COMM(process_pid))) { + if(!AuxRoutines::fileExists(COMM(processPid))) { LOGD(CLASSIFIER_TAG, "Skipping inference, process is dead: "+ comm); return CC_IGNORE; } LOGD(CLASSIFIER_TAG, - "Starting classification for PID: "+ std::to_string(process_pid)); - context = mInference->Classify(process_pid); + "Starting classification for PID: "+ std::to_string(processPid)); + context = mInference->Classify(processPid); return context; } @@ -301,33 +293,32 @@ void ContextualClassifier::ApplyActions(uint32_t sigId, uint32_t sigType) { // Call tuneSignal here // tuneSignal and update the handles // mResTunerHandles + + // TODO:: No second level interface for signals exists as of now return; } -void ContextualClassifier::RemoveActions(pid_t process_pid, pid_t process_tgid) { - (void)process_pid; - (void)process_tgid; +void ContextualClassifier::RemoveActions(pid_t processPid, pid_t processTgid) { + (void)processPid; + (void)processTgid; // untuneSignal and erase handles // mResTunerHandles return; } -void ContextualClassifier::GetSignalDetailsForWorkload(int32_t contextType, - uint32_t &sigId, - uint32_t &sigSubtype) { - (void)sigSubtype; - switch (contextType) { - case CC_MULTIMEDIA: - sigId = CC_MULTIMEDIA_APP_OPEN; - break; - case CC_GAME: - sigId = CC_GAME_APP_OPEN; - break; - case CC_BROWSER: - sigId = CC_BROWSER_APP_OPEN; - break; +uint32_t ContextualClassifier::GetSignalIDForWorkload(int32_t contextType) { + switch(contextType) { + case CC_MULTIMEDIA: + return CC_MULTIMEDIA_APP_OPEN; + case CC_GAME: + return CC_GAME_APP_OPEN; + case CC_BROWSER: + return CC_BROWSER_APP_OPEN; + default: + break; } - return; + + return CC_APP_OPEN; } void ContextualClassifier::LoadIgnoredProcesses() { @@ -343,12 +334,14 @@ void ContextualClassifier::LoadIgnoredProcesses() { std::string segment; while (std::getline(ss, segment, ',')) { size_t first = segment.find_first_not_of(" \t\n\r"); - if (first == std::string::npos) + if(first == std::string::npos) { continue; + } + size_t last = segment.find_last_not_of(" \t\n\r"); segment = segment.substr(first, (last - first + 1)); - if (!segment.empty()) { - mIgnoredProcesses.insert(segment); + if(!segment.empty()) { + this->mIgnoredProcesses.insert(segment); } } } @@ -364,19 +357,19 @@ int8_t ContextualClassifier::isIgnoredProcess(int32_t evType, pid_t pid) { } // For context open, check if comm is in ignored list and track pid. - std::string comm_path = COMM(pid); - std::ifstream comm_file(comm_path); - if (comm_file.is_open()) { - std::string proc_name; - std::getline(comm_file, proc_name); + std::string commPath = COMM(pid); + std::ifstream commFile(commPath); + if (commFile.is_open()) { + std::string procName; + std::getline(commFile, procName); // Trim - size_t first = proc_name.find_first_not_of(" \t\n\r"); + size_t first = procName.find_first_not_of(" \t\n\r"); if (first != std::string::npos) { - size_t last = proc_name.find_last_not_of(" \t\n\r"); - proc_name = proc_name.substr(first, (last - first + 1)); + size_t last = procName.find_last_not_of(" \t\n\r"); + procName = procName.substr(first, (last - first + 1)); } - if (mIgnoredProcesses.count(proc_name) != 0U) { - LOGD(CLASSIFIER_TAG, "Ignoring process: " + proc_name); + if (this->mIgnoredProcesses.count(procName) != 0U) { + LOGD(CLASSIFIER_TAG, "Ignoring process: " + procName); ignore = true; } } else { @@ -400,9 +393,9 @@ ResIterable* ContextualClassifier::createMovePidResource(int32_t cGroupdId, pid_ } void ContextualClassifier::MoveAppThreadsToCGroup(pid_t incomingPID, + pid_t incomingTID, const std::string& comm, int32_t cgroupIdentifier) { - (void)comm; try { // Check for any outstanding request, if found untune it. if(this->mRestuneHandle != -1) { @@ -418,8 +411,8 @@ void ContextualClassifier::MoveAppThreadsToCGroup(pid_t incomingPID, // not free up the underlying Request object, allowing for reuse. // Priority Level: -2 is used to force server termination and cleanup so should not be used otherwise. untuneRequest->setPriority(SYSTEM_HIGH); - untuneRequest->setClientPID(mOurPid); - untuneRequest->setClientTID(mOurTid); + untuneRequest->setClientPID(incomingPID); + untuneRequest->setClientTID(incomingTID); // fast path to Request Queue // Mark verification status as true. Request still goes through RequestManager though. @@ -435,27 +428,27 @@ void ContextualClassifier::MoveAppThreadsToCGroup(pid_t incomingPID, request->setHandle(this->mRestuneHandle); request->setDuration(-1); request->setPriority(SYSTEM_LOW); - request->setClientPID(this->mOurPid); - request->setClientTID(this->mOurTid); + request->setClientPID(incomingPID); + request->setClientTID(incomingTID); // Move the incoming pid ResIterable* resIter = this->createMovePidResource(cgroupIdentifier, incomingPID); request->addResource(resIter); - // AppConfig* appConfig = AppConfigs::getInstance()->getAppConfig(comm); - // if(appConfig != nullptr && appConfig->mThreadNameList != nullptr) { - // int32_t numThreads = appConfig->mNumThreads; - // // Go over the list of proc names (comm) and get their pids - // for(int32_t i = 0; i < numThreads; i++) { - // std::string targetComm = appConfig->mThreadNameList[i]; - // pid_t targetPID = this->fetchPid(targetComm); - // if(targetPID != -1 && targetPID != incomingPID) { - // // Get the CGroup - // int32_t currCGroupID = appConfig->mCGroupIds[i]; - // request->addResource(createMovePidResource(currCGroupID, targetPID)); - // } - // } - // } + AppConfig* appConfig = AppConfigs::getInstance()->getAppConfig(comm); + if(appConfig != nullptr && appConfig->mThreadNameList != nullptr) { + int32_t numThreads = appConfig->mNumThreads; + // Go over the list of proc names (comm) and get their pids + for(int32_t i = 0; i < numThreads; i++) { + std::string targetComm = appConfig->mThreadNameList[i]; + pid_t targetPID = AuxRoutines::fetchPid(targetComm); + if(targetPID != -1 && targetPID != incomingPID) { + // Get the CGroup + int32_t currCGroupID = appConfig->mCGroupIds[i]; + request->addResource(createMovePidResource(currCGroupID, targetPID)); + } + } + } // Anything to issue if(request->getResourcesCount() > 0) { @@ -476,18 +469,18 @@ void ContextualClassifier::MoveAppThreadsToCGroup(pid_t incomingPID, // Public C interface exported from the contextual-classifier shared library. // These are what the URM module entrypoints will call. extern "C" ErrCode cc_init(void) { - if (!g_classifier) { - g_classifier = new ContextualClassifier(); + if(gClassifier == nullptr) { + gClassifier = new ContextualClassifier(); } - return g_classifier->Init(); + return gClassifier->Init(); } extern "C" ErrCode cc_terminate(void) { - if (g_classifier) { - ErrCode rc = g_classifier->Terminate(); - delete g_classifier; - g_classifier = nullptr; - return rc; + if(gClassifier != nullptr) { + ErrCode opStatus = gClassifier->Terminate(); + delete gClassifier; + gClassifier = nullptr; + return opStatus; } return RC_SUCCESS; } diff --git a/contextual-classifier/ContextualClassifierInit.cpp b/contextual-classifier/ContextualClassifierInit.cpp index 7ab6276d1..d0e266be1 100644 --- a/contextual-classifier/ContextualClassifierInit.cpp +++ b/contextual-classifier/ContextualClassifierInit.cpp @@ -1,12 +1,13 @@ // Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries. // SPDX-License-Identifier: BSD-3-Clause-Clear -#include "ComponentRegistry.h" -#include "Logger.h" #include #include #include +#include "Logger.h" +#include "ComponentRegistry.h" + // Helper function from ContextualClassifier to format strings static std::string format_string(const char *fmt, ...) { char buffer[1024]; diff --git a/contextual-classifier/Include/ContextualClassifier.h b/contextual-classifier/Include/ContextualClassifier.h index 98fdd8f7f..99bfabcd2 100644 --- a/contextual-classifier/Include/ContextualClassifier.h +++ b/contextual-classifier/Include/ContextualClassifier.h @@ -52,8 +52,6 @@ struct ProcEvent { class ContextualClassifier { private: - pid_t mOurPid; - pid_t mOurTid; int64_t mRestuneHandle; int8_t mDebugMode = false; volatile int8_t mNeedExit = false; @@ -81,9 +79,7 @@ class ContextualClassifier { uint32_t &ctxDetails); // Fetch signal configuration info - void GetSignalDetailsForWorkload(int32_t contextType, - uint32_t &sigId, - uint32_t &sigSubtype); + uint32_t GetSignalIDForWorkload(int32_t contextType); // Methods for tuning / untuning signals based on the workload void ApplyActions(uint32_t sigId, uint32_t sigType); @@ -100,6 +96,7 @@ class ContextualClassifier { // Helper methods to move the current process to focused-cgroup ResIterable* createMovePidResource(int32_t cGroupdId, pid_t pid); void MoveAppThreadsToCGroup(pid_t incomingPID, + pid_t incomingTID, const std::string& comm, int32_t cgroupIdentifier); diff --git a/extensions/Include/Extensions.h b/extensions/Include/Extensions.h index cfba9335d..5a53b380c 100644 --- a/extensions/Include/Extensions.h +++ b/extensions/Include/Extensions.h @@ -19,7 +19,7 @@ typedef void (*PostProcessingCallback)(void*); typedef struct { pid_t mPid; uint32_t mSigId; - uint32_t mSigSubtype; + uint32_t mSigType; } PostProcessCBData; /** diff --git a/modula/CoreModules/AuxRoutines.cpp b/modula/CoreModules/AuxRoutines.cpp index 8372ae413..d4476061d 100644 --- a/modula/CoreModules/AuxRoutines.cpp +++ b/modula/CoreModules/AuxRoutines.cpp @@ -134,7 +134,6 @@ pid_t AuxRoutines::fetchPid(const std::string& process_name) { int32_t AuxRoutines::fetchComm(pid_t pid, std::string &comm) { std::string proc_path = "/proc/" + std::to_string(pid); if(!AuxRoutines::fileExists(proc_path)) { - LOGD("URM_AUX_ROUTINE", "Process %d has exited." + std::to_string(pid)); return -1; } From b0f1c4fbeb1f734de6576b9a9697f0012aa2c8e2 Mon Sep 17 00:00:00 2001 From: kartnema Date: Tue, 20 Jan 2026 13:19:06 +0530 Subject: [PATCH 4/4] Cleanup --- .../ContextualClassifier.cpp | 28 +++++++++---------- modula/Common/Include/Common.h | 3 -- modula/CoreModules/Include/AuxRoutines.h | 1 + modula/CoreModules/Include/UrmSettings.h | 1 + modula/CoreModules/UrmSettings.cpp | 3 +- resource-tuner/init/RestuneInit.cpp | 3 +- 6 files changed, 19 insertions(+), 20 deletions(-) diff --git a/contextual-classifier/ContextualClassifier.cpp b/contextual-classifier/ContextualClassifier.cpp index 9ef020a19..e7f03b166 100644 --- a/contextual-classifier/ContextualClassifier.cpp +++ b/contextual-classifier/ContextualClassifier.cpp @@ -92,28 +92,28 @@ ErrCode ContextualClassifier::Init() { ErrCode ContextualClassifier::Terminate() { LOGI(CLASSIFIER_TAG, "Classifier module terminate."); - if (mNetLinkComm.getSocket() != -1) { - mNetLinkComm.setListen(false); + if (this->mNetLinkComm.getSocket() != -1) { + this->mNetLinkComm.setListen(false); } { - std::unique_lock lock(mQueueMutex); - mNeedExit = true; + std::unique_lock lock(this->mQueueMutex); + this->mNeedExit = true; // Clear any pending PIDs so the worker doesn't see stale entries - while (!mPendingEv.empty()) { - mPendingEv.pop(); + while (!this->mPendingEv.empty()) { + this->mPendingEv.pop(); } } - mQueueCond.notify_all(); + this->mQueueCond.notify_all(); - mNetLinkComm.closeSocket(); + this->mNetLinkComm.closeSocket(); - if (mNetlinkThread.joinable()) { - mNetlinkThread.join(); + if (this->mNetlinkThread.joinable()) { + this->mNetlinkThread.join(); } - if (mClassifierMain.joinable()) { - mClassifierMain.join(); + if (this->mClassifierMain.joinable()) { + this->mClassifierMain.join(); } return RC_SUCCESS; @@ -199,7 +199,7 @@ void ContextualClassifier::ClassifierMain() { } int ContextualClassifier::HandleProcEv() { - pthread_setname_np(pthread_self(), "ClassNetlink"); + pthread_setname_np(pthread_self(), "urmNetlinkListener"); int32_t rc = 0; while(!mNeedExit) { @@ -269,7 +269,7 @@ int32_t ContextualClassifier::ClassifyProcess(pid_t processPid, if(this->mIgnoredProcesses.count(comm) != 0U) { LOGD(CLASSIFIER_TAG, - "Skipping inference for ignored process: "+ comm); + "Skipping inference for ignored process: " + comm); return CC_IGNORE; } diff --git a/modula/Common/Include/Common.h b/modula/Common/Include/Common.h index 4f9b29265..0c9c85439 100644 --- a/modula/Common/Include/Common.h +++ b/modula/Common/Include/Common.h @@ -19,9 +19,6 @@ // Used to define the new config value, relative to the already configured value #define OPT_WITHREL 0X00000004 -// Stores name of focused slice -#define FOCUSED_SLICE "focused.slice" - /** * @struct SysResource * @brief Used to store information regarding Resources / Tunables which need to be diff --git a/modula/CoreModules/Include/AuxRoutines.h b/modula/CoreModules/Include/AuxRoutines.h index 6a9991678..0e126ff40 100644 --- a/modula/CoreModules/Include/AuxRoutines.h +++ b/modula/CoreModules/Include/AuxRoutines.h @@ -12,6 +12,7 @@ #include #include #include +#include #include "Logger.h" #include "Request.h" diff --git a/modula/CoreModules/Include/UrmSettings.h b/modula/CoreModules/Include/UrmSettings.h index 160da0502..3d8d6ed55 100644 --- a/modula/CoreModules/Include/UrmSettings.h +++ b/modula/CoreModules/Include/UrmSettings.h @@ -68,6 +68,7 @@ class UrmSettings { static const std::string mDeviceNamePath; static const std::string mBaseCGroupPath; + static const std::string focusedCgroup; static const std::string mPersistenceFile; diff --git a/modula/CoreModules/UrmSettings.cpp b/modula/CoreModules/UrmSettings.cpp index c1685e4b5..28e27924f 100644 --- a/modula/CoreModules/UrmSettings.cpp +++ b/modula/CoreModules/UrmSettings.cpp @@ -41,9 +41,10 @@ const std::string UrmSettings::mExtensionsPluginLibPath = const std::string UrmSettings::mDeviceNamePath = "/sys/devices/soc0/machine"; - const std::string UrmSettings::mBaseCGroupPath = "/sys/fs/cgroup/"; +const std::string UrmSettings::focusedCgroup = + "focused.slice"; const std::string UrmSettings::mPersistenceFile = "/etc/urm/data/resource_original_values.txt"; diff --git a/resource-tuner/init/RestuneInit.cpp b/resource-tuner/init/RestuneInit.cpp index 3a841f341..04a80ba3e 100644 --- a/resource-tuner/init/RestuneInit.cpp +++ b/resource-tuner/init/RestuneInit.cpp @@ -410,11 +410,10 @@ static void configureFocusedSlice() { const char *cgroupParam[][2] = { { "cgroup.max.depth", "3" }, { "cgroup.max.descendants", "10" }, - // { "pids.max", "100" }, }; for (size_t i = 0; i < sizeof(cgroupParam)/sizeof(cgroupParam[0]); i++) { - setCgroupParam(FOCUSED_SLICE, cgroupParam[i][0], cgroupParam[i][1]); + setCgroupParam(UrmSettings::focusedCgroup.c_str(), cgroupParam[i][0], cgroupParam[i][1]); } }