CPUPower. Novos Shell Scripts Para Trocar Frequência dos Núcleos dos Processadores.


Autores:  Alberto Federman Neto, albfneto

e Marcelo Oliver, msoliver

Atualizado  em 28 de Agosto de 2019. Contém nova versão, 4.0, do Script TROCAGOV.sh

1 . INTRODUÇÃO:

O que é Governor?  O termo geral  se refere a métodos ou  dispositivos para reduzir ou controlar a velocidade de máquinas, motores ou equipamentos.

Redutores de velocidade (depois chamados Governors) foram os primeiros dispositivos mecânicos e analógicos para regular velocidade e energia, e remontam ao Engenheiro Escocês James Watt, que os inventou, no século XVII, em 1775. Outra invenção extremamente conhecida dele é a Máquina a Vapor.

Um século depois, em 1888, as bases teóricas e os cálculos dos Governors mecânicos foi feita pelo Físico Escocês James Clerk Maxell, cuja outra descoberta muito famosa foi a antevisão teórica da existência das ondas eletromagnéticas, que dariam origem ao Rádio e à Eletrônica. Foi também Maxell quem grifou o termo “Governor“.

Em informática, os Governors   fazem parte do Kernel  e regulam a velocidade e a frequência de trabalho  dos processadores e dos seus núcleos.

Eles foram programados em linguagem C  e, juntamente com o CPUFreq, foram introduzidos no Kernel, pelo programador Alemão  Dominik Brodowski (Brodo.DE). (Outro Link)

Governors ou reguladores de frequência de CPU, existem em outros sistemas operacionais, Windows (links 1, 2, 3) e também  no Android.

Os Governors podem ser ajustados manualmente, através da edição de arquivos de configuração  ou do ajuste  do Daemon CPUFreq. Mas é mais cômodo fazer isso via software, usando certos comandos, programas ou pacotes.

Vários programas são conhecidos para fazer isso e eram usados antigamente. Exemplos:

cpudynd; cpufrequtils; powernowd; powersave; kpowersave ; PowerDevil; PowerMizer; Intel Power GovernorGNOME CPU Frequency Monitor and Governor Manager  etc…

Mas nos últimos anos, em várias distribuições Linux, como o CentOS, OpenSUSE, (outro link) Red-Hat; Calculate, Sabayon , Ubuntu, ArchGentoo (Link 2) etc… o pacote ou Daemon CPUPower (introduzido por Linus Torvalds) tem sido mais usado.

2. SCRIPTS ANTIGOS:

Embora o pacote CPUPower possa ser fácilmente usado com comandos, para os iniciantes ou os não especialistas em hardware, não há dúvida de que Scripts facilitam muito a tarefa de trocar os governors, variar a frequência e a velocidade da CPU.

As interfaces gráficas nos scripts, facilitam ainda mais o seu uso. São bem conhecidos o Dialog (semi gráfico) sua implementação em Qt, o Kdialog, Pode-se usar Dialog em GTK.

Para o GTK própriamente dito, existem o Yad e o Zenity (evolução do  GDialog).

Usando ou não o Dialog, os scripts para trocar Governor na Internet, são quase todos antigos e usavam CPUFreqUtils.

CPUFreq-Selector em Dialog.

CPUFreq-Selector For Quadcore.

Script to Toggle The CPU Governor.

Updated CPU Frequency Scaling Script.

Pelo fato de hoje se usar muito mais o CPUPower, esses scripts antigos podem ser considerados obsoletos.

3. PROCESSADORES E GOVERNORS:

Usei  este computador. Um Phenom, 8 núcleos, 16 Giga de RAM, do meu laboratório na FCFRP, USP. Sistema Operacional é Sabayon Linux atualizado a 18.11.

Os processadores AMD suportam  vários Governors: Conservative (mínima energia);  Ondemand (o micro aumenta ou diminui a frequência, de acordo com o que precisa); Userspace (o programa rodando é que decide o que usar) ; Powersave (economiza energia) e Performance (máxima energia usada).

Recentemente, AMD deu suporte ao novo Governor Schedutil (otimiza a energia usando uma informação do “trabalho” exercido pela CPU, e o faz ativando núcleo a núcleo, só os que precisa). É desenvolvimento da SUSELabs.

Embora o governor Schedutil pareça ser o melhor, os classicamente mais usados são o Ondemand e às vezes, o Userspace.

Quando tenho que fazer muito cálculo ou usar muita CPU, eu costumo usar Performance. Governors Powersave e Conservative são recomendados para Notebooks, para não gastar bateria.

