Ich versuche, den CPU-Regler in 18.04 auf Leistung zu setzen. Das Problem ist, dass er Neustarts nie überlebt.

Ich habe versucht, diese Schritte in einer Antwort auf diese Frage auszuführen. Wie stelle ich "Leistung" anstelle von "Powersave" als Standard ein? aber wenn ich den Computer neu starte, wechselt der CPU-Regler zurück zu Powersaver.

Ich habe auch versucht, eine Datei /etc/rc.localmit der folgenden Bezeichnung zu erstellen :

cpupower frequency-set --governor performance

Das übersteht auch Neustarts nicht.

Wie kann ich das machen?

sudo apt-get install cpufrequtils
echo 'GOVERNOR="performance"' | sudo tee /etc/default/cpufrequtils
sudo systemctl disable ondemand

Kurze Antwort

In /etc/rc.localput in diesen Befehlen:

sleep 120
cpupower frequency-set --governor performance

1 Minute nach dem Booten wird automatisch auf Powersave umgeschaltet

Aus welchen Gründen auch immer startet meine Skylake Intel-CPU immer im Leistungsmodus und wechselt dann automatisch nach 1 Minute in den Energiesparmodus.

Wenn Sie den Modus beim Start auf Leistung einstellen, wird er um die 1-minütige Up-Time- Marke im Energiesparmodus überschrieben .

In der folgenden GIF-Datei wird die CPU-Geschwindigkeit über 3000 MHz beim Start oben angezeigt. Die Betriebszeit wird unten angezeigt. Wenn die Betriebszeit ca. 1 Minute erreicht, fällt der CPU-MHz-Wert ab. :

Programm zum Überwachen des exakt zweiten aufgerufenen Powersave

Erstellen Sie dieses Skript in /usr/local/bin/watch-gov.sh:

#! /bin/bash

# NAME: watch-gov.sh
# PATH: /usr/local/bin
# DESC: Set governnor to performance and watch for change
#       Ask Ubuntu question: /ubuntu/1021748/set-cpu-governor-to-performance-in-18-04/1084727#1084727
# CALL: called from `/etc/rc.local`
# DATE: Created Oct 18, 2018.

echo performance | tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
last_gov=$(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor)
Uptime=$(uptime)
echo "watch-gov.sh: Set to performance at $Uptime " > /tmp/watch-gov.log

for ((i=0; i<300; i++)) ; do
    curr_gov=$(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor)
    if [ $last_gov != $curr_gov ] ; then
        last_gov=$curr_gov
        Uptime=$(uptime)
        echo "watch-gov.sh: Current governor: $last_gov Uptime: $Uptime" >> \
            /tmp/watch-gov.log
    fi
    sleep 1
done

Rufen Sie das Skript /etc/rc.localvor dem exit 0Befehl auf (im Detail unten erklärt).

Eine Minute nach dem Einloggen schauen Sie sich die Ausgabe an:

$ cat /tmp/watch-gov.log
watch-gov.sh: Set to performance at  17:50:09 up 0 min,  0 users,  load average: 0.00, 0.00, 0.00 
watch-gov.sh: Current governor: powersave Uptime:  17:51:09 up 1 min,  1 user,  load average: 1.89, 0.62, 0.22

Die Bestätigung dieser Antwort besagt, dass diese 1-minütige Kraft zum powersaveGouverneur von kontrolliert wird /etc/init.d/ondemand.

Schalten Sie 120 Sekunden lang in den Ruhezustand, bevor Sie den Leistungsmodus einstellen

Die einfachste Möglichkeit, im Performance-Modus zu bleiben, besteht darin, /etc/rc.localdiese Zeilen vor der letzten Zeile zu bearbeiten und einzufügen, die Folgendes enthält exit 0:

sleep 120 # Give CPU startup routines time to settle.
echo performance | tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

Speichern Sie die Datei und starten Sie neu.

Wenn Sie die neuen Zeilen einfügen exit 0, wird sie niemals ausgeführt.

Vorbehalte

