Skip to main content

103.6 Modificar o NI de execução de processos



Aqui vamos ver como aumentar ou diminuir o NI de um processo no sistema, isso significa que o processo terá maior tempo de uso de CPU e I/O caso tenha uma NI mais elevada.

Entendendo o NI no Linux


Essa explicação não cai na prova, mas é bom para você entender e aprender (e nunca esquecer) o porque existe e como funciona o nice/renice.


Os sistemas operacionais modernos usamtime sharing(compartilhamento do tempo de uso da CPU e operações de I/O). O tempo em que um processo fica utilizando esses recursos é chamado detime sliceouquantum, resumidamente, tempo de uso de CPU e operações de I/O é o tempo de ocupação de um processo (para poder trabalhar) até que outro processo tenha sua vez.


Escalonamento


O escalonamento atua em conjunto com o time sharing. Existem dois tipos básicos de classificação de escalonamento no Linux, por Uso de Recurso e Execução e Resposta.


Uso de Recursos

Esse é o modelo mais comun e o que se refere ao uso do niceerenice. Ele analisa a quantidade de recursos o processo está usando, esse modelo de escalonamento de divide em:

  • CPU-Bound

    Analisa quais aplicações precisam de uma grande quantidade de uso de CPU.


  • I/O-Bound

    Analisa o processo que faz operações de I/O demoradas e pesadas no sistema por muito tempo e por várias vezes seguidas.

O Kernel do Linux estabelece uma prioridade para um processo e monitora esse processo, o Kernel pode alterar o NI caso necessário, tanto para uso de CPU como para operações de I/O.

Quando o usuário altera manualmente o NI de um processo, o Kernel para de monitorar esse processo e o mesmo fica rodando com uma NI estática.


Exitem dois tipos básicos de processo no Linux, o processo Convencional e o Real Time, cada um possui uma priorização própria.


Processo Convencional

São processos normais do sistema, geralmente executados pelo usuário (pessoa) ou por algum software do sistema, sua NI varia de 100 a 139, sendo 100 a mais alta e 139 a mais baixa.

A prioriade padrão para processos é de 120 (caso seja executado normalmente), esse valor interfere diretamente no time slicedo processo. No Kernel 3.2 ter uma NI igual a 100, da 800 ms de tempo de execução por cada time slice, ou seja, cada vez que o processo tiver sua vez de usar os recursos, ele poderá fazer isso por um período de 800 mili-segundos até passar sua vez para outro processo.

Nível de PrioridadeValor de PrioridadeValor NI (Nice)Tempo de execução
Baixa139195 ms
Média1200100 ms
Alta100-20800 ms

A fórmula para calcula é:

  • Para NI de 100 até 119 (PR é a abreviação de prioridade):

    Time Slice = (140 - PR)*20 ms


  • Para NI de 120 até 139:

    Time Slice = (140 - PR)*5 ms


Então uma NI de 107 e outra de 125 seria assim (TS é a abreviação de Time Slice):

TS = (140-107)*20 = 660 ms

TS = (140-125)*5 = 75 ms


Vamos calcular o que coloquei na tabela acima:

​ TS = (140-100)*20 = 800 ms

​ TS = (140-120)*5 = 100 ms

​ TS = (140-139)*5 = 5 ms


Pode ser que aconteça do Kernel dar ou retirar 5 no valor do NI, ele vai faze isso para que o sistema fique sempre equilibrado, impedindo que um processo atrapalhe outro no time sharing.


Processos em Tempo Real

Executa o processo pelo tempo necessário para terminar sua tarefa, vale lembrar que processos em Tempo Real tem prioridade em comparação aos processos Convencionais.


A priorização aqui é um pouco diferente, varia de 1 até 99, sendo 1 maior prioridade e 99 a menor, esse RT-PRI (Real Time Priority) pode ser modificada também, para isso podemos usar o comando chrt, mas adianto que não é bom ficar alterando esse RT-PRI, geralmente está ligada a processos que o Kernel esteja usando. O valor de NI vai alterar o valor de prioridade em tempo real apenas entre 60 e 99, sendo 60 a priordade mais alta e 99 a mais baixa.

linux:~$ ps -la
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 R 1000 6298 3148 0 80 0 - 2847 - pts/0 00:00:00 ps

# Como podemos ver em PRI, o processo do ps possui prioridade 80,
# indicando que está rodando em tempo real.

Execução e Resposta

