Add support for Intel turbo frequency throttling through intel_pstate

Support controlling the maximum turbo frequency percentage on Intel
CPUs. Under heavy loads with 100% turbo frequency, spinning the fans
at their maximum speed does not prevent the CPU from reaching
temperatures above 90C and beyond. Reducing the effective clock
frequency of the CPU is an effective way to control its temperature.

The proposed intel_pstate controller tries to maintain the turbo
frequency at the maximunm possible value that still keeps the CPU
temperature below the user-specified 'max_temp' value. Every time the
temperature crosses the max_temp threshold, the controller reduces the
maximum frequency percentage by 4%. When the temperature drops, the
controller increases the turbo frequency by 1%. To account for the
jitter in temperature readings, the controller only increases the
temperature when the drop is greater than or equual to 3 degrees
Celcius. If the temperature drops below 'high_temp', the maximum turbo
frequency percentage is set back to 100%. The values 4%, 1%, and 3C
are chosen empirically and the code can be updated later on to make
these user-configurable as well through mbpfan.conf.

Signed-off-by: Göktürk Yüksek <[email protected]>

Author: gktrk

mbpfan.conf

@@ -16,3 +16,4 @@ low_temp = 63			# try ranges 55-63, default is 63
 high_temp = 66			# try ranges 58-66, default is 66
 max_temp = 86			# take highest number returned by "cat /sys/devices/platform/coretemp.*/hwmon/hwmon*/temp*_max", divide by 1000
 polling_interval = 1	# default is 1 seconds
+intel_pstate_control = 0	# whether mbpfan should throttle down max turbo speed when exceeding max temp

src/daemon.c

@@ -34,6 +34,7 @@
 #include "global.h"
 #include "daemon.h"
 #include "util.h"
+#include "intel_pstate.h"
 
 int daemonize = 1;
 int verbose = 0;
@@ -108,6 +109,9 @@ static void cleanup_and_exit(int exit_code)
 		sensors = next_sensor;
 	}
 
+	intel_pstate_exit(intel_pstate);
+	free(intel_pstate);
+
 	exit(exit_code);
 }
 

src/intel_pstate.c

@@ -0,0 +1,148 @@
+/**
+ *  intel_pstate.c - automatically control turbo frequency for MacBook Pro
+ *  Copyright (C) 2021 Gokturk Yuksek <[email protected]>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <errno.h>
+
+#include "intel_pstate.h"
+#include "util.h"
+#include <syslog.h>
+
+static int read_int(FILE *fp, int *val)
+{
+    char buf[4]; /* Maximum we can read in this module is '100\0' */
+    ssize_t ret;
+
+    ret = pread(fileno(fp), buf, sizeof(buf), 0);
+    if (ret >= 0) {
+        buf[ret] = '\0';
+        *val = atoi(buf);
+        return 0;
+    } else {
+        return (int)ret;
+    }
+}
+
+static inline int write_str(FILE *fp, char *str, int len)
+{
+    ssize_t ret;
+    ret = (int)pwrite(fileno(fp), str, len, 0);
+    if (ret == len)
+        return 0;
+    else
+        return -1;
+}
+
+static int write_int(FILE *fp, int val)
+{
+    char buf[4]; /* Maximum we can read in this module is '100\0' */
+    int ret;
+
+    ret = snprintf(buf, sizeof(buf), "%d", val);
+    if (ret < 0)
+        return ret;
+
+    return write_str(fp, buf, ret);
+}
+
+int intel_pstate_init(t_intel_pstate *intel_pstate)
+{
+    const char *path_max_perf_pct = INTEL_PT_PATH "/max_perf_pct";
+    const char *path_min_perf_pct = INTEL_PT_PATH "/min_perf_pct";
+    FILE *fp;
+    int err;
+
+    fp = fopen(path_max_perf_pct, "w+");
+    if (!fp)
+        return -1;
+    /* Save the initial value of max_perf_pct, to restore it on exit */
+    err = read_int(fp, &intel_pstate->preserved_max_perf_pct);
+    if (err)
+        return err;
+    /* Start with the maximum performance percentage at 100% */
+    err = write_str(fp, "100", 4);
+    if (err)
+        return err;
+    intel_pstate->f_max_perf_pct = fp;
+
+    fp = fopen(path_min_perf_pct, "w+");
+    if (!fp)
+        return -1;
+    /* Save the initial value of min_perf_pct, to restore it on exit */
+    err = read_int(fp, &intel_pstate->preserved_min_perf_pct);
+    if (err)
+        return err;
+    /* Set the minimum performance percentage to 0 */
+    err = write_str(fp, "0", 2);
+    if (err)
+        return err;
+    intel_pstate->f_min_perf_pct = fp;
+
+    return 0;
+}
+
+int intel_pstate_is_available(void)
+{
+    DIR* dir = opendir(INTEL_PT_PATH);
+
+    if ((!dir) && ENOENT == errno)
+        return 0;
+
+    closedir(dir);
+    return 1;
+}
+
+int intel_pstate_adjust(t_intel_pstate *intel_pstate, int step)
+{
+    int val;
+    int err;
+
+    if (!intel_pstate)
+        return 1;
+
+    err = read_int(intel_pstate->f_max_perf_pct, &val);
+    if (err)
+        return err;
+
+    mbp_log(LOG_INFO, "Adjusting intel_pstate: val: %d, step: %d", val, step);
+
+    val += step;
+    if (val < 0)
+        val = 0;
+    if (val > 100)
+        val = 100;
+
+    return write_int(intel_pstate->f_max_perf_pct, val);
+}
+
+void intel_pstate_exit(t_intel_pstate *intel_pstate)
+{
+    if (!intel_pstate)
+        return;
+
+    (void)write_int(intel_pstate->f_max_perf_pct, intel_pstate->preserved_max_perf_pct);
+    (void)write_int(intel_pstate->f_min_perf_pct, intel_pstate->preserved_min_perf_pct);
+
+    fclose(intel_pstate->f_max_perf_pct);
+    fclose(intel_pstate->f_min_perf_pct);
+
+    memset(intel_pstate, 0, sizeof(*intel_pstate));
+}