Ihre Maschine wird wahrscheinlich 10 bis 15 Grad heißer laufen.

Möglicherweise müssen Sie andere Programme entfernen, die die CPU-Frequenz ändern, wenn sie Ihre Leistungseinstellungen in überschreiben /etc/rc.local

Die Ubuntu-Kernel-Standardkonfigurationen sind so, dass der CPU-Frequenzskalierungsregler für die Leistung während des Startvorgangs verwendet wird. Der relevante Abschnitt der Kernel-Konfigurationsdatei ( /boot/config-4.15.0-36-genericin diesem Beispiel) lautet:

#
# CPU Frequency scaling
#
CONFIG_CPU_FREQ=y
CONFIG_CPU_FREQ_GOV_ATTR_SET=y
CONFIG_CPU_FREQ_GOV_COMMON=y
CONFIG_CPU_FREQ_STAT=y
CONFIG_CPU_FREQ_DEFAULT_GOV_PERFORMANCE=y
# CONFIG_CPU_FREQ_DEFAULT_GOV_POWERSAVE is not set
# CONFIG_CPU_FREQ_DEFAULT_GOV_USERSPACE is not set
# CONFIG_CPU_FREQ_DEFAULT_GOV_ONDEMAND is not set
# CONFIG_CPU_FREQ_DEFAULT_GOV_CONSERVATIVE is not set
# CONFIG_CPU_FREQ_DEFAULT_GOV_SCHEDUTIL is not set
CONFIG_CPU_FREQ_GOV_PERFORMANCE=y
CONFIG_CPU_FREQ_GOV_POWERSAVE=y
CONFIG_CPU_FREQ_GOV_USERSPACE=y
CONFIG_CPU_FREQ_GOV_ONDEMAND=y
CONFIG_CPU_FREQ_GOV_CONSERVATIVE=y
CONFIG_CPU_FREQ_GOV_SCHEDUTIL=y

#
# CPU frequency scaling drivers
#
CONFIG_X86_INTEL_PSTATE=y
CONFIG_X86_PCC_CPUFREQ=y
CONFIG_X86_ACPI_CPUFREQ=y
CONFIG_X86_ACPI_CPUFREQ_CPB=y
CONFIG_X86_POWERNOW_K8=y
CONFIG_X86_AMD_FREQ_SENSITIVITY=m
CONFIG_X86_SPEEDSTEP_CENTRINO=y
CONFIG_X86_P4_CLOCKMOD=m

Aber auch beim Booten wird standardmäßig der ondemandDienst ausgeführt. Es bietet Platz für 1 Minuten und dann ändert sich die Skalierung Gouverneur entweder interactive, ondemandoder powersave, je nach Verfügbarkeit. Die Verfügbarkeit hängt wiederum davon ab, welchen CPU-Frequenzskalierungstreiber Sie verwenden. Der Code lautet (an mehreren Stellen nach suchen ondemand):

#! /bin/sh
### BEGIN INIT INFO
# Provides:          ondemand
# Required-Start:    $remote_fs $all
# Required-Stop:
# Default-Start:     2 3 4 5
# Default-Stop:
# Short-Description: Set the CPU Frequency Scaling governor to "ondemand"
### END INIT INFO

# Don't run if we're going to start an Android LXC container:
[ ! -f /etc/init/lxc-android-config.conf ] || exit 0

PATH=/sbin:/usr/sbin:/bin:/usr/bin

. /lib/init/vars.sh
. /lib/lsb/init-functions

AVAILABLE="/sys/devices/system/cpu/cpu0/cpufreq/scaling_available_governors"
DOWN_FACTOR="/sys/devices/system/cpu/cpufreq/ondemand/sampling_down_factor"

