Je ne sais pas si cela répond à votre question, mais j'ai trouvé ce script perl qui prétend faire exactement ce que vous recherchez. Le script implémente son propre système pour appliquer les limites en se réveillant et en vérifiant l'utilisation des ressources du processus et de ses enfants. Il semble être bien documenté et expliqué, et a été mis à jour récemment.
Comme slm l'a dit dans son commentaire, les cgroups peuvent également être utilisés pour cela. Vous devrez peut-être installer les utilitaires de gestion des cgroups, en supposant que vous êtes sous Linux, vous devriez rechercher libcgroups .
sudo cgcreate -t $USER:$USER -a $USER:$USER -g memory:myGroup
Assurez-vous que $USER est votre utilisateur.
Votre utilisateur devrait alors avoir accès aux paramètres de mémoire du groupe de contrôle dans /sys/fs/cgroup/memory/myGroup .
Vous pouvez ensuite définir la limite à, disons, 500 Mo, en procédant comme suit :
echo 500000000 > /sys/fs/cgroup/memory/myGroup/memory.limit_in_bytes
Lançons maintenant Vim :
cgexec -g memory:myGroup vim
Le processus vim et tous ses enfants devraient maintenant être limités à l'utilisation de 500 Mo de RAM. Cependant , je pense que cette limite ne s'applique qu'à la RAM et non au swap. Une fois que les processus atteignent la limite, ils commenceront à échanger. Je ne sais pas si vous pouvez contourner ce problème, je ne trouve pas de moyen de limiter l'utilisation de l'échange à l'aide de cgroups.
https://unix.stackexchange.com/a/536046/4319 :
Sur n'importe quelle distribution basée sur systemd, vous pouvez également utiliser les cgroups indirectement via systemd-run. Par exemple. pour votre cas de limitation pdftoppm à 500 Mo de RAM, utilisez :
systemd-run --scope -p MemoryLimit=500M pdftoppm
...
J'ai créé un script qui fait cela, en utilisant cgmanager qui est utilisé dans Ubuntu. Un avantage est que cela ne nécessite pas d'accès root. Notez que la gestion des groupes de contrôle est un peu spécifique à la distribution, donc je ne sais pas si cela fonctionne sur les distributions qui utilisent la gestion des groupes de contrôle systemd.
#!/bin/sh
set -eu
if [ "$#" -lt 2 ]
then
echo Usage: `basename $0` "<limit> <command>..."
exit 1
fi
limit="$1"
shift
cgname="limitmem_$$"
echo "limiting memory to $limit (cgroup $cgname) for command [email protected]"
cgm create memory "$cgname" >/dev/null
cgm setvalue memory "$cgname" memory.limit_in_bytes "$limit" >/dev/null
# try also limiting swap usage, but this fails if the system has no swap
cgm setvalue memory "$cgname" memsw.limit_in_bytes "$limit" >/dev/null 2>&1 || true
# spawn subshell to run in the cgroup
set +e
(
set -e
cgm movepid memory "$cgname" `sh -c 'echo $PPID'` > /dev/null
exec "[email protected]"
)
# grab exit code
exitcode=`echo $?`
set -e
echo -n "peak memory used: "
cgm getvalue memory "$cgname" memory.max_usage_in_bytes | tail -1 | cut -f2 -d\"
cgm remove memory "$cgname" >/dev/null
exit $exitcode
utilisation :enregistrer sous limitmem dans votre chemin et rendez-le exécutable. Ensuite, exécutez par ex. limitmem 1G command... . Cela limite la mémoire réellement utilisée. Si cela est atteint, le tueur de MOO tuera le processus ou l'un de ses enfants, mais pas quelque chose d'aléatoire qui n'a rien à voir avec cette commande.