Create a thermal manager class and wire it in to nanobench behind a flag

tools/ThermalManager.cpp

Index: tools/ThermalManager.cpp
diff --git a/tools/ThermalManager.cpp b/tools/ThermalManager.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..24770ab08e67ceb12c07d7abb4981eb859e37efe
--- /dev/null
+++ b/tools/ThermalManager.cpp
@@ -0,0 +1,113 @@
+/*
+ * Copyright 2016 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "ThermalManager.h"
+
+#include "SkOSFile.h"
+
+#include <stdio.h>
+
+#ifdef THERMAL_MANAGER_SUPPORTED
+
+/*
+ * ThermalManager is completely dependent on sysfs to monitor thermal temperatures.  In sysfs
+ * thermal management is controlled by a number of thermal zones.  They are laid out as follows:
+ * /sys/class/thermal/thermal_zoneN where N is the number of the thermal zone starting at 0.
+ *
+ * Inside each thermal_zone folder is a file called 'temp,' which has the current temperature
+ * reading from the sensor in that zone, as well as 0 or more files called 'trip_point_N_temp.'
+ *
+ * When the reading in temp is greater than one of the numbers in the trip_point files, then the
+ * kernel will take some kind of action.  This is all documented online.
+ *
+ * In any case, the goal of this class is to sleep right before a trip point is about to be
+ * triggered, thus naturally cooling the system and preventing thermal throttling.
+ */
+
+ThermalManager::ThermalManager(int32_t threshold, uint32_t sleepIntervalMs, uint32_t timeoutMs)
+    : fSleepIntervalMs(sleepIntervalMs)
+    , fTimeoutMs(timeoutMs) {
+    static const char* kThermalZonePath = "/sys/class/thermal/";
+    SkOSFile::Iter it(kThermalZonePath);
+    SkString path;
+    while (it.next(&path, true)) {
+        if (!path.contains("thermal_zone")) {
+            continue;
+        }
+
+        SkString fullPath(kThermalZonePath);
+        fullPath.append(path);
+        SkOSFile::Iter thermalZoneIt(fullPath.c_str());
+
+        SkString filename;
+        while (thermalZoneIt.next(&filename)) {
+            if (!(filename.contains("trip_point") && filename.contains("temp"))) {
+                continue;
+            }
+
+            fTripPoints.push_back(TripPoint(fullPath, filename, threshold));
+        }
+    }
+}
+
+bool ThermalManager::coolOffIfNecessary() {
+    uint32_t i = 0, totalTimeSleptMs = 0;
+    while (i < (uint32_t)fTripPoints.count() && totalTimeSleptMs < fTimeoutMs) {
+        if (fTripPoints[i].willTrip()) {
+            sleep(fSleepIntervalMs);

[scroggo, 2016/02/10 17:01:11]

This breaks the AOSP mips build. From [1]:

external/skia/bench/../tools/ThermalManager.cpp:61:13: error: use of undeclared
identifier 'sleep'
            sleep(fSleepIntervalMs);

The fix for this should look like crrev.com/1568883002

Derek, this is the third time we've broken AOSP mips by calling sleep. Should we
add a builder (on the CQ) that builds our testing libraries on mips so we can
catch this sooner?

[1]
https://android-build.storage.googleapis.com/builds/git_master-skia-linux-aos...

+            totalTimeSleptMs += fSleepIntervalMs;
+        } else {
+            i++;
+        }
+    }
+
+    return totalTimeSleptMs < fTimeoutMs;
+}
+
+int32_t ThermalManager::OpenFileAndReadInt32(const char* path) {
+    FILE* tempFile = fopen(path, "r");
+    SkASSERT(tempFile);
+    int32_t value;
+    int ret = fscanf(tempFile, "%d", &value);
+    if (!ret) {
+        SkDebugf("Could not read temperature\n");
+        SkASSERT(false);
+    }
+
+    fclose(tempFile);
+    return value;
+}
+
+ThermalManager::TripPoint::TripPoint(SkString thermalZoneRoot, SkString pointName,
+                                     int32_t threshold)
+    : fThermalZoneRoot(thermalZoneRoot)
+    , fPointName(pointName) {
+    SkString fullPath(thermalZoneRoot);
+    fullPath.appendf("/%s", pointName.c_str());
+    fPoint = OpenFileAndReadInt32(fullPath.c_str());
+    fBase = GetTemp(fThermalZoneRoot);
+    fDisabled = fBase >= fPoint + fThreshold;  // We disable any trip point which start off
+                                               // triggered
+    fThreshold = threshold;
+    if (!fDisabled) {
+        SkDebugf("Trip point %s base - %d trip point-%d\n", fullPath.c_str(),
+                 fBase, fPoint);
+    }
+}
+
+bool ThermalManager::TripPoint::willTrip() {
+    int32_t currentTemp = GetTemp(fThermalZoneRoot);
+    bool wouldTrip = !fDisabled && currentTemp + fThreshold >= fPoint;
+
+    if (wouldTrip) {
+        SkDebugf("%s/%s would trip {%d,%d,%d,%d}\n", fThermalZoneRoot.c_str(),
+                 fPointName.c_str(), fBase, currentTemp, fPoint, fThreshold);
+    }
+    return wouldTrip;
+}
+
+#endif