Como descobrir quais processos estão usando o espaço de troca no Linux?

No Linux, como descubro qual processo está usando mais o espaço de troca?

    Run top, em seguida, pressione O p Enter . Agora os processos devem ser classificados por seu uso de troca.

    Aqui está uma atualização, pois minha resposta original não fornece uma resposta exata para o problema, como apontado nos comentários. A partir do FAQ htop :

    Não é possível obter o tamanho exato do espaço de troca usado de um processo. Top falsifica essa informação fazendo SWAP = VIRT – RES, mas isso não é uma boa métrica, porque outras coisas, como memory de vídeo, também contam com VIRT (por exemplo: top diz que meu processo X está usando 81M de swap, mas também relatórios meu sistema como um todo está usando apenas 2M de swap.Portanto, eu não vou adicionar uma coluna Swap semelhante para htop porque eu não sei uma maneira confiável para obter essa informação (na verdade, eu não acho que é possível obter um número exato, por causa de páginas compartilhadas).

    O melhor roteiro que encontrei está nesta página: http://northernmost.org/blog/find-out-what-is-using-your-swap/

    Aqui está uma variante do script e nenhuma raiz é necessária:

    #!/bin/bash # Get current swap usage for all running processes # Erik Ljungstrom 27/05/2011 # Modified by Mikko Rantalainen 2012-08-09 # Pipe the output to "sort -nk3" to get sorted output # Modified by Marc Methot 2014-09-18 # removed the need for sudo SUM=0 OVERALL=0 for DIR in `find /proc/ -maxdepth 1 -type d -regex "^/proc/[0-9]+"` do PID=`echo $DIR | cut -d / -f 3` PROGNAME=`ps -p $PID -o comm --no-headers` for SWAP in `grep VmSwap $DIR/status 2>/dev/null | awk '{ print $2 }'` do let SUM=$SUM+$SWAP done if (( $SUM > 0 )); then echo "PID=$PID swapped $SUM KB ($PROGNAME)" fi let OVERALL=$OVERALL+$SUM SUM=0 done echo "Overall swap used: $OVERALL KB" 

    Aqui está outra variante do script, mas destinada a fornecer resultados mais legíveis (você precisa executar isso como root para obter resultados exatos):

     #!/bin/bash # find-out-what-is-using-your-swap.sh # -- Get current swap usage for all running processes # -- # -- rev.0.3, 2012-09-03, Jan Smid - alignment and intendation, sorting # -- rev.0.2, 2012-08-09, Mikko Rantalainen - pipe the output to "sort -nk3" to get sorted output # -- rev.0.1, 2011-05-27, Erik Ljungstrom - initial version SCRIPT_NAME=`basename $0`; SORT="kb"; # {pid|kB|name} as first parameter, [default: kb] [ "$1" != "" ] && { SORT="$1"; } [ ! -x `which mktemp` ] && { echo "ERROR: mktemp is not available!"; exit; } MKTEMP=`which mktemp`; TMP=`${MKTEMP} -d`; [ ! -d "${TMP}" ] && { echo "ERROR: unable to create temp dir!"; exit; } >${TMP}/${SCRIPT_NAME}.pid; >${TMP}/${SCRIPT_NAME}.kb; >${TMP}/${SCRIPT_NAME}.name; SUM=0; OVERALL=0; echo "${OVERALL}" > ${TMP}/${SCRIPT_NAME}.overal; for DIR in `find /proc/ -maxdepth 1 -type d -regex "^/proc/[0-9]+"`; do PID=`echo $DIR | cut -d / -f 3` PROGNAME=`ps -p $PID -o comm --no-headers` for SWAP in `grep Swap $DIR/smaps 2>/dev/null| awk '{ print $2 }'` do let SUM=$SUM+$SWAP done if (( $SUM > 0 )); then echo -n "."; echo -e "${PID}\t${SUM}\t${PROGNAME}" >> ${TMP}/${SCRIPT_NAME}.pid; echo -e "${SUM}\t${PID}\t${PROGNAME}" >> ${TMP}/${SCRIPT_NAME}.kb; echo -e "${PROGNAME}\t${SUM}\t${PID}" >> ${TMP}/${SCRIPT_NAME}.name; fi let OVERALL=$OVERALL+$SUM SUM=0 done echo "${OVERALL}" > ${TMP}/${SCRIPT_NAME}.overal; echo; echo "Overall swap used: ${OVERALL} kB"; echo "========================================"; case "${SORT}" in name ) echo -e "name\tkB\tpid"; echo "========================================"; cat ${TMP}/${SCRIPT_NAME}.name|sort -r; ;; kb ) echo -e "kB\tpid\tname"; echo "========================================"; cat ${TMP}/${SCRIPT_NAME}.kb|sort -rh; ;; pid | * ) echo -e "pid\tkB\tname"; echo "========================================"; cat ${TMP}/${SCRIPT_NAME}.pid|sort -rh; ;; esac rm -fR "${TMP}/"; 

    Não está totalmente claro se você quer dizer que quer encontrar o processo que tem a maioria das páginas trocadas ou processadas, que causou a troca da maioria das páginas.

    Para o primeiro você pode executar top e order by swap (aperte ‘Op’), para o último você pode rodar o vmstat e procurar por inputs diferentes de ‘so’.

    Eu notei que esse tópico é um tanto antigo, mas se você se deparar com ele, como acabei de fazer, outra resposta é: use smem.

    Aqui está um link que diz a você como instalá-lo e como usá-lo:

    http://www.cyberciti.biz/faq/linux-which-process-is-using-swap/

    O comando top também contém um campo para exibir o número de falhas de página de um processo. O processo com falhas máximas na página seria o processo que mais troca. Para daemons de longa duração, pode ser que eles tenham um grande número de falhas de página no início e o número não aumente mais tarde. Portanto, precisamos observar se as falhas de página estão aumentando.

    Outra variante de script evitando o loop no shell:

     #!/bin/bash grep VmSwap /proc/[0-9]*/status | awk -F':' -v sort="$1" ' { split($1,pid,"/") # Split first field on / split($3,swp," ") # Split third field on space cmdlinefile = "/proc/"pid[3]"/cmdline" # Build the cmdline filepath getline pname[pid[3]] < cmdlinefile # Get the command line from pid swap[pid[3]] = sprintf("%6i %s",swp[1],swp[2]) # Store the swap used (with unit to avoid rebuilding at print) sum+=swp[1] # Sum the swap } END { OFS="\t" # Change the output separator to tabulation print "Pid","Swap used","Command line" # Print header if(sort) { getline max_pid < "/proc/sys/kernel/pid_max" for(p=1;p<=max_pid;p++) { if(p in pname) print p,swap[p],pname[p] # print the values } } else { for(p in pname) { # Loop over all pids found print p,swap[p],pname[p] # print the values } } print "Total swap used:",sum # print the sum }' 

    O uso padrão é script.sh para obter o uso por programa com ordem aleatória (até como o awk armazena seus hashes) ou script.sh 1 para classificar a saída por pid.

    Espero ter comentado o código o suficiente para dizer o que ele faz.

    Ainda mais duas variantes:

    Uma variante de casca ! (Não apenas bash)

    Isso é exatamente o mesmo que o script lolotux , mas sem nenhum fork para grep , awk ou ps . Isso é muito mais rápido!

    E como o bash é um dos shell mais pobres em relação ao desempenho, um pouco de trabalho foi feito para garantir que esse script seja executado bem em dash , busybox e outros. Então, ( graças a Stéphane Chazelas ), torne-se muito mais rápido de novo!

     #!/bin/sh # Get current swap usage for all running processes # Felix Hauri 2016-08-05 # Rewritted without fork. Inspired by first stuff from # Erik Ljungstrom 27/05/2011 # Modified by Mikko Rantalainen 2012-08-09 # Pipe the output to "sort -nk3" to get sorted output # Modified by Marc Methot 2014-09-18 # removed the need for sudo OVERALL=0 rifs=`printf ': \t'` for FILE in /proc/[0-9]*/status ;do SUM=0 while IFS="$rifs" read FIELD VALUE ;do case $FIELD in Pid ) PID=$VALUE ;; Name ) PROGNAME="$VALUE" ;; VmSwap ) SUM=$((SUM=${VALUE% *})) ;; esac done <$FILE [ $SUM -gt 0 ] && printf "PID: %9d swapped: %11d KB (%s)\n" $PID $SUM "$PROGNAME" OVERALL=$((OVERALL+SUM)) done printf "Total swapped memory: %14u KB\n" $OVERALL 

    Não se esqueça de aspas duplas "$PROGNAME" ! Veja o comentário de Stéphane Chazelas :

     read FIELD PROGNAME < <( perl -ne 'BEGIN{$0="/*/*/../../*/*"} print if /^Name/' /proc/self/status ) echo $FIELD "$PROGNAME" 

    Não tente echo $PROGNAME sem aspas duplas no sistema sensato, e esteja pronto para matar o shell atual antes!

    E uma versão perl

    Como isso se torna um script não tão simples , o tempo está chegando para escrever uma ferramenta dedicada usando uma linguagem mais eficiente.

     #!/usr/bin/perl -w use strict; use Getopt::Std; my ($tot,$mtot)=(0,0); my %procs; my %opts; getopt('', \%opts); sub sortres { return $a <=> $b if $opts{'p'}; return $procs{$a}->{'cmd'} cmp $procs{$b}->{'cmd'} if $opts{'c'}; return $procs{$a}->{'mswap'} <=> $procs{$b}->{'mswap'} if $opts{'m'}; return $procs{$a}->{'swap'} <=> $procs{$b}->{'swap'}; }; opendir my $dh,"/proc"; for my $pid (grep {/^\d+$/} readdir $dh) { if (open my $fh,") { $sum+=$1 if /^VmSwap:\s+(\d+)\s/; $nam=$1 if /^Name:\s+(\S+)/; } if ($sum) { $tot+=$sum; $procs{$pid}->{'swap'}=$sum; $procs{$pid}->{'cmd'}=$nam; close $fh; if (open my $fh,") { $sum+=$1 if /^Swap:\s+(\d+)\s/; }; }; $mtot+=$sum; $procs{$pid}->{'mswap'}=$sum; } else { close $fh; }; }; }; map { printf "PID: %9d swapped: %11d (%11d) KB (%s)\n", $_, $procs{$_}->{'swap'}, $procs{$_}->{'mswap'}, $procs{$_}->{'cmd'}; } sort sortres keys %procs; printf "Total swapped memory: %14u (%11u) KB\n", $tot,$mtot; 

    poderia por correr com um dos

     -c sort by command name -p sort by pid -m sort by swap values by default, output is sorted by status's vmsize 

    Eu suponho que você poderia ter um bom palpite executando top e procurando por processos ativos usando muita memory. Fazer isso programaticamente é mais difícil – basta olhar para os debates intermináveis ​​sobre a heurística do assassino Linux OOM.

    Trocar é uma function de ter mais memory em uso ativo do que está instalado, então geralmente é difícil culpá-lo em um único processo. Se for um problema contínuo, a melhor solução é instalar mais memory ou fazer outras alterações sistêmicas.

    No MacOSX, você também executa o comando top, mas precisa digitar “o” e depois “vsize”, depois ENTER.

    Eu não sei de nenhuma resposta direta sobre como encontrar exatamente qual processo está usando o espaço de swap, entretanto, este link pode ser útil . Outro bom está aqui

    Além disso, use uma boa ferramenta como htop para ver quais processos estão usando muita memory e quanto de swap está sendo usado.

    iotop é uma ferramenta muito útil. Fornece statistics ao vivo de E / S e troca de uso por processo / thread. Por padrão, ele mostra por thread, mas você pode fazer iotop -P para obter informações por processo. Isso não está disponível por padrão. Você pode ter que instalar via rpm / apt.

    Eu adaptei um script diferente na web para este longo one-liner:

      { date;for f in /proc/[0-9]*/status; do awk '{k[$1]=$2} END { if (k["VmSwap:"]) print k["Pid:"],k["Name:"],k["VmSwap:"];}' $f 2>/dev/null; done | sort -n ; } 

    Que então eu jogo em um cronjob e redireciono a saída para um arquivo de log. As informações aqui são as mesmas que acumular as inputs Swap: no arquivo smaps, mas se você quiser ter certeza, você pode usar:

     { date;for m in /proc/*/smaps;do awk '/^Swap/ {s+=$2} END { if (s) print FILENAME,s }' $m 2>/dev/null; done | tr -dc ' [0-9]\n' |sort -k 1n; } 

    A saída desta versão está em duas colunas: pid, swap amount. Na versão acima, o tr tira os componentes não numéricos. Em ambos os casos, a saída é classificada numericamente por pid.

    Dá totais e porcentagens para o processo usando swap

     smem -t -p 

    insira a descrição da imagem aqui

    Fonte: https://www.cyberciti.biz/faq/linux-which-process-is-using-swap/