Já os processadores Intel, tem apenas dois Governors: Powersave e Performance, “formais” e não necessitam de outros, pois usam outro tipo de Driver, módulo de kernel, o Intel_PS e também gerenciam eficientemente  os demais níveis de energia. Resumo, os Intel tem menos Governors, mas não precisam deles.

4. NOSSOS NOVOS SCRIPTS:

De fato, neste Artigo, usaremos o Zenity, embora eu esteja em ambiente gráfico KDE e portanto, em Qt. Pode-se usar Zenity em KDE.

Inclusive, existiu um pacote (agora descontinuado) semelhante ao Zenity, para KDE. Se chamava Kommander.

Zenity funcionará em KDE,  se você tiver as dependências, que geralmente são instaladas automaticamente pelas distros.

Como ponto de partida, se você não tiver, precisa instalar na sua Distro o pacote Zenity.

4.1. SCRIPT DE albfneto e msoliver:

Tive a ideia de fazer um Script gráfico para usar o pacote CPUPower e poder trocar facilmente o Governor de energia e variar a frequência máxima ou mínima dos processadores.

Meu baseei no Script simples do programador Americano Gilmoreja. O Script dele já usava CPUPower e Zenity . A linguagem usada, o tradicional Bash Script,  que usa funções internas ao Shell Bash. muito utilizado em LInux.

A intenção inicial era apenas adaptar,  modificar e traduzir o Script original, mas ele apresentou problemas na execução. Não aceitava a senha (CPUPower necessita  de Root ou de Sudo) e por isso não trocava o governor.

Fiz algumas modificações no Script, mas ele foi muito modificado e muito melhorado pelo coautor MSOliver.

Em um exemplo, a direta detecção de quantos governors o processador aceita e definição automatizada das variáveis. Com a modificação, o script diferencia os governors, conforme o processador seja AMD, ou Intel. Outros melhoramentos incluiram reduzir código, exibir Introdução sem arquivo de texto separado etc…

Eu Incrementei bastante  a parte gráfica e o Zenity. A exibição da Introdução foi melhorada por msoliver, usando sed.

Após vários melhoramentos, publico aqui a versão mais recente do nosso Script TROCAGOV.sh (SCRIPT 1)

# Este Script roda em Linux com Zenity, para trocar o governor, 
# modifica a frequência e a energia usada pelos processadores.

# Por albfneto <albfneto@fcfrp.usp.br>:
# https://www.vivaolinux.com.br/~albfneto
# e
# msoliver:
# https://www.vivaolinux.com.br/~msoliver
# Site "Viva o Linux"
# https://www.vivaolinux.com.br

# Versão 3.9 (2018).

# Licença: GPL, Livre para baixar, usar, modificar, citando a autoria.
#######################################################################

# idéia inspirada por antigos Scripts que usavam CPUfreq e Dialog:
# https://www.vivaolinux.com.br/script/cpufreqselector-em-Dialog-Centrino-frequencia
# https://pastebin.com/3PikpU8v
# https://www.thelinuxrain.com/articles/a-script-to-toggle-cpu-performance-governor
# https://meganerd.ca/site/node/45

# Os Linux modernos não usam mais CPUFreq e sim CPUPower:
# https://www.vivaolinux.com.br/dica/Regulando-velocidade-e-energia-gasta-pelos-processadores-Metodo-moderno-cpupower


# Shell Script com Zenity, baseado, traduzido e Modificado do Script original de GILMOREJA, EUA:
# https://bbs.archlinux.org/viewtopic.php?id=192774
# http://www.deskdr.com/dr/new-to-bash-scripting-making-script-to-change-laptop-cpu-governor.html


# Observação:
# Instale o pacote Zenity  na sua Distribuição, caso não esteja instalado, é verificado pelo script.

##INTRO

# Corpo do Script:

# Checar se rodando como Root:
(($UID != 0)) && { zenity --timeout="5" --warning --text '<span foreground="red" font="16">Exige Root\nLogue com o \"root\"\nOu\nUso: sudo $0</span>' 2>/dev/null;exit 0;}

# Testa o ZENITY está instalado
[[ $(which zenity) ]] || { zenity --timeout="5" --title="ERRO" --warning --text '<span foreground="red" font="16">\nInstale o \"zenity\" para continuar!\n</span>' 2>/dev/null;exit 0;}


# Informação Inicial:
zenity --timeout="5" --info --width=400  --title=TROCAGOV --text="Script Zenity Para Trocar Governor do Processador\n\nPor:\n\nAlbfneto e MSOliver, do Site:\n\nViva o Linux\n\nVersão: 3.9 (2018)"