Esse método é baseado em três possibilidades de tipos de processos, são eles:

  • Processos interativos

    Dependem de atividade humana, por causa disso seu tempo de espera é muito maior (geralmente porque o processo espera uma resposta do usuário, que pode ser feita via teclado, mouse e etc).


  • Processos em série (batch)

    Não possuem interação com o usuário e estão quase sempre em segundo plano.


  • Processos em tempo real (real time)

    Aqui temos os processos de extrema importância para o sistema, não devendo ser parado ou retardado de forma alguma. A diferença entre os processos real time explicados acima e esse, é que nesse método temos processos mais comuns que também executam em real time.


Merge dos Escalonamentos

Nos Kernels mais atuais os dois métodos de escalonamento são utilizados, ambos são usados e são de extrema importancia para o sistema, nenhum é melhor que o outro, cada um implementa e executa bem sua função.



NICE


O comando nice é usado para iniciar um processo com uma prioridade alta ou baixa, somente um super-usuário pode aumentar o NI de um processo, portanto, se esse comando for usado para aumentar o NI (de -20 até -1) somente o root poderá usar o comando nice, caso venha utilizar para diminuir o NI (de 1 até 19) poderá utilizar sem ser root.

O valor de nice apenas vai influenciar no valor da prioridade do processo.

Para calcular o valor da PR, usamos a fórmula PR = 20 + NI, segue alguns exemplos:

​ PR = 20 + 7 = 27 -- PR=127

​ PR = 20 + 19 = 39 -- PR=139

​ PR = 20 + -20 = 20 - 20 = 0 -- PR=100


Opções:

Alguns padrões que podemos usar:

-n -N - Aumenta o NI do processo;
-n N - Diminui o NI do processo;
--N - Aumenta o NI do processo (sem usar o -n);
-N - Diminui o NI do processo (sem usar o -n);

Exemplos:

#### Iniciando um processo com prioridade alta


### Usando a opção '-n -N' e '-n N'.

## Vamos iniciar um processo com NI (prioridade de Nice) -15:
linux:~$ sudo nice -n -15 ping -c 50 127.0.0.15 >/dev/null
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 2347 2346 0 65 -15 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = -15


## Vamos iniciar um processo com NI (prioridade de Nice) -20:
linux:~$ sudo nice -n -20 ping -c 50 127.0.0.15 >/dev/null
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 2375 2374 0 60 -20 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = -20


## Vamos iniciar um processo com NI (prioridade de Nice) 15:
linux:~$ sudo nice -n 15 ping -c 50 127.0.0.15 >/dev/null
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 2390 2389 0 95 15 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = 15



### Usando a opção '-N' e '--N'.

## Vamos iniciar um processo com NI (prioridade de Nice) -10:
linux:~$ sudo nice --10 ping -c 50 127.0.0.15 >/dev/null
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 2407 2406 0 70 -10 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = -10


## Vamos iniciar um processo com NI (prioridade de Nice) -9:
linux:~$ sudo nice --9 ping -c 50 127.0.0.15 >/dev/null
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 2422 2421 0 71 -9 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = -9


## Vamos iniciar um processo com NI (prioridade de Nice) 12:
linux:~$ sudo nice -12 ping -c 50 127.0.0.15 >/dev/null
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 2427 2426 0 92 12 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = 12


## Vamos iniciar um processo com NI (prioridade de Nice) 5:
linux:~$ sudo nice -5 ping -c 50 127.0.0.15 >/dev/null
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
4 S 0 2434 2433 0 85 5 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = 12


RENICE


O comando renice tem a função de alterar o valor nice quando o processo já esteja rodando.

O dono do processo pode diminuir o NI sem ser root, mas só poderá aumentar a mesma se for root.


Opções:

-n -N           - Aumenta o NI do processo;
-n N - Diminui o NI do processo;
-N - Aumenta o NI do processo (sem usar -n);
N - Diminui o NI do processo (sem usar -n);

-u USER - Específica um usuário;
-g GROUP - Específica um grupo;

Exemplos:

### Usando a opção '-n -N' e '-n N'

# Deixe o comando abaixo rodando:
linux:~$ ping -c 5000 127.0.0.15 >/dev/null
# Agora vamos pegar o PID desse processo:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 2991 2307 0 80 0 - 1832 - pts/1 00:00:00 ping
# PID = 2991


## Vamos alterar o NI de um processo para 5:
linux:~$ renice -n 5 2991
2991 (process ID) old priority 0, new priority 5
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 2991 2307 0 85 5 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = 5


## Vamos alterar o NI de um processo para 10:
linux:~$ renice -n 10 2991
2991 (process ID) old priority 5, new priority 10
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 2991 2307 0 90 10 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = 10


## Vamos alterar o NI de um processo para -10:
linux:~$ sudo renice -n -10 2991
2991 (process ID) old priority 10, new priority -10
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 2991 2307 0 70 -10 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = -10


