Jak dowiedzieć się, które procesy używają przestrzeni swap w Linuksie?

Najlepszy skrypt jaki znalazłem jest na tej stronie: http://northernmost.org/blog/find-out-what-is-using-your-swap/

Oto jeden wariant skryptu i nie jest potrzebny 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"

Oto kolejny wariant skryptu, ale mający dać bardziej czytelne wyniki (musisz uruchomić go jako root, aby uzyskać dokładne wyniki):

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

Nie jest do końca jasne, czy chcesz znaleźć proces, który zamienił większość stron lub proces, który spowodował zamianę większości stron.

Dla pierwszego można uruchomić top i zamówić przez swap (naciśnij 'Op'), dla drugiego można uruchomić vmstat i szukać niezerowych wpisów dla 'so'.

Zauważyłem, że ten wątek jest dość stary, ale jeśli się na niego natkniesz, tak jak ja, inna odpowiedź brzmi: użyj smem.

Oto link, który mówi zarówno jak go zainstalować, jak i jak z niego korzystać:

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

Polecenie top zawiera również pole wyświetlające liczbę błędów strony dla procesu. Proces z maksymalnymi błędami strony byłby procesem, który jest najczęściej wymieniany. W przypadku długotrwałych demonów może się zdarzyć, że na początku będą ponosić dużą liczbę błędów strony i liczba ta nie wzrośnie później. Musimy więc obserwować, czy błędy strony rosną.

Inny wariant skryptu unikający pętli w powłoce:

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

Standardowe użycie to script.sh, Aby uzyskać użycie dla każdego programu w losowej kolejności (do tego, jak awk przechowuje jego skróty) lub script.sh 1, aby posortować wyjście według pid.

Mam nadzieję, że skomentowałem kod wystarczająco, aby powiedzieć, co robi.

Jeszcze dwa warianty:

A shell variant! (Nie tylko bash)

Jest to dokładnie to samo co skrypt lolotux , ale bez widelca do grep, awk lub ps. To jest o wiele szybsze!

A ponieważ bash jest jednym z najbiedniejszychshell pod względem wydajności, wykonaliśmy trochę pracy, aby zapewnić, że skrypt będzie działał dobrze pod dash, busybox i inne. Następnie, (Dzięki Stéphane Chazelas ,) stań się o wiele szybszy!

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

Nie zapomnij dwukrotnie cytować "$PROGNAME"! Zobacz komentarz Stéphane ' a Chazelasa :

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

Nie próbuj echo $PROGNAME bez podwójnego cytowania na sense system, i bądź gotowy do zabicia bieżącego shella przed!

I Perl Wersja

Ponieważ staje się to nie tak prostym skryptem, nadchodzi czas na napisanie dedykowanego narzędzia przy użyciu bardziej wydajnego języka.

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

Można uruchomić z jednym z

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

Przypuszczam, że można się domyślić uruchamiając {[0] } i szukając aktywnych procesów z dużą ilością pamięci. Robienie tego programu jest trudniejsze - - - wystarczy spojrzeć na niekończące się debaty na temat heurystyki Linuksa OOM killer.

Swapping jest funkcją posiadającą więcej pamięci w active niż jest zainstalowana, więc zwykle trudno jest zwalić winę na pojedynczy proces. Jeśli jest to ciągły problem, najlepszym rozwiązaniem jest zainstalowanie większej ilości pamięci lub dokonanie innych zmian systemowych.

Na MacOSX również uruchamiasz polecenie top, ale musisz wpisać "o", następnie" vsize", a następnie wprowadzić.

Nie znam żadnej bezpośredniej odpowiedzi, jak znaleźć dokładnie, jaki proces używa przestrzeni wymiany, jednak ten link może być pomocny . Kolejny dobry jest Tutaj

Użyj również dobrego narzędzia, takiego jak htop, aby zobaczyć, które procesy zużywają dużo pamięci i ile swapów jest ogólnie używanych.

iotop jest bardzo przydatnym narzędziem. Daje on aktualne statystyki użycia we / wy i swap dla procesu/wątku. Domyślnie wyświetla się w każdym wątku, ale można zrobić iotop -P, Aby uzyskać informacje o procesie. Domyślnie nie jest to dostępne. Być może trzeba będzie zainstalować przez rpm / apt.

Zaadaptowałem inny skrypt w sieci do tego długiego linera:

 { 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 ; }

Które następnie wrzucam do cronjob i Przekierowuję wyjście do pliku dziennika. Informacje tutaj są takie same jak gromadzone wpisy Swap: w pliku smaps, ale jeśli chcesz mieć pewność, możesz użyć:

{ 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; }

Wyjście tej wersji jest w dwóch kolumnach: pid, swap amount. W powyższej wersji tr usuwa elementy nieliczbowe. W obu przypadkach wyjście jest sortowane numerycznie według pid.

Daje sumy i procenty dla procesu za pomocą swap

smem -t -p

Źródło: https://www.cyberciti.biz/faq/linux-which-process-is-using-swap/