#Deseja ver a Introdução do TROCAGOV? 
INTROD=$(zenity --list --text "Deseja Ver a introdução do TROCAGOV??" --radiolist --column "" --column "Opções" false "Sim" false "Não" 2>/dev/null)

if [ "$INTROD" = "Sim" ] ; then
# Mostra a Introdução que são as linhas contidas entre "##INTRO":
sed -n '/^##INTRO/,/^##INTRO/p' $0|sed -r 's/^##INTRO|^#//'|zenity --text-info --title="Introdução" --width 640 --height 640 
else
zenity --error --title="Não Ver Introdução" --text="Você clicou para pular a Introdução\!"
fi

#GOVERNORS DISPONÍVEIS:
governor=($(cpupower frequency-info|awk -F: '/reguladores/ {print $2}'))

#GOVERNOR EM USO:
currentGovernor=$(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor)

# Definindo Variáveis:
for X in ${governor[*]};do
[[ $currentGovernor = $X ]] && eval ${X}="TRUE" || eval ${X}=FALSE;
done

# Zenity para selecionar o governor que vai usar
wantedGovernor=$(zenity --list --width=400 --height=300 --title="Selecionar" --text="Selecionar o Governor que quer usar:" --radiolist --column "" --column "Opções" $(for ((x=0;x<${#governor[@]};x++));do echo "${!governor[$x]} ${governor[$x]}"|awk '/^FALSE/'; done)) # Checar se o botão Cancelar foi Pressionado. (($?==1)) && exit 0 # Checar se o Governor que quer trocar já havia sido selecionado antes if [ $wantedGovernor = $currentGovernor ];then newGovernor=$(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor) zenity --info --width=400 --title="Não Trocar" --text="Governor já estava trocado para $newGovernor.\n\nSem Modificações." exit 0 fi # Usaremos CPUPower para trocar. #cpupower frequency-set -g $wantedGovernor #sleep 3 zenity --notification --timeout="6" --title="Governors AJustados para Todos os Núcleos" --text="$(cpupower frequency-set -g $wantedGovernor)" # Parte da saída de "frequency-info" mostra que o governor foi trocado, numa janela de zenity: # coloquei o sed para tirar os espa cpupower frequency-info | grep -i regulador|sed 's/ \+//'| zenity --width=450 --height=200 --text-info 2>/dev/null

# Checando se Trocado o governor Corretamente
newGovernor=$(cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor)

zenity --info --text="Governor ajustado para $newGovernor."

sleep 2

zenity --info --width=500  --title=TROCAGOV --text="Obrigado por usar TROCAGOV!\n\nEmail para Entrar em Contato com os Autores:\n\nalbfneto@fcfrp.usp.br\n\nClique em OK Para Sair."

#EOF

4.2. SCRIPT DE msoliver, baseado no de  albfneto:

Enquanto trabalhava em cima do código do meu Script, o outro Autor deste Artigo, Marcelo Oliver, fez um Script simplificado em relação ao meu, mas com a vantagem da execução mais rápida.

Eis o Script de msoliver, TROCAGOVmodif.sh (SCRIPT 2):

#!/bin/bash

# Script simplificado e modificado por MSOliver
# Site "Viva o Linux"
# https://www.vivaolinux.com.br/~msoliver

tput clear

#Governor Em Uso #Criei a var "GOVERNOR" para não ficar repetindo o comando . . .
GOVERNOR="cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor"

# Checar se rodando como Root:
(($UID != 0)) && { zenity --timeout="5" --warning --text '<span foreground="red" font="16">Exige Root\nLogue com o \"root\"\nOu\nUso: sudo $0</span>' 2>/dev/null;exit;}

#Governor's disponíveis
governor=($(cpupower frequency-info|awk -F": " '/reguladores/ {print $2}'))

# Definindo o Governor(ATUAL) e Variáveis:

currentGovernor=$(eval $GOVERNOR)
for X in ${governor[*]};do
[[ $currentGovernor = $X ]] && eval ${X}="TRUE" || eval ${X}="FALSE";
done

# Zenity para selecionar o governor que vai usar
wantedGovernor=$(zenity --list --text "Selecionar o Governor que quer usar:" --radiolist --column "" --column "Opções" $(for ((x=0;x<${#governor[@]};x++));do echo "${!governor[$x]} ${governor[$x]}"|awk '/^FALSE/'; done))

# Checar se o botão Cancelar foi Pressionado.
(($? == 1)) && { echo -e "\n Botão CANCELAR Pressionado.\n Saindo . . .\n"; exit 0; }

# Usaremos CPUPower para trocar.
cpupower frequency-set -g $wantedGovernor

# Checando se o governor foi alterado
newGovernor=$(eval $GOVERNOR)
if [ "$wantedGovernor" = "$newGovernor" ];then
zenity --info --text "Governor ajustado para $newGovernor."
else
zenity --info --text "ERRO.\nGovernor Não ajustado para: \"$newGovernor\".\nEntre em contato com o Autor: \"albfneto@fcfrp.usp.br \" ;)"
fi

5. COMO PREPARAR E USAR OS SCRIPTS:

Para preparar os Scripts, vamos usar o método geral. Se você fizer o Script em sua pasta /home ou subdiretório dela, nem precisará de senha de root para salvar o Script.

Eu usei Geany, porque gosto, mas abra seu editor de texto favorito ou da distro,  copie e cole as linhas de um dos Scripts (do Item 4) em um arquivo novo.

Salve com um nome, com  extensão .sh .Assim teremos por exemplo, TROCAGOV.sh e TROCAGOVmodif.sh

Se você é iniciante, e/ou não quer preparar seus scripts, você pode baixar  eles prontos, diretamente da minha (albfneto)  área do Google Drive. Basta instalar o pacote Zenity no seu micro, e baixar os scripts:

TROCAGOV4.sh, modificado por albfneto. Esta versão mostra o Governor atual, antes de trocar.

TROCAGOV.sh, por albfneto e msoliver. Versão 3.9.

TROCAGOVmodif.sh, por msoliver, baseado no Script de albfneto.

TROCAGOVantigo.sh, Versão 3.8, uma versão anterior.

Numa pasta do /home, onde esteja o script, talvez nem seja necessário torná-lo executável (pelo menos em Sabayon Linux não o foi) mas se precisar (se não executar) vamos tornar o Script executável.

Detalhes e Diferenças e opções de chmod,  veja esta Dica.

$ sudo chmod +x TROCAGOV.sh OU
$ sudo chmod u+x TROCAGOV.sh (só o usuário Dono do Script o executará) OU
$ sudo chmod a+x TROCAGOV.sh (todos podem executar)

Agora executar o Script. Necessita de Root (pois o cpupower frequency-set precisa).

 
$ sudo sh TROCAGOV.sh OU
$ sudo ./TROCAGOV.sh OU
$ su (e senha de Root) && sh TROCAGOV.sh

6. TESTANDO OS SCRIPTS:

Pronto…. Vamos testar eles?

6.1. TROCAGOV.sh

Primeiro, tentaremos sem senha de root, ou sem sudo. O que acontece?  Claro não executa:

Tentando Executar TROCAGOV.sh , Sem Senha de Root Nem sudo.

Usando senha de root ou sudo:

Começou a execução do Script. mostra versão, autores, etc…

Primeira Tela Zenity do Script TROCAGOV.sh

Na segunda janela, se você escolher “Ver a Introdução do Script”, verá este texto na janela do Zenity:

Mostrando Introdução do Script TROCAGOV.sh.

Para não ler a Introdução, é só clicar em “não”:

Caso não Queira ver a Introdução, Clique em “não” e verá isto;

Nesta Janela Zenity, você seleciona o governor que quer. Para meu processador AMD:

Selecionando o Governor que quer Usar.

Selecionado o Governor, clique em OK. Note que ele está trocando. Coloca o novo Governor em cada um de meus oito núcleos do processador.

Veja na área de notificação, acima , lado direito. Mesmo eu estando em Qt, (porque é KDE), a notificação aparece, confirmando a troca.

O Script Atuando. Ele Associa o Novo governor, Para cada um dos Núcleos do Processador.

No caso desse teste (cuja imagem foi capturada), o novo Governor escolhido foi “ondemand”. Veja na tela seguinte, onde o Zenity extrai informação da saída do comando “cpupower –frequency-info | grep -i regulador“. Claro, instrução para isso foi inserida no script.

Informações dos Governors Disponíveis e do Governor Trocado.ela mostra o Governor trocado, “ondemand”. Clique em OK.

A Tela mostra que o governor foi trocado.

Após clicar, mais uma janela é mostrada, confirmando a troca.

Governor Ajustado para “ondemand”.

Agora observe. Vamos supor que você tenha esquecido que já havia trocado o governor para “ondemand“. Você seleciona o “ondemand” novamente. Observe que o Script não irá trocar:

Janela que Mostra que não Houve Troca, Pois o Governor Selecionado Era o Mesmo que já Estava Ajustado Anteriormente.

Clicando em OK, o Script vai para tela final.

O Script Acaba de Executar, Mostra Esta Tela Final.

6.2. TROCAGOVmodif.sh

Observe que msoliver testou os scripts no computador dele, que tem processador Intel, e não AMD. Como vimos no Item 3, os nossos Scripts listarão somente dois governors nos processadores Intel.

De maneira análoga, testei o Script mais rápido, modificado de msoliver. Ele é mais simples graficamente, mas algumas telas são semelhantes e a execução também o é.

Ele executa mais rápidamente e uma  característica interessante dele. Suponha que você não escolha Governor nenhum.

Aparecerá esta janela, mostrando que não houve o ajuste e ficou no governor pré regulado

Script TROCAGOV.modif.sh Erro no Ajuste do Governor.

A mesma tela aparecerá caso ocorram, por algum motivo, outros erros de execução.

Mostramos então os Scripts,   que estão funcionando perfeitamente, e trocando o Governor.

7. ATALHO PARA EXECUÇÃO:

Desejando facilitar mais ainda para você, pode fazer usando sua interface gráfica ou editando, um atalho para executar o script apenas clicando sobre ele.

Aqui neste ponto, não fica fácil fazer um procedimento geral, pois cada ambiente gráfico é diferente e tem emuladores de terminal diferentes. Embora os Atalhos sempre sejam .desktop , os comandos dos emuladores de terminal podem ser diferentes.

Porém, eu fiz, dentro da minha pasta de “Aplicativos” (~/APLICATIVOS) um Atalho, TROCAGOV.desktop que está funcionandobem, pelo menos  no Konsole do KDE.

Clicando duas vezes nele, um terminal abre, pede a senha e executa o Script.

Para servir de guia para os leitores, estas são as linhas de texto do meu Atalho. Ao menos em Sabayon Linux com KDE, está funcionando:

 [Desktop Entry]
Comment[pt_BR]=TRocador de Governor de CPU
Exec=sudo sh TROCAGOV.sh
GenericName[pt_BR]=TROCAGOV
Icon=boot
MimeType=
Name[pt_BR]=TROCAGOV
Name=TROCAGOV
Path=/home/albfneto/PACOTES/TROCAGOV
StartupNotify=true
Terminal=true
TerminalOptions=
Type=Application
X-DBUS-ServiceName=
X-DBUS-StartupType=
X-KDE-SubstituteUID=false
X-KDE-Username=

8. RESUMO, COMPLEMENTOS E CONCLUSÃO:

Duas variantes de um  novo código em  Shell Script TROCAGOV.sh foram feitas, descritas e testadas.

O Script tem a finalidade de facilitar ao Iniciante (ou, ao preguiçoso clicador! KKKKKKK) a tarefa de modificar ou ajustar o governor de energia dos processadores, em computadores com sistema operacional Linux. Mesmo para o usuário avançado, considero os scripts práticos. Eu mesmo estou usando.

O ajuste do governor, fará variar as frequências  de funcionamento dos núcleos desses processadores, aumentando ou diminuindo sua performance, e ou/economizando energia.

Estes Scripts destinam-se a substituir os antigos Scripts feitos com ou sem interface gráfica Dialog, pois esses Scripts antigos usavam diretamente o  CPUFreq, através de cpufrequtils.

Nos Linux atuais, prefere-se empregar o pacote e/ou Daemon CPUPower, como fizemos aqui.

Observação: Os Scripts tem licença GPL (General Public License), isto é,  com acesso ao público e livres para serem baixados, copiados, utilizados ou modificados. Porém pedimos que a Autoria original seja citada.

Correspondência acerca destes Scripts, pode ser endereçada  ao email de um dos autores:

albfneto@fcfrp.usp.br

Artigo  e Script escritos, realizados e testados na Faculdade de Ciências Farmacêuticas de Ribeirão Preto, Universidade de São Paulo, em um Phenom 8 núcleos, com 16 G de RAM, e sistema operacional Sabayon Linux, atualizado ao 18.11:

Atualização de Navegadores Diversos, em Sabayon Linux.

Sabayon do Futuro, Bleeding Edge.

Anúncios
CPUPower. Novos Shell Scripts Para Trocar Frequência dos Núcleos dos Processadores.

Deixe um comentário

Preencha os seus dados abaixo ou clique em um ícone para log in:

Logotipo do WordPress.com

Você está comentando utilizando sua conta WordPress.com. Sair /  Alterar )

Foto do Google

Você está comentando utilizando sua conta Google. Sair /  Alterar )

Imagem do Twitter

Você está comentando utilizando sua conta Twitter. Sair /  Alterar )

Foto do Facebook

Você está comentando utilizando sua conta Facebook. Sair /  Alterar )

Conectando a %s