case "$1" in
    start)
        start-stop-daemon --start --background --exec /etc/init.d/ondemand -- background
        ;;
    background)
        sleep 60 # probably enough time for desktop login

        [ -f $AVAILABLE ] || exit 0
        read governors < $AVAILABLE
        case $governors in
                *interactive*)
                        GOVERNOR="interactive"
                        break
                        ;;
                *ondemand*)
                        GOVERNOR="ondemand"
                        case $(uname -m) in
                                ppc64*)
                                        SAMPLING=100
                                ;;
                        esac
                        break
                        ;;
                *powersave*)
                        GOVERNOR="powersave"
                        break
                        ;;
                *)
                        exit 0
                        ;;
        esac

        for CPUFREQ in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
        do
                [ -f $CPUFREQ ] || continue
                echo -n $GOVERNOR > $CPUFREQ
        done
        if [ -n "$SAMPLING" ] && [ -f $DOWN_FACTOR ]; then
                echo -n $SAMPLING > $DOWN_FACTOR
        fi
        ;;
    restart|reload|force-reload)
        echo "Error: argument '$1' not supported" >&2
        exit 3
        ;;
    stop)
        ;;
    *)
        echo "Usage: $0 start|stop" >&2
        exit 3
        ;;
esac

Warum heißt es "ondemand", setzt aber andere Gouverneure (zum Beispiel setzt es mit dem intel_pstate-Treiber den powersave-Gouverneur)? Da dieses Tool vor dem intel_pstate-Treiber ausgeführt wurde, war der bei weitem vorherrschende Frequenzskalierungstreiber der acpi-cpufreq-Treiber und "ondemand" der bevorzugte Ubuntu-Standard-Governor.

Eine Möglichkeit, mit dem CPU-Frequenzskalierungsregler zu booten und zu bleiben, besteht darin, den Dienst zu deaktivieren, der sich von ihm entfernt (was auch in einer anderen Antwort erwähnt wurde):

Vor:

~$ systemctl list-units --all --type=service | grep ondemand
  ondemand.service                                      loaded    inactive dead    Set the CPU Frequency Scaling governor
~$ cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
ondemand
ondemand

Deaktivieren Sie den Dienst:

~$ sudo systemctl disable ondemand
Removed /etc/systemd/system/multi-user.target.wants/ondemand.service.

Neustart, dann erneut prüfen (eine Minute nach dem Neustart warten):

doug@s17:~$ systemctl list-units --all --type=service | grep ondemand
doug@s17:~$
doug@s17:~$ cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
performance
performance

Hinweis: Die Beispiele in dieser Antwort stammen von einem Computer, der den acpi-cpufreq-CPU-Frequenzskalierungstreiber verwendet. Wenn Sie den intel_pstate-Treiber ohne On-Demand-Governor verwenden, wird standardmäßig der Powersave-Governor verwendet.

Erwartete Frage: Warum skalieren meine CPU-Frequenzen, auch wenn der Leistungsregler verwendet wird?

Antwort: Moderne Prozessoren skalieren die CPU-Frequenz auch im Leistungsmodus und in Abhängigkeit von der Tiefe des Ruhezustands. Wenn Sie die CPU-Frequenz wirklich sperren möchten, deaktivieren Sie alle Leerlaufzustände, die niedriger als 0 sind. Beachten Sie jedoch, dass dies sehr viel Strom kostet.

Persönlich und wie in einer anderen Antwort erwähnt, verwende ich den Performance-Gouverneur oder den Powersave-Gouverneur in Abhängigkeit von meiner Arbeit. Meine Skripte sind etwas anders:

$ cat set_cpu_performance
#! /bin/bash
cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

for file in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do echo "performance" > $file; done

cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

und:

$ cat set_cpu_powersave
#! /bin/bash
cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

for file in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor; do echo "powersave" > $file; done

cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

Beispielverwendung (auf einem Computer mit dem intel_pstate-Treiber):

$ sudo ./set_cpu_performance
powersave
powersave
powersave
powersave
powersave
powersave
powersave
powersave
performance
performance
performance
performance
performance
performance
performance
performance

Ich habe die Datei /etc/rc.local verwendet

Verwenden Sie zum Ermitteln Ihrer Pfade Folgendes:

find / -name scaling_governor
find / -name scaling_max_freq

Dies funktioniert für mein Setup, aber Sie müssen es nur für Ihr Setup bearbeiten

