rebalance_interrupts: Run through clang-format

Change-Id: I76495309d747349077fef7980864fc794807723a

Author: bgcngm

rebalance_interrupts/rebalance_interrupts.cpp

@@ -35,8 +35,8 @@
  *
  */
 
-#include <sys/types.h>
 #include <dirent.h>
+#include <sys/types.h>
 
 #include <iostream>
 #include <list>
@@ -51,7 +51,6 @@
 #include <android-base/parseint.h>
 #include <android-base/strings.h>
 
-
 #define POLICY0_CORES_PATH "/sys/devices/system/cpu/cpufreq/policy0/affected_cpus"
 #define SYSFS_IRQDIR "/sys/kernel/irq"
 #define PROC_IRQDIR "/proc/irq"
@@ -70,158 +69,147 @@ using std::vector;
 // Return a vector of strings describing the affected CPUs for cpufreq
 // Policy 0.
 vector<int> Policy0AffectedCpus() {
-  string policy0_cores_unparsed;
-  if (!ReadFileToString(POLICY0_CORES_PATH, &policy0_cores_unparsed))
-    return vector<int>();
-  string policy0_trimmed = android::base::Trim(policy0_cores_unparsed);
-  vector<string> cpus_as_string = android::base::Split(policy0_trimmed, " ");
-
-  vector<int> cpus_as_int;
-  for (int i = 0; i < cpus_as_string.size(); ++i) {
-    int cpu;
-    if (!ParseInt(cpus_as_string[i].c_str(), &cpu))
-      return vector<int>();
-    cpus_as_int.push_back(cpu);
-  }
-  return cpus_as_int;
+    string policy0_cores_unparsed;
+    if (!ReadFileToString(POLICY0_CORES_PATH, &policy0_cores_unparsed)) return vector<int>();
+    string policy0_trimmed = android::base::Trim(policy0_cores_unparsed);
+    vector<string> cpus_as_string = android::base::Split(policy0_trimmed, " ");
+
+    vector<int> cpus_as_int;
+    for (int i = 0; i < cpus_as_string.size(); ++i) {
+        int cpu;
+        if (!ParseInt(cpus_as_string[i].c_str(), &cpu)) return vector<int>();
+        cpus_as_int.push_back(cpu);
+    }
+    return cpus_as_int;
 }
 
 // Return a vector of strings describing the CPU masks for cpufreq Policy 0.
 vector<string> Policy0CpuMasks() {
-  vector<int> cpus = Policy0AffectedCpus();
-  vector<string> cpu_masks;
-  for (int i = 0; i < cpus.size(); ++i)
-    cpu_masks.push_back(fmt::format("{0:02x}", 1 << cpus[i]));
-  return cpu_masks;
+    vector<int> cpus = Policy0AffectedCpus();
+    vector<string> cpu_masks;
+    for (int i = 0; i < cpus.size(); ++i) cpu_masks.push_back(fmt::format("{0:02x}", 1 << cpus[i]));
+    return cpu_masks;
 }
 
 // Read the actions for the given irq# from sysfs, and add it to action_to_irq