## Vamos alterar o NI de um processo para -18:
linux:~$ sudo renice -n -18 2991
2991 (process ID) old priority -10, new priority -18
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 2991 2307 0 62 -18 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = -18


### Usando a opção '-N' e 'N'

## Vamos alterar o NI de um processo para -12:
linux:~$ renice -12 2991
2991 (process ID) old priority -18, new priority -12
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 2991 2307 0 68 -12 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = -12


## Vamos alterar o NI de um processo para -3:
linux:~$ renice -3 2991
2991 (process ID) old priority -12, new priority -3
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 2991 2307 0 77 -3 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = -3


## Vamos alterar o NI de um processo para 4:
linux:~$ renice 4 2991
2991 (process ID) old priority -3, new priority 4
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 2991 2307 0 84 4 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = 4


## Vamos alterar o NI de um processo para 14:
linux:~$ renice 14 2991
2991 (process ID) old priority 4, new priority 14
# Vamos ver o NI que esse processo tem:
linux:~$ ps -la | sed -n '1p; /ping/p'
F S UID PID PPID C PRI NI ADDR SZ WCHAN TTY TIME CMD
0 S 1001 2991 2307 0 94 14 - 1832 - pts/1 00:00:00 ping
# NICE(NI) = 4



# Mudando as prioridades dos processos de um usuário:
linux:~$ sudo renice -10 -u linux
1001 (user ID) old priority 0, new priority -10

# Listando:
linux:~$ top -u linux -b -d 1 -n 1
top - 16:36:24 up 2:20, 1 user, load average: 0.08, 0.18, 0.17
Tasks: 256 total, 1 running, 255 sleeping, 0 stopped, 0 zombie
%Cpu(s): 1.1 us, 0.0 sy, 0.0 ni, 98.9 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
MiB Mem : 16001.5 total, 11015.8 free, 2982.5 used, 2003.3 buff/cache
MiB Swap: 19531.0 total, 19531.0 free, 0.0 used. 12605.4 avail Mem

PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
2272 linux 10 -10 7628 4160 3392 S 0.0 0.0 0:00.04 bash
2307 linux 10 -10 7528 4264 3512 S 0.0 0.0 0:00.11 bash
5300 linux 10 -10 10372 3904 3332 R 0.0 0.0 0:00.00 top



Ionice - Não Cai na Prova


Esse comando funciona da mesma maneira que o renice, mas ele não vai alterar processos e sim operações de entrada e saída excessivas, identificadas com o comando iotop.

Para mexermos com o ionice, temos que entender suas classes:

  • Idle (ocioso, disponível)

    Impede que um processo realize entrada e saída quando outro processo estiver fazendo. Assim como o time slice, aqui temos um tempo definido para isso, esse tempo é entregue a outro processo e chamamos isso de grace time. É uma boa classe para diminuir ou eliminar o impacto sobre o sistema.


  • Best effort (melhor esforço)

    Essa classe divide a utilização dos recursos de I/O por todos aqueles que necessitem. Possui prioridades, que vão de 0 a 7, onde 0 é a melhor e 7 a pior prioridade, criando assim um time slice para I/O. Sempre que criar uma classe dessa, devemos dar uma prioridade a ela. Essa classe é do tipo Round Robin, cada processo que necessitar realizar I/O o fará sequencial, um depois do outro.


  • Real time

    Dá prioridade total e privilégio de acesso aos discos. Deve ser usado com extremo cuidado, assim como no Best Effort possui prioridades de 0 a 7.


  • None

    Não é uma classe, mas sim uma opção do comando ionice, onde não vai existir nenhuma prioridade para o processo em questão.

Usuário comuns podem estabelecer idle, best effort e none, desde que sejam donos do processo. As classes que usam prioridade, possuem o valor 4 como padrão..

OpçãoDescrição
-c xDefine a classe a ser utilizada, onde X varia de 0 a 3, sendo 0=none, 1=real-time, 2=best-effort e 3=idle.
-nUsado apenas com best-effort e real time. Informa o valor de 0 a 7.
-pPID do processo que será escalonado.

Exemplos:

# Mostra a PRI do processo 9063
linux:~$ ionice -p 9063

# Faz o processo trabalhar em best effort, pega PRI padrão (PRI=4)
linux:~$ ionice -c 2 -p 9063

# Faz o processo trabalhar em best effort, com PRI igual 2
linux:~$ ionice -c 2 -n 2 -p 9063

# Faz o processo trabalhar em real time, com PRI igual 5
linux:~$ ionice -c 1 -n 5 -p 9063