Python: ulimit et sympa pour subprocess.call/subprocess.Popen?

Question

Je dois limiter la quantité de temps et de cpu pris par les applications de ligne de commande externes que je génère à partir d'un processus python utilisant subprocess.call, principalement parce que parfois le processus engendré est coincé et épingle le cpu à 99%. Nice et ulimit semblent être des moyens raisonnables de le faire, mais je ne sais pas comment ils interagiraient avec les sous-processus.

• Les limites ressembler à quelque chose comme:
  • tuer le processus si elle prend plus de 60 secondes
  • limite à 20% de cpu
• Je veux appliquer la ressource limite au sous-processus, pas au processus python qui engendre les sous-processus.

Existe-t-il un moyen d'appliquer nice et ulimit au processus spawned subprocess.call? Y a-t-il de meilleures alternatives python-natives?

Ceci est sur un système Linux (Ubuntu).

Answer 1

Vous pouvez définir des limites pour les sous-processus avec les commandes shell ulimit et nice comme celui-ci:

import subprocess 
subprocess.Popen('ulimit -t 60; nice -n 15 cpuhog', shell=True) 

Cela va cpuhog avec une limite de 60 secondes de temps CPU et un réglage de niceness de 15. Notez qu'il existe pas de moyen simple de régler un accélérateur de CPU de 20% en tant que tel. Le processus utilisera 100% CPU sauf si un autre processus (moins agréable) a également besoin du CPU.

Answer 2

Utilisez le paramètre preexec_fn pour le sous-processus.Popen et le module de ressources. Exemple:

parent.py:

#!/usr/bin/env python 

import os 
import sys 
import resource 
import subprocess 

def setlimits(): 
    # Set maximum CPU time to 1 second in child process, after fork() but before exec() 
    print "Setting resource limit in child (pid %d)" % os.getpid() 
    resource.setrlimit(resource.RLIMIT_CPU, (1, 1)) 

print "CPU limit of parent (pid %d)" % os.getpid(), resource.getrlimit(resource.RLIMIT_CPU) 
p = subprocess.Popen(["./child.py"], preexec_fn=setlimits) 
print "CPU limit of parent (pid %d) after startup of child" % os.getpid(), resource.getrlimit(resource.RLIMIT_CPU) 
p.wait() 
print "CPU limit of parent (pid %d) after child finished executing" % os.getpid(), resource.getrlimit(resource.RLIMIT_CPU) 

child.py:

#!/usr/bin/env python 

import os 
import sys 
import resource 

print "CPU limit of child (pid %d)" % os.getpid(), resource.getrlimit(resource.RLIMIT_CPU) 

parent.py se fourchette dans un nouveau processus. Dans le nouveau processus, il appellera setlimits(), puis exec child.py. Cela signifie que la ressource sera limitée dans le processus enfant, mais pas dans le parent.

sortie lorsque le programme en cours d'exécution:

./parent.py 
CPU limit of parent (pid 17404) (-1, -1) 
Setting resource limit in child (pid 17405) 
CPU limit of parent (pid 17404) after startup of child (-1, -1) 
CPU limit of child (pid 17405) (1, 1) 
CPU limit of parent (pid 17404) after child finished executing (-1, -1) 

Ceci est dans de nombreux cas, une meilleure solution que d'essayer de ulimit utiliser, car il est pas toujours une bonne idée de se reproduire sous-processus via le shell, en particulier car il provoque souvent le paramètre laid citer des problèmes.

Answer 3

Erik a rendu facile pour moi, mais il a oublié la partie nice qui Rich Souligné. Je trouve le package psutil sympa (jeu de mots) mais malheureusement moins portable.Voici mon opinion à la question:

import os 
import psutil 
import resource 
import subprocess 

def preexec_fn(): 
    pid = os.getpid() 
    ps = psutil.Process(pid) 
    ps.set_nice(10) 
    resource.setrlimit(resource.RLIMIT_CPU, (1, 1)) 

print "mother pid", os.getpid() 
p = subprocess.Popen(["./cpuhog.sh"], preexec_fn=preexec_fn) 
p.wait() 
print "mother still alive with pid", os.getpid() 

Ville utilisé le shell=True auquel je suis en quelque sorte allergique. Peut-être que je suis juste vieux et grincheux ici, mais j'essaie de l'éviter!