-bool AddEntryToIrqmap(const char* irq,
-                      map<string, list<string>>& action_to_irqs) {
-  const string irq_base(SYSFS_IRQDIR "/");
-  string irq_actions_path = irq_base + irq + "/actions";
+bool AddEntryToIrqmap(const char* irq, map<string, list<string>>& action_to_irqs) {
+    const string irq_base(SYSFS_IRQDIR "/");
+    string irq_actions_path = irq_base + irq + "/actions";
 
-  string irq_actions;
-  if (!ReadFileToString(irq_actions_path, &irq_actions))
-    return false;
+    string irq_actions;
+    if (!ReadFileToString(irq_actions_path, &irq_actions)) return false;
 
-  irq_actions = Trim(irq_actions);
+    irq_actions = Trim(irq_actions);
 
-  if (irq_actions == "(null)")
-    irq_actions = "";
+    if (irq_actions == "(null)") irq_actions = "";
 
-  action_to_irqs[irq_actions].push_back(irq);
+    action_to_irqs[irq_actions].push_back(irq);
 
-  return true;
+    return true;
 }
 
 // Get a mapping of driver "action" to IRQ#s for each IRQ# in
 // SYSFS_IRQDIR.
 bool GetIrqmap(map<string, list<string>>& action_to_irqs) {
-  bool some_success = false;
-  std::unique_ptr<DIR, decltype(&closedir)> irq_dir(opendir(SYSFS_IRQDIR), closedir);
-  if (!irq_dir) {
-    PLOG(ERROR) << "opening dir " SYSFS_IRQDIR;
-    return false;
-  }
-
-  struct dirent* entry;
-  while ((entry = readdir(irq_dir.get()))) {
-
-    // If the directory entry isn't a parsable number, skip it.
-    // . and .. get skipped here.
-    unsigned throwaway;
-    if (!ParseUint(entry->d_name, &throwaway))
-      continue;
-
-    some_success |= AddEntryToIrqmap(entry->d_name, action_to_irqs);
-  }
-  return some_success;
+    bool some_success = false;
+    std::unique_ptr<DIR, decltype(&closedir)> irq_dir(opendir(SYSFS_IRQDIR), closedir);
+    if (!irq_dir) {
+        PLOG(ERROR) << "opening dir " SYSFS_IRQDIR;
+        return false;
+    }
+
+    struct dirent* entry;
+    while ((entry = readdir(irq_dir.get()))) {
+        // If the directory entry isn't a parsable number, skip it.
+        // . and .. get skipped here.
+        unsigned throwaway;
+        if (!ParseUint(entry->d_name, &throwaway)) continue;
+
+        some_success |= AddEntryToIrqmap(entry->d_name, action_to_irqs);
+    }
+    return some_success;
 }
 
 // Given a map of irq actions -> IRQs,
 // find out which ones haven't been assigned and add those to
 // rebalance_actions.
 void FindUnassignedIrqs(const map<string, list<string>>& action_to_irqs,
                         list<pair<string, list<string>>>& rebalance_actions) {
-  for (const auto &action_to_irqs_entry: action_to_irqs) {
-    bool rebalance = true;
-    for (const auto& irq: action_to_irqs_entry.second) {
-      string smp_affinity;
-      string proc_path(PROC_IRQDIR "/");
-      proc_path += irq + "/smp_affinity";
-      ReadFileToString(proc_path, &smp_affinity);
-      smp_affinity = Trim(smp_affinity);
-
-      // Try to respect previoulsy set IRQ affinities.
-      // On ARM interrupt controllers under Linux, if an IRQ is assigned
-      // to more than one core it will only be assigned to the lowest core.
-      // Assume any IRQ which is set to more than one core in the lowest four
-      // CPUs hasn't been assigned and needs to be rebalanced.
-      if (smp_affinity.back() == '0' ||
-          smp_affinity.back() == '1' ||
-          smp_affinity.back() == '2' ||
-          smp_affinity.back() == '4' ||
-          smp_affinity.back() == '8') {
-        rebalance = false;
-      }
-
-      // Treat each unnamed action IRQ as independent.
-      if (action_to_irqs_entry.first.empty()) {
-        if (rebalance) {
-          pair<string, list<string>> empty_action_irq;
-          empty_action_irq.first = "";
-          empty_action_irq.second.push_back(irq);
-          rebalance_actions.push_back(empty_action_irq);
+    for (const auto& action_to_irqs_entry : action_to_irqs) {
+        bool rebalance = true;
+        for (const auto& irq : action_to_irqs_entry.second) {
+            string smp_affinity;
+            string proc_path(PROC_IRQDIR "/");
+            proc_path += irq + "/smp_affinity";
+            ReadFileToString(proc_path, &smp_affinity);
+            smp_affinity = Trim(smp_affinity);
+
+            // Try to respect previoulsy set IRQ affinities.
+            // On ARM interrupt controllers under Linux, if an IRQ is assigned
+            // to more than one core it will only be assigned to the lowest core.
+            // Assume any IRQ which is set to more than one core in the lowest four
+            // CPUs hasn't been assigned and needs to be rebalanced.
+            if (smp_affinity.back() == '0' || smp_affinity.back() == '1' ||
+                smp_affinity.back() == '2' || smp_affinity.back() == '4' ||
+                smp_affinity.back() == '8') {
+                rebalance = false;
+            }
+
+            // Treat each unnamed action IRQ as independent.
+            if (action_to_irqs_entry.first.empty()) {
+                if (rebalance) {
+                    pair<string, list<string>> empty_action_irq;
+                    empty_action_irq.first = "";
+                    empty_action_irq.second.push_back(irq);
+                    rebalance_actions.push_back(empty_action_irq);
+                }
+                rebalance = true;
+            }
+        }
+        if (rebalance && !action_to_irqs_entry.first.empty()) {
+            rebalance_actions.push_back(
+                    std::make_pair(action_to_irqs_entry.first, action_to_irqs_entry.second));
         }
-        rebalance = true;
-      }
-    }
-    if (rebalance && !action_to_irqs_entry.first.empty()) {
-      rebalance_actions.push_back(std::make_pair(action_to_irqs_entry.first,
-                                                 action_to_irqs_entry.second));
     }
-  }
 }
 
 // Read the file at `path`, Trim whitespace, see if it matches `expected_value`.
 // Print the results to stdout.
-void ReportIfAffinityUpdated(const std::string expected_value,
-                             const std::string path) {
-  std::string readback, report;
-  ReadFileToString(path, &readback);
-  readback = Trim(readback);
-  if (readback != expected_value) {
-    report += "Unable to set ";
-  } else {
-    report += "Success setting ";
-  }
-  report += path;
-  report += ": found " + readback + " vs " + expected_value + "\n";
-  LOG(DEBUG) << report;
+void ReportIfAffinityUpdated(const std::string expected_value, const std::string path) {
+    std::string readback, report;
+    ReadFileToString(path, &readback);
+    readback = Trim(readback);
+    if (readback != expected_value) {
+        report += "Unable to set ";
+    } else {
+        report += "Success setting ";
+    }
+    report += path;
+    report += ": found " + readback + " vs " + expected_value + "\n";
+    LOG(DEBUG) << report;
 }
 
 // Evenly distribute the IRQ actions across all the Policy0 CPUs.
 // Assign all the IRQs of an action to a single CPU core.
 bool RebalanceIrqs(const list<pair<string, list<string>>>& action_to_irqs) {
-  int mask_index = 0;
-  std::vector<std::string> affinity_masks = Policy0CpuMasks();
-
-  if (affinity_masks.empty()) {
-    LOG(ERROR) << "Unable to find Policy0 CPUs for IRQ assignment.";
-    return false;
-  }
-
-  for (const auto &action_to_irq: action_to_irqs) {
-    for (const auto& irq: action_to_irq.second) {
-      std::string affinity_path(PROC_IRQDIR "/");
-      affinity_path += irq + "/smp_affinity";
-      WriteStringToFile(affinity_masks[mask_index], affinity_path);
-      ReportIfAffinityUpdated(affinity_masks[mask_index], affinity_path);
+    int mask_index = 0;
+    std::vector<std::string> affinity_masks = Policy0CpuMasks();
+
+    if (affinity_masks.empty()) {
+        LOG(ERROR) << "Unable to find Policy0 CPUs for IRQ assignment.";
+        return false;
+    }
+
+    for (const auto& action_to_irq : action_to_irqs) {
+        for (const auto& irq : action_to_irq.second) {
+            std::string affinity_path(PROC_IRQDIR "/");
+            affinity_path += irq + "/smp_affinity";
+            WriteStringToFile(affinity_masks[mask_index], affinity_path);
+            ReportIfAffinityUpdated(affinity_masks[mask_index], affinity_path);
+        }
+        mask_index = (mask_index + 1) % affinity_masks.size();
     }
-    mask_index = (mask_index + 1) % affinity_masks.size();
-  }
-  return true;
+    return true;
 }
 
 void ChownIrqAffinity() {
@@ -231,13 +219,12 @@ void ChownIrqAffinity() {
         return;
     }
 
-    struct dirent *entry;
+    struct dirent* entry;
     while ((entry = readdir(irq_dir.get()))) {
         // If the directory entry isn't a parsable number, skip it.
         // . and .. get skipped here.
         unsigned throwaway;
-        if (!ParseUint(entry->d_name, &throwaway))
-            continue;
+        if (!ParseUint(entry->d_name, &throwaway)) continue;
 
         string affinity_path(PROC_IRQDIR "/");
         affinity_path += entry->d_name;
@@ -252,29 +239,29 @@ void ChownIrqAffinity() {
 }
 
 int main(int /* argc */, char* /* argv */[]) {
-  map<string, list<string>> irq_mapping;
-  list<pair<string, list<string>>> action_to_irqs;
-
-  // Find the mapping of "irq actions" to IRQs.
-  // Each IRQ has an assocatied irq_actions field, showing the actions
-  // associated with it.  Multiple IRQs have the same actions.
-  // Generate the mapping of actions to IRQs with that action,
-  // as these IRQs should all be mapped to the same cores.
-  if (!GetIrqmap(irq_mapping)) {
-    LOG(ERROR) << "Unable to read IRQ mappings.  Are you root?";
-    return 1;
-  }
-
-  // Change ownership of smp_affinity and smp_affinity_list handles
-  // from root to system.
-  ChownIrqAffinity();
-
-  // Some IRQs are already assigned to a subset of cores, usually for
-  // good reason (like some drivers have an IRQ per core, for per-core
-  // queues.)  Find the set of IRQs that haven't been mapped to specific
-  // cores.
-  FindUnassignedIrqs(irq_mapping, action_to_irqs);
-
-  // Distribute the rebalancable IRQs across all cores.
-  return RebalanceIrqs(action_to_irqs) ? 0 : 1;
+    map<string, list<string>> irq_mapping;
+    list<pair<string, list<string>>> action_to_irqs;
+
+    // Find the mapping of "irq actions" to IRQs.
+    // Each IRQ has an assocatied irq_actions field, showing the actions
+    // associated with it.  Multiple IRQs have the same actions.
+    // Generate the mapping of actions to IRQs with that action,
+    // as these IRQs should all be mapped to the same cores.
+    if (!GetIrqmap(irq_mapping)) {
+        LOG(ERROR) << "Unable to read IRQ mappings.  Are you root?";
+        return 1;
+    }
+
+    // Change ownership of smp_affinity and smp_affinity_list handles
+    // from root to system.
+    ChownIrqAffinity();
+
+    // Some IRQs are already assigned to a subset of cores, usually for
+    // good reason (like some drivers have an IRQ per core, for per-core
+    // queues.)  Find the set of IRQs that haven't been mapped to specific
+    // cores.
+    FindUnassignedIrqs(irq_mapping, action_to_irqs);
+
+    // Distribute the rebalancable IRQs across all cores.
+    return RebalanceIrqs(action_to_irqs) ? 0 : 1;
 }