Comment résoudre ce problème de mémoire avec élégance?

J'ai un ordinateur portable Linux (test Debian) standard, avec une partition de swap.

Je fais beaucoup d'expériences avec. Certains d'entre eux sont vraiment gourmands en mémoire et la façon dont Linux se comporte par défaut est un problème pour moi ... Donnons un exemple stupide:

1. Asseyez-vous devant l'ordinateur portable
2. Ouvrez un terminal
3. Tapez python, puisa = [0]*100000000

Il y a maintenant de grandes chances que vous n'ayez pas assez de RAM pour gérer cette grande liste. Linux remplira la RAM, puis l'échange et, quelques minutes plus tard, le tueur OOM sera déclenché et tuera des services (presque) aléatoires et, espérons-le, si vous appuyez sur Ctrl + C au bon moment python, et si le terminal avait encore le focus, l'ordinateur redeviendra réactif.

Je voudrais imposer certaines limites de mémoire pour éviter cet échange indésirable et refuser à un processus le droit d'allouer plus de mémoire que je n'en ai (en RAM). Si la demande de mémoire est inférieure à une certaine limite ou demandée par root, il suffit de tuer le processus le plus gourmand en mémoire de tout utilisateur, sauf root.

ulimit -Sv [mem] J'entends dans le dos!

Ho Ho! "Utiliser cgroupsvia cgexec!" quelqu'un dit au premier rang!

Oui, vous avez raison: ce sont en effet de très bonnes solutions. Mais:

• Ils ne s'appliquent pas à l'ensemble du système
• Les limites sont fixées par processus
• Les limites sont statiques, sans tenir compte de la quantité réelle de RAM libre (AFAIK)
• Ici et là , ils disent que ce n'est pas vraiment une bonne solution pour imposer des limites strictes.

Ce que j'aimerais, c'est que le noyau dise: "Vous appartenez à l'utilisateur foo (pas root), vous utilisez beaucoup de mémoire et nous allons manquer de mémoire. Désolé mec ... meurs maintenant!"

Ou: "Que diable faites-vous? Vous avez besoin de x Mo et il n'y a que y Mo disponibles. Oui, SWAP est vide, mais vous n'avez pas l'intention d'utiliser le SWAP pour faire votre sale boulot, n'est-ce pas? Non, je dit non! Pas de mémoire pour toi! Si tu insistes, tu vas mourir! "

Quelqu'un a suggéré dans votre audition cgroups. Eh bien, essayez de chercher cette direction car elle peut vous fournir:

• appliqué à un groupe de tâches que vous choisissez (donc pas à l'échelle du système mais ni par processus)
• les limites sont fixées pour le groupe
• les limites sont statiques
• ils peuvent appliquer une limite stricte sur la mémoire et / ou la mémoire + swap

Quelque chose comme ça pourrait vous rapprocher de vos objectifs :

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

Cela indique que les tâches sous ce groupe de contrôle peuvent utiliser au maximum 50 Mo de mémoire uniquement et 50 Mo de mémoire + échange, donc lorsque la mémoire est pleine, elle ne sera pas échangée, mais si la mémoire n'est pas pleine et que certaines données pourraient être mappées dans échange, cela pourrait être autorisé.

Voici un extrait de la documentation mémoire du cgroup :

En utilisant la limite memsw, vous pouvez éviter le MOO du système qui peut être causé par une pénurie de swap.

Je rencontre souvent le même problème. Mon workflow général implique des calculs lourds dans MATLAB. Parfois, j'essaierai par inadvertance d'allouer une nouvelle variable qui dépasse la quantité de mémoire disponible. Le système se bloque et je dois généralement redémarrer la machine en dur pour me remettre au travail. : P

Dans mon cas, et il semble que dans le vôtre aussi, je n'étais pas tellement préoccupé par la limitation de la quantité de mémoire utilisée par MATLAB à une quantité statique - j'étais intéressé à ne pas avoir de machine gelée, et j'étais prêt à sacrifier mon processus MATLAB afin de préserver la réactivité du système.

Inspiré par une réponse à ce post , j'ai écrit le script suivant (je l'ai appelé 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

Ce script vérifie chaque seconde le pourcentage de mémoire libre. Lorsque le système est épuisé, votre pid "bouc émissaire" (passé en argument au script) est tué.

Sans ajuster la priorité (gentillesse) du script, il a fallu environ 10 à 20 secondes pour que le bouc émissaire soit tué, mais cela a quand même fonctionné. L'exécution du script avec une priorité négative a entraîné un kill instantané après violation (11916 dans cet exemple est le pid que je veux tuer si je manque de mémoire):

sudo nice -n -5 bash watch_memory.sh 11916