src/intel_pstate.h

@@ -0,0 +1,38 @@
+/**
+ *  intel_pstate.c - automatically control turbo frequency for MacBook Pro
+ *  Copyright (C) 2021 Gokturk Yuksek <[email protected]>
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ */
+
+#ifndef  _INTEL_PT_H_
+#define _INTEL_PT_H_
+
+#define INTEL_PT_PATH "/sys/devices/system/cpu/intel_pstate/"
+
+struct s_intel_pstate {
+    FILE *f_max_perf_pct;
+    FILE *f_min_perf_pct;
+    int preserved_max_perf_pct;
+    int preserved_min_perf_pct;
+};
+
+typedef struct s_intel_pstate t_intel_pstate;
+
+extern t_intel_pstate *intel_pstate;
+
+extern int intel_pstate_init(t_intel_pstate *intel_pstate);
+extern int intel_pstate_is_available(void);
+extern int intel_pstate_adjust(t_intel_pstate *intel_pstate, int step);
+extern void intel_pstate_exit(t_intel_pstate *intel_pstate);
+
+#endif /*_INTEL_PT_H_*/

src/mbpfan.c

@@ -45,6 +45,7 @@
 #include "global.h"
 #include "settings.h"
 #include "util.h"
+#include "intel_pstate.h"
 
 /* lazy min/max... */
 #define min(a,b) ((a) < (b) ? (a) : (b))
@@ -61,6 +62,9 @@ int low_temp = 63;   // try ranges 55-63
 int high_temp = 66;  // try ranges 58-66
 int max_temp = 86;   // do not set it > 90
 
+/* Whether mbpfan should control the turbo frequency or not */
+int intel_pstate_control = 0;  // disabled by default
+
 // maximum number of processors etc supported
 #define NUM_PROCESSORS 6
 #define NUM_HWMONS 12
@@ -74,6 +78,7 @@ int polling_interval = 1;
 
 t_sensors* sensors = NULL;
 t_fans* fans = NULL;
+t_intel_pstate* intel_pstate = NULL;
 
 char *smprintf(const char *fmt, ...)
 {
@@ -524,6 +529,12 @@ void retrieve_settings(const char* settings_path, t_fans* fans)
                 polling_interval = result;
             }
 
+            result = settings_get_int(settings, "general", "intel_pstate_control");
+
+            if (result != 0) {
+                intel_pstate_control = (result == 0) ? 0 : 1;
+            }
+
             /* Destroy the settings object */
             settings_delete(settings);
         }
@@ -573,12 +584,31 @@ void mbpfan()
 {
     int old_temp, new_temp, fan_speed, steps;
     int temp_change;
+    int err;
 
     sensors = retrieve_sensors();
     fans = retrieve_fans();
 
     retrieve_settings(NULL, fans);
 
+    if (intel_pstate_control) {
+        if (!intel_pstate_is_available()) {
+            mbp_log(LOG_ERR, "Intel pstate control is requested but not available");
+            exit(EXIT_FAILURE);
+        } else {
+            intel_pstate = (t_intel_pstate*)malloc(sizeof(t_intel_pstate));
+            if (!intel_pstate) {
+                mbp_log(LOG_ERR, "Failed to allocate memory for intel_pstate control");
+                exit(EXIT_FAILURE);
+            }
+            err = intel_pstate_init(intel_pstate);
+            if (err) {
+                mbp_log(LOG_ERR, "Failed to initialize intel_pstate control");
+                exit(EXIT_FAILURE);
+            }
+        }
+    }
+
     t_fans* fan = fans;
     while(fan != NULL) {
 
@@ -620,6 +650,13 @@ void mbpfan()
         old_temp = new_temp;
         new_temp = get_temp(sensors);
 
+	if (new_temp <= high_temp) /* maximize turbo below high_temp */
+	    intel_pstate_adjust(intel_pstate, +100);
+	else if (new_temp >= max_temp) /* throttle down to keep the temp in control */
+	    intel_pstate_adjust(intel_pstate, -4);
+	else if ((new_temp - old_temp) <= -3) /* core is cooling down, increase turbo */
+	    intel_pstate_adjust(intel_pstate, +1);
+
         fan = fans;
 
 	while(fan != NULL) {