Recuperar o uso da CPU e da memória de um único processo no Linux?

Quero obter o uso da CPU e da memória de um único processo no Linux - conheço o PID. Felizmente, eu posso obtê-lo a cada segundo e gravá-lo em um CSV usando o comando 'watch'. Que comando posso usar para obter essas informações na linha de comando do Linux?

ps -p <pid> -o %cpu,%mem,cmd

(Você pode deixar o "cmd", mas isso pode ser útil na depuração).

Observe que isso fornece o uso médio da CPU do processo ao longo do tempo em que ele foi executado.

Uma variante da resposta do caf : top -p <pid>

Isso atualiza automaticamente o uso da CPU, por isso é bom para o monitoramento.

Você pode obter os resultados pelo nome do processo usando

ps -C chrome -o %cpu,%mem,cmd

a -Copção permite que você use o nome do processo sem saber que é pid.

Use pidstat (do sysstat - Consulte o link ).

por exemplo, para monitorar esses dois IDs de processo (12345 e 11223) a cada 5 segundos, use

$ pidstat -h -r -u -v -p 12345,11223 5

ps comando (não deve usar):

• Atualmente, o uso da CPU é expresso como a porcentagem de tempo gasto em execução durante toda a vida útil de um processo.

top comando (deve usar):

• O compartilhamento da tarefa do tempo decorrido da CPU desde a última atualização da tela, expresso como uma porcentagem do tempo total da CPU.

Use toppara obter o uso da CPU em tempo real (intervalo curto atual):

top -b -n 2 -d 0.2 -p 6962 | tail -1 | awk '{print $9}'

ecoará como: 78.6

• -b: Modo de lote
• -n 2: Número de iterações, use 2porque: Quando você o executa pela primeira vez, ele não possui uma amostra anterior para comparar; portanto, esses valores iniciais são as porcentagens desde a inicialização.
• -d 0.2: Tempo de atraso (em segundo, aqui estão 200ms)
• -p 6962: Monitor-PIDs
• tail -1: a última linha
• awk '{print $9}': a 9a coluna (o número de uso da CPU)

Inicie um programa e monitore-o

Este formulário é útil se você deseja comparar facilmente um executável:

topp() (
  $* &>/dev/null &
  pid="$!"
  trap ':' INT
  echo 'CPU  MEM'
  while sleep 1; do ps --no-headers -o '%cpu,%mem' -p "$pid"; done
  kill "$pid"
)
topp ./myprog arg1 arg2

Agora, quando você pressiona Ctrl + C, ele sai do programa e para de monitorar. Saída de amostra:

CPU  MEM
20.0  1.3
35.0  1.3
40.0  1.3

Relacionado: /unix/554/how-to-monitor-cpu-memory-usage-of-a-singsing-process

Testado no Ubuntu 16.04.

Você pode usar top -be exibir o pid desejado (com a -bparte superior do sinalizador sendo executada no modo em lote) ou também usar o -psinalizador e especificar o pid sem usar o grep.

Como comentado na resposta do caf acima, ps e, em alguns casos, pidstat fornecerão a média da vida útil da pCPU. Para obter resultados mais precisos, use top. Se você precisar executar o top assim que puder:

top -b -n 1 -p <PID>

ou para processar apenas dados e cabeçalho:

top -b -n 1 -p <PID> | tail -3 | head -2

sem cabeçalhos:

top -b -n 1 -p <PID> | tail -2 | head -1

ps aux | awk '{print $4"\t"$11}' | sort | uniq -c | awk '{print $2" "$1" "$3}' | sort -nr

ou por processo

ps aux | awk '{print $4"\t"$11}' | sort | uniq -c | awk '{print $2" "$1" "$3}' | sort -nr |grep mysql

Para obter o uso de memória apenas de seu aplicativo (em oposição às bibliotecas compartilhadas que ele usa, você precisa usar a interface de smaps do Linux). Esta resposta explica bem .

