Comando TOP

# top

O comando top no Linux exibe os processos em execução no sistema. Uma das ferramentas mais importantes para um administrador do sistema. É amplamente utilizado para monitorar a carga do sistema. Nesse artigo é explorado o comando top em detalhes, pois ele é um comando interativo; ou seja, muitos outros comandos estão disponíveis quando ele está executando. Sendo assim, domine o comando top!

I – SAÍDA DO COMANDO TOP

top

top - 23:18:09 up  1:45,  1 user,  load average: 0.76, 0.78, 0.76

Tasks: 192 total,   1 running, 190 sleeping,   0 stopped,   1 zombie

Cpu(s): 15.4%us,  5.7%sy,  0.0%ni, 78.8%id,  0.2%wa,  0.0%hi,  0.0%si,  0.0%st

Mem:   3058052k total,  2100524k used,   957528k free,   168696k buffers

Swap:  3481788k total,        0k used,  3481788k free,  1099720k cached

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                          

 3187 ricardo   20   0 1129m 403m  43m S   14 13.5  28:23.04 firefox                                                          

 1238 root      20   0 98840  27m 8876 S    6  0.9   4:45.38 Xorg                                                             

 2398 ricardo   20   0  429m  76m  29m S    4  2.6   3:01.05 compiz                                                           

 3352 ricardo   20   0  246m  53m  22m S    2  1.8   2:20.39 plugin-containe                                                  

 2431 ricardo   20   0  196m  25m  15m S    2  0.9   0:03.11 python                                                           

 2552 ricardo   20   0  166m  11m 8456 S    1  0.4   0:04.21 bamfdaemon                                                       

 2955 root      20   0     0    0    0 S    1  0.0   0:04.06 kworker/0:3                                                      

 2370 ricardo   20   0  6836 3352  632 S    1  0.1   0:14.33 dbus-daemon

Primeiramente, é preciso entender a saída do comando (mostrada acima). Ela exibe uma série de informações sobre o sistema em funcionamento. Então, é preciso ficar ciente das seções mostradas:

1 – Tempo de atividade e média de carga do sistema (Uptime and Load Averages)

top - 23:18:09 up  1:45,  1 user,  load average: 0.76, 0.78, 0.76

Na parte superior do comando top é apresentada a saída similar ao comando uptime.

* O tempo atual 
* O tempo que seu sistema está funcionando 
* Número de usuários autenticados no sistema no momento 
* Média de carga de 5, 10 e 15 minutos respectivamente.

2 – Tarefas (Tasks)

Tasks: 192 total,   1 running, 190 sleeping,   0 stopped,   1 zombie

A segunda linha mostra resumo das tarefas ou processos. Os processos podem ser em diferentes estados. Ela mostra o número total de processos. Destes, os processos podem estar executando (running), dormindo (sleeping), parado (stopped) ou modo zumbi (zombie)

3 – Estados da CPU (CPU States)

Cpu(s): 15.4%us,  5.7%sy,  0.0%ni, 78.8%id,  0.2%wa,  0.0%hi,  0.0%si,  0.0%st

Em seguida é apresentado o estado da CPU. O significado dos diferentes tempos de CPU são:

* us, usuário (user): tempo de CPU na execução dos processos de usuário 
* Sy, sistema (sytem): tempo de CPU na execução de processos do kernel 
* Id, ocioso (idle): tempo de CPU em inatividade 

* Wa, tempo para I/O: tempo de CPU esperando a conclusão de operação de entrada/saída no disco (I/O) 
* hi: CPU tempo servindo interrupções de hardware 
* Si: tempo de CPU servindo interrupções de software

4 – Uso da memória (Memory Usage)

Mem:   3058052k total,  2100524k used,   957528k free,   168696k buffers

Swap:  3481788k total,        0k used,  3481788k free,  1099720k cached

Estes mostram o uso de memória, um pouco do comando “free”. A primeira linha refere-se a memória física e a segunda linha a memória virtual (swap). A memória física é apresentada como: memória total disponível, memória usada, memória livre e memória usada para buffers. Da mesma forma, a swap: total, usada, espaço de troca livre e em cache. Todas em unidade Kilobyte

5 – Colunas

 PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                          

 3187 ricardo   RT   0 1129m 403m  43m S   14 13.5  28:23.04 firefox                                                          

 1238 root      20   0 98840  27m 8876 S    6  0.9   4:45.38 Xorg                                                             

 2398 ricardo   20   0  429m  76m  29m S    4  2.6   3:01.05  compiz

Nesta seção, os processos são apresentados em colunas. As diferentes colunas representam diferentes propriedades exibidas abaixo:

PID (Identificador do processo) 
A identificação do processo (identificador único)

USUÁRIO (USER) 
Usuário proprietário do processo.

PR (Prioridade) 
A prioridade de agendamento do processo. Alguns valores neste campo são ‘ RT ‘ . Isso significa que o processo está sendo executado em tempo real (Real Time).

NI 
Os valores mais baixos significam maior prioridade.

VIRT 
A quantidade de memória virtual usada pelo processo.

RES 
O tamanho da memória usada. Residente na memória física e não na área de troca (swap).

SHR (Share – compartilhada) 
SHR é a memória compartilhada usada pelo processo.

S (State – estado)
Este é o estado do processo . Ele pode ter um dos seguintes valores :

D – ininterrupto 

R – executando 
S – dormindo 
T – rastreado ou parado 
Z – zumbi

% CPU 
É a porcentagem de tempo de CPU que a tarefa tem usado desde a última atualização.

