¿Cómo saber qué procesos están utilizando el espacio de intercambio en Linux?

El mejor script que encontré está en esta página: http://northernmost.org/blog/find-out-what-is-using-your-swap /

Aquí hay una variante del script y no se necesita root:

#!/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"

Aquí hay otra variante del script, pero destinada a dar una salida más legible (necesita ejecutar esto como root para obtener resultados exactos):

#!/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}/";

No está del todo claro si quiere decir que desea encontrar el proceso que tiene la mayoría de las páginas intercambiadas o el proceso que causó que la mayoría de las páginas se intercambiaran.

Para la primera puede ejecutar top y ordenar por swap (presione 'Op'), para la última puede ejecutar vmstat y buscar entradas distintas de cero para 'so'.

Noté que este hilo es bastante viejo, pero si te encuentras con él, como acabo de hacer, otra respuesta es: usa smem.

Aquí hay un enlace que le indica cómo instalarlo y cómo usarlo:

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

El comando top también contiene un campo para mostrar el número de fallos de página de un proceso. El proceso con fallos máximos de página sería el proceso que está intercambiando más. Para demonios de larga duración puede ser que incurran en un gran número de fallas de página al principio y el número no aumente más adelante. Así que necesitamos observar si las fallas de página están aumentando.

Otra variante de script que evita el bucle en el 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
  }'

El uso estándar es script.sh para obtener el uso por programa en orden aleatorio (hasta cómo awk almacena sus hashes) o script.sh 1 para ordenar la salida por pid.

Espero haber comentado el código lo suficiente como para decir lo que hace.

Sin embargo, dos variantes más:

A shell variante! (No solo bash)

Esto es exactamente lo mismo que lolotux script, pero sin ninguna bifurcación para grep, awk o ps. Esto es mucho más rápido!

Y como bash es uno de los shell más pobres en cuanto a rendimiento, se hizo un poco de trabajo para garantizar que este script se ejecute bien bajo dash, busybox y algún otro. Entonces, (gracias a Stéphane Chazelas,) llegar a ser mucho más rápido de nuevo!

#!/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

No se olvide de comillas dobles "$PROGNAME"! Ver Comentario de Stéphane Chazelas :

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

No intentes echo $PROGNAME sin comillas dobles en el sistema sensible, ¡y prepárate para matar a current shell antes!

And a perl version

A medida que esto se convierte en un script no tan simple, el tiempo está llegando para escribir una herramienta dedicada mediante el uso de un lenguaje más 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,"</proc/$pid/status") {
        my ($sum,$nam)=(0,"");
        while (<$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,"</proc/$pid/smaps") {
                $sum=0;
                while (<$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;

Podría correr con uno de

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

Supongo que podría obtener una buena suposición ejecutando top y buscando procesos activos que usen mucha memoria. Hacer esto programáticamente es más difícil - - - solo mira los interminables debates sobre la heurística asesina de Linux OOM.

El intercambio es una función de tener más memoria en uso activo de la que está instalada, por lo que generalmente es difícil culpar a un solo proceso. Si se trata de un problema continuo, la mejor solución es instalar más memoria o realizar otros cambios sistémicos.

En MacOSX, también ejecuta el comando superior, pero necesita escribir "o", luego "vsize" y luego INGRESAR.

No conozco ninguna respuesta directa sobre cómo encontrar exactamente qué proceso está utilizando el espacio de intercambio, sin embargo, este enlace puede ser útil. Otra buena es por aquí

También, utilice una buena herramienta como htop para ver qué procesos están utilizando una gran cantidad de memoria y cuánto intercambio general se está utilizando.

iotop es una herramienta muy útil. Proporciona estadísticas en vivo de E/S e intercambio de uso por proceso / hilo. Por defecto se muestra por hilo, pero puedes hacer iotop -P para obtener información por proceso. Esto no está disponible de forma predeterminada. Es posible que tenga que instalar a través de rpm / apt.

Adapté un script diferente en la web a este largo de un solo 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 luego tiro en un cronjob y redirecciono la salida a un archivo de registro. La información aquí es la misma que la acumulación de las entradas Swap: en el archivo smaps, pero si quiere estar seguro, puede 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; }

La salida de esta versión está en dos columnas: pid, swap amount. En la versión anterior, el tr elimina los componentes no numéricos. En ambos casos, la salida se ordena numéricamente por pid.

Da totales y porcentajes para el proceso usando swap

smem -t -p

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