ps aux|awk  '{print $2,$3,$4}'|grep PID

onde a primeira coluna é o PID, o uso da CPU na segunda coluna e o uso da memória na terceira coluna.

ps axo pid,etime,%cpu,%mem,cmd | grep 'processname' | grep -v grep

PID - ID do processo

etime - Processo em execução / duração ao vivo

% de CPU - uso da CPU

% mem - uso de memória

cmd - Comando

Substitua processname pelo processo que você deseja rastrear, mysql nginx php-fpm etc ...

Todas as respostas aqui mostram apenas a porcentagem de memória para o PID.

Aqui está um exemplo de como obter o uso da memória rss em KB para todos os processos apache, substitua "grep apache" por "grep PID" se você quiser apenas assistir um PID específico:

watch -n5 "ps aux -y | grep apache | awk '{print \$2,\$6}'"

Isso imprime:

Every 5.0s: ps aux -y | grep apache | awk '{print $2,$6}'                                                                                                                                                                                                          
Thu Jan 25 15:44:13 2018

12588 9328
12589 8700
12590 9392
12591 9340
12592 8700
12811 15200
15453 9340
15693 3800
15694 2352
15695 1352
15697 948
22896 9360

Com% da CPU:

watch -n5 "ps aux -y | grep apache | awk '{print \$2,\$3,\$6}'"

Resultado:

Every 5.0s: ps aux -y | grep apache | awk '{print $2,$3,$6}'                                                                                                                                                                                                       
Thu Jan 25 15:46:00 2018

12588 0.0 9328
12589 0.0 8700
12590 0.0 9392
12591 0.0 9340
12592 0.0 8700
12811 0.0 15200
15453 0.0 9340
15778 0.0 3800
15779 0.0 2352
15780 0.0 1348
15782 0.0 948
22896 0.0 9360

Para aqueles que lutaram por um tempo se perguntando por que a resposta selecionada não funciona:

ps -p <pid> -o %cpu,%mem

Nenhum ESPAÇO entre %cpu,e %mem.

Esse é um bom truque para seguir um ou mais programas em tempo real, enquanto também assiste à saída de outras ferramentas: watch "top -bn1 -p$(pidof foo),$(pidof bar); tool"

O comando a seguir obtém a média do uso da CPU e da memória a cada 40 segundos para um processo específico (pid)

pidstat 40 -ru -p <pid>

Saída para o meu caso (duas primeiras linhas para uso da CPU, duas primeiras linhas para memória):

02:15:07 PM       PID    %usr %system  %guest    %CPU   CPU  Command
02:15:47 PM     24563    0.65    0.07    0.00    0.73     3  java

02:15:07 PM       PID  minflt/s  majflt/s     VSZ    RSS   %MEM  Command
02:15:47 PM     24563      6.95      0.00 13047972 2123268   6.52  java

(Se você estiver no MacOS 10.10, tente a opção -c acumulativa da parte superior:

top -c a -pid PID

(Esta opção não está disponível em outro linux, tentei com o Scientific Linux el6 e RHEL6)

Acima, lista os principais processos que consomem CPU e memória

        ps axo %cpu,%mem,command | sort -nr | head

Com base na resposta do @ caf, isso funciona muito bem para mim.

Calcular a média para o PID fornecido:

measure.sh

times=100
total=0
for i in $(seq 1 $times)
do
   OUTPUT=$(top -b -n 1 -d 0.1 -p $1 | tail -1 | awk '{print $9}')
   echo -n "$i time: ${OUTPUT}"\\r
   total=`echo "$total + $OUTPUT" | bc -l`
done
#echo "Average: $total / $times" | bc

average=`echo "scale=2; $total / $times" | bc`
echo "Average: $average"

Uso:

# send PID as argument
sh measure.sh 3282

Uso de CPU e memória de um único processo no Linux ou você pode obter os 10 principais processos utilizados pela CPU usando o comando abaixo

ps -aux --sort -pcpu | cabeça -n 11