% MEM 
Percentagem de memória física disponível usada pelo processo.

TEMPO + 
O tempo total de CPU que a tarefa tem usado desde o início (precisão de centésimo de segundo)

COMANDO 
Descrição do comando que foi utilizado para iniciar o processo.

II – OPÇÕES DO COMANDO

1 – Resultado enxuto

top -b

2 – Tempo de atualização (a cada 2 segundos)

top -d 2

3 – Somente processos executando

top -i

4 – Limite de iteração

top -n 3

5 – Especificando o usuário

top -u “nome_usuario”

III – COMANDOS INTERATIVOS

Esses comandos serão usados durante a execução do comando TOP.

1 – ‘h’: Help

Help for Interactive Commands - procps version 3.2.8

Window 1:Def: Cumulative mode Off.  System: Delay 3.0 secs; Secure mode Off.

  Z,B       Global: 'Z' change color mappings; 'B' disable/enable bold

  l,t,m     Toggle Summaries: 'l' load avg; 't' task/cpu stats; 'm' mem info

  1,I       Toggle SMP view: '1' single/separate states; 'I' Irix/Solaris mode

  f,o     . Fields/Columns: 'f' add or remove; 'o' change display order

  F or O  . Select sort field

       . Move sort field: '' next col right

  R,H     . Toggle: 'R' normal/reverse sort; 'H' show threads

  c,i,S   . Toggle: 'c' cmd name/line; 'i' idle tasks; 'S' cumulative time

  x,y     . Toggle highlights: 'x' sort field; 'y' running tasks

  z,b     . Toggle: 'z' color/mono; 'b' bold/reverse (only if 'x' or 'y')

  u       . Show specific user only

  n or #  . Set maximum tasks displayed

2 – ‘ENTER’: Atualizar a amostragem

3 – ‘d’: Informe o tempo de atualização

top - 00:25:27 up  2:52,  1 user,  load average: 0.70, 0.65, 0.62

Tasks: 190 total,   2 running, 187 sleeping,   0 stopped,   1 zombie

Cpu(s): 13.5%us,  3.9%sy,  4.3%ni, 76.8%id,  1.4%wa,  0.0%hi,  0.1%si,  0.0%st

Mem:   3058052k total,  2106460k used,   951592k free,   177340k buffers

Swap:  3481788k total,        0k used,  3481788k free,  1086764k cached

Change delay from 3.0 to: 

  PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                          

 3187 ricardo   22   2 1216m 418m  43m S   20 14.0  50:26.41 firefox 

4 – ‘f’: Controle quais valores devem ser exibidos

Current Fields:  AEHIOQTWKNMbcdfgjplrsuvyzX  for window 1:Def

Toggle fields via field letter, type any other key to return 

* A: PID        = Process Id                                     0x00100000  PF_USEDFPU (thru 2.4)

* E: USER       = User Name

* H: PR         = Priority

* I: NI         = Nice value

* O: VIRT       = Virtual Image (kb)

* Q: RES        = Resident size (kb)

* T: SHR        = Shared Mem size (kb)

* W: S          = Process Status

* K: %CPU       = CPU usage

* N: %MEM       = Memory usage (RES)

* M: TIME+      = CPU Time, hundredths

  b: PPID       = Parent Process Pid

  c: RUSER      = Real user name

  d: UID        = User Id

  f: GROUP      = Group Name

  g: TTY        = Controlling Tty

  j: P          = Last used cpu (SMP)

5 – ‘i’: Apenas processos em execução

6 – ‘k’: Matar processos pelo identificador (ID)

http://www.linuxdescomplicado.com.br/2013/12/comandos-linux-dominando-o-comando-top.html

Resident and Virtual memory on Linux: A short example

Tools like top show processes using two kinds of memory:

·         Resident memory, labelled RES: How much physical memory, how much RAM, your process is using. RES is the important number.

·         Virtual memory, labelled VIRT: How much memory your process thinks it’s using. Usually much bigger than RES, thanks to the Linux kernel’s clever memory management.

Here’s a short C program to illustrate the difference:

#include <stdio.h>

#include <stdlib.h>

void fill(unsigned char* addr, size_t amount) {

    unsigned long i;

    for (i = 0; i < amount; i++) {

        *(addr + i) = 42;

    }

}

int main(int argc, char **argv) {

    unsigned char *result;

    char input;

    size_t s = 1<<30;

    result = malloc(s);

    printf("Addr: %p\n", result);

    //fill(result, s);

    scanf("%c", &input);

    return 0;

}

Save it as mem.c, compile it cc -Wall -g mem.c -o mem and run it.

It requests 1 Gig of memory (1 << 30), but doesn’t use it. With top (or htop, which is much nicer), or even ps -Ao rsz,vsz,cmd | grep mem view it’s memory usage. The resident size should be quite small (~280k for me), but the virtual size will be the full 1 Gig we requested.

Uncomment the fill line, compile and run it again. You should see the resident size get much bigger, as we’re actually using the memory we requested (we’re filling it with the number 42). The kernel has to give us real memory to work with.

We can request far more virtual memory than the machine can handle. Here’s a screenshot where I’ve requested 16 Gig of memory, on a machine with only 3 Gig of RAM and 3 Gig of swap. The VIRT’s sum up to way more than that machine can handle. At the top left of the screenshot you can see none of that memory has really been allocated. The kernel won’t allocate it until we use it.

In summary, virtual size can largely be ignored. Resident size is the important number.

Fontes: RICARDO FERREIRA