Come risolvere questo problema di memoria con garbo?

Ho un laptop standard Linux (test Debian), con una partizione di swap.

Faccio molti esperimenti con esso. Alcuni di loro sono davvero affamati di memoria e il modo in cui Linux si comporta di default è un problema per me ... Facciamo un esempio stupido:

1. Siediti di fronte al laptop
2. Apri un terminale
3. Digita python, quindia = [0]*100000000

Ora è molto probabile che non avrai abbastanza RAM per gestire quella grande lista. Linux riempirà la RAM, quindi lo swap e, un paio di minuti dopo, il killer OOM verrà attivato e ucciderà (quasi) servizi casuali e, si spera, se premi Ctrl + C nel momento giusto pythone se il terminale ancora focalizzato, il computer tornerà reattivo.

Vorrei imporre alcuni limiti di memoria per evitare lo scambio indesiderato e rifiutare a un processo il diritto di allocare più memoria di quella che ho (nella RAM). Se la richiesta di memoria è al di sotto di un certo limite o viene richiesta da root, è sufficiente interrompere il processo più affamato di memoria di qualsiasi utente tranne root.

ulimit -Sv [mem] Sento nella parte posteriore!

Ho Ho! "Usa cgroupsvia cgexec!" qualcuno dice in prima fila!

Sì, hai ragione: queste sono davvero ottime soluzioni. Ma:

• Non si applicano a tutto il sistema
• I limiti sono impostati per processo
• I limiti sono statici, ignorando la quantità reale di RAM libera (AFAIK)
• Qua e là , dicono che questi non sono davvero una buona soluzione per imporre limiti rigidi.

Quello che mi piacerebbe è che il kernel dica: "Tu appartieni all'utente foo (non root), usi molta memoria e finiremo la memoria. Scusa amico ... muori ora!"

Oppure: "Che diavolo stai facendo? Hai bisogno di x MB e sono disponibili solo y MB. Sì, SWAP è vuoto, ma non intendi utilizzare SWAP per fare il tuo sporco lavoro, vero? No, io ha detto di no! Nessun ricordo per te! Se insisti, morirai! "

Qualcuno ha suggerito nel tuo ascolto cgroups. Bene, prova a cercare quella direzione in quanto può fornirti:

• applicato a un gruppo di attività scelto (quindi non a livello di sistema ma né per processo)
• i limiti sono stabiliti per il gruppo
• i limiti sono statici
• possono imporre limiti rigidi alla memoria e / o alla memoria + scambio

Qualcosa del genere potrebbe avvicinarti ai tuoi obiettivi :

group limited {
  memory {
    memory.limit_in_bytes = 50M;
    memory.memsw.limit_in_bytes = 50M;
  }
}

Ciò indica che le attività in questo cgroup possono utilizzare al massimo 50 M di memoria e 50 M di memoria + scambio, quindi quando la memoria è piena, non si scambia, ma se la memoria non è piena e alcuni dati potrebbero essere mappati in scambiare, questo potrebbe essere permesso.

Ecco un estratto dalla documentazione di memoria del cgroup :

Utilizzando il limite memsw, è possibile evitare la OOM di sistema che può essere causata dalla carenza di swap.

Mi imbatto spesso nello stesso problema. Il mio flusso di lavoro generale comporta un calcolo pesante in MATLAB. Occasionalmente tenterò inavvertitamente di allocare una nuova variabile che supera la quantità di memoria disponibile. Il sistema si blocca e in genere devo riavviare la macchina per tornare al lavoro. : P

Nel mio caso, e sembra anche nel tuo, non ero molto preoccupato di limitare la quantità di memoria che MATLAB usa a una quantità statica - ero interessato a non avere una macchina congelata ed ero disposto a sacrificare il mio processo MATLAB al fine di preservare la reattività del sistema.

Ispirato da una risposta a questo post , ho scritto il seguente script (l'ho chiamato watch_memory.sh):

#!/bin/bash

MONITOR=$(free | grep 'buffers/cache:')
MEM_USED=$(echo $MONITOR | awk '{ print $3 }')
MEM_FREE=$(echo $MONITOR | awk '{ print $4 }')

MEM_PERC=$(( 100*MEM_USED / (MEM_FREE+MEM_USED) ))

while :; do
    if [ "$MEM_PERC" -gt "95" ]
    then
        kill $1
        echo "$1 killed for using too much memory."
        exit
    fi
    sleep 1

    MONITOR=$(free | grep 'buffers/cache:')
    MEM_USED=$(echo $MONITOR | awk '{ print $3 }')
    MEM_FREE=$(echo $MONITOR | awk '{ print $4 }')
    MEM_PERC=$(( 100*MEM_USED / (MEM_FREE+MEM_USED) ))
done

Questo script controlla ogni secondo la quantità percentuale di memoria libera. Quando il sistema si esaurisce, il pid "capro espiatorio" (passato come argomento allo script) viene ucciso.

Senza modificare la priorità (gentilezza) della sceneggiatura, ci sono voluti circa 10-20 secondi prima che il capro espiatorio venisse ucciso, ma funzionava ancora. L'esecuzione dello script con una priorità negativa ha provocato un'uccisione istantanea dopo la violazione (11916 in questo esempio è il pid che voglio uccidere se esaurisco la memoria):

sudo nice -n -5 bash watch_memory.sh 11916