Ich habe /etc/rc.local mit nano hinzugefügt:

# Set CPU Governor and Freq at boot up
 echo "performance" > /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
 echo 1500000 > /sys/devices/system/cpu/cpu0/cpufreq/scaling_max_freq
 echo 2000000 > /sys/devices/system/cpu/cpu4/cpufreq/scaling_max_freq
 echo "performance" > /sys/devices/system/cpu/cpu4/cpufreq/scaling_governor

direkt unter der shebang linie. Schließen Sie nano mit Strg-X und Y, um es zu speichern

Dann für 18.04 (funktioniert möglicherweise nicht auf 16.04) auf der Kommandozeile ausführen:

systemctl disable ondemand

Dann in der Kommandozeile /etc/rc.local lesen und neu starten:

/etc/rc.local
reboot

Wenn /etc/rc.local Drosseln und Fehler aufweist, stellen Sie sicher, dass es sich um chmod + x /etc/rc.local handelt

Ich benutze dieses Bash-Skript, um den performanceGouverneur festzulegen :

#!/bin/bash

sudo cpufreq-set --cpu 0 --governor performance
sudo cpufreq-set --cpu 1 --governor performance
sudo cpufreq-set --cpu 2 --governor performance
sudo cpufreq-set --cpu 3 --governor performance
sudo cpufreq-set --cpu 4 --governor performance
sudo cpufreq-set --cpu 5 --governor performance
sudo cpufreq-set --cpu 6 --governor performance
sudo cpufreq-set --cpu 7 --governor performance

cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor

Make ist ausführbar chmod +x cpu.shund kann jederzeit ausgeführt werden (immer direkt nach jedem Start / Neustart des Computers).

Ich hatte ein ähnliches Problem. In meinem Fall wollte ich den Governor auf 'schedutil' setzen, aber nach einem Neustart würde ich immer feststellen, dass der Governor 'on-demand' ist. Ich habe die meisten hier vorgestellten Lösungen ohne Erfolg gelesen und ausprobiert.

Was hat den Trick für mich getan und ich benutze Ubuntu Mate 18.04.2 fand die Datei:

/ lib / systemd / set-cpufreq

Bearbeiten, um die Zeilen einzufügen:

    *schedutil*)
            GOVERNOR="schedutil"
            break
            ;;

So, jetzt lautet die Datei:

    #! /bin/sh
    # Set the CPU Frequency Scaling governor to "ondemand"/"powersave"      where available
    set -eu

    FIRSTCPU=`cut -f1 -d- /sys/devices/system/cpu/online`
    AVAILABLE="/sys/devices/system/cpu/cpu$FIRSTCPU/cpufreq/scaling_available_governors"
    DOWN_FACTOR="/sys/devices/system/cpu/cpufreq/ondemand/sampling_down_factor"

    [ -f $AVAILABLE ] || exit 0

    read governors < $AVAILABLE
    case $governors in
            *interactive*)
                   GOVERNOR="interactive"
                   break
                   ;;
            *schedutil*)
                   GOVERNOR="schedutil"
                   break
                   ;;
            *ondemand*)
                   GOVERNOR="ondemand"
                   case $(uname -m) in
                           ppc64*)
                           SAMPLING=100
                   ;;
                   esac
                   break
                   ;;
            *powersave*)
                   GOVERNOR="powersave"
                   break
                   ;;
            *)
                   exit 0
                   ;;
    esac

    [ -n "${GOVERNOR:-}" ] || exit 0

    echo "Setting $GOVERNOR scheduler for all CPUs"

    for CPUFREQ in /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
    do
            [ -f $CPUFREQ ] || continue
            echo -n $GOVERNOR > $CPUFREQ
    done
    if [ -n "${SAMPLING:-}" ] && [ -f $DOWN_FACTOR ]; then
            echo -n $SAMPLING > $DOWN_FACTOR
    fi.

und jetzt, wenn ich meinen Computer starte, fängt es mit dem 'schedutil' Gouverneur an!