set_start_method - ¿Cómo adjuntar el depurador a un subproceso python?

python pool process

Question

Necesito depurar un proceso hijo generado por multiprocessing.Process() . El pdb pdb parece no ser consciente de forking y no puede adjuntarse a procesos ya en ejecución.

¿Hay algún depurador de Python más inteligente que pueda asociarse a un subproceso?

Answer 1

Esta es una elaboración de la respuesta de Romuald que restaura la entrada original usando su descriptor de archivo. Esto mantiene la línea de lectura trabajando dentro del depurador. Además, la gestión especial de pdb de KeyboardInterrupt está deshabilitada, para no interferir con el manipulador sigint de multiprocesamiento.

class ForkablePdb(pdb.Pdb):
_original_stdin_fd = sys.stdin.fileno()
_original_stdin = None
def __init__(self):
pdb.Pdb.__init__(self, nosigint=True)
def _cmdloop(self):
current_stdin = sys.stdin
try:
if not self._original_stdin:
self._original_stdin = os.fdopen(self._original_stdin_fd)
sys.stdin = self._original_stdin
self.cmdloop()
finally:
sys.stdin = current_stdin

Answer 2

He estado buscando una solución simple para este problema y se me ocurrió esto:

import sys
import pdb
class ForkedPdb(pdb.Pdb):
"""A Pdb subclass that may be used
from a forked multiprocessing child
"""
def interaction(self, *args, **kwargs):
_stdin = sys.stdin
try:
sys.stdin = open(''/dev/stdin'')
pdb.Pdb.interaction(self, *args, **kwargs)
finally:
sys.stdin = _stdin

Úsalo de la misma manera que podrías usar el Pdb clásico:

ForkedPdb().set_trace()

Answer 3

Si está en una plataforma compatible, pruebe DTrace . La mayor parte de la familia BSD / Solaris / OS X es compatible con DTrace.

Aquí hay una introducción del autor . Puedes usar Dtrace para depurar casi cualquier cosa.

Aquí hay una publicación SO sobre el aprendizaje de DTrace.

Answer 4

Sobre la base de la idea de @memplex, tuve que modificarla para que funcionara con joblib estableciendo sys.stdin en el constructor, así como pasándolo directamente a través de joblib.

<!-- language: lang-py -->
import os
import pdb
import signal
import sys
import joblib
_original_stdin_fd = None
class ForkablePdb(pdb.Pdb):
_original_stdin = None
_original_pid = os.getpid()
def __init__(self):
pdb.Pdb.__init__(self)
if self._original_pid != os.getpid():
if _original_stdin_fd is None:
raise Exception("Must set ForkablePdb._original_stdin_fd to stdin fileno")
self.current_stdin = sys.stdin
if not self._original_stdin:
self._original_stdin = os.fdopen(_original_stdin_fd)
sys.stdin = self._original_stdin
def _cmdloop(self):
try:
self.cmdloop()
finally:
sys.stdin = self.current_stdin
def handle_pdb(sig, frame):
ForkablePdb().set_trace(frame)
def test(i, fileno):
global _original_stdin_fd
_original_stdin_fd = fileno
while True:
pass
if __name__ == ''__main__'':
print "PID: %d" % os.getpid()
signal.signal(signal.SIGUSR2, handle_pdb)
ForkablePdb().set_trace()
fileno = sys.stdin.fileno()
joblib.Parallel(n_jobs=2)(joblib.delayed(test)(i, fileno) for i in range(10))

Answer 5

Una idea que tuve fue crear clases "ficticias" para falsificar la implementación de los métodos que está utilizando desde el multiprocesamiento:

from multiprocessing import Pool
class DummyPool():
@staticmethod
def apply_async(func, args, kwds):
return DummyApplyResult(func(*args, **kwds))
def close(self): pass
def join(self): pass
class DummyApplyResult():
def __init__(self, result):
self.result = result
def get(self):
return self.result
def foo(a, b, switch):
# set trace when DummyPool is used
# import ipdb; ipdb.set_trace()
if switch:
return b - a
else:
return a - b
if __name__ == ''__main__'':
xml = etree.parse(''C:/Users/anmendoza/Downloads/jim - 8.1/running-config.xml'')
pool = DummyPool() # switch between Pool() and DummyPool() here
results = []
results.append(pool.apply_async(foo, args=(1, 100), kwds={''switch'': True}))
pool.close()
pool.join()
results[0].get()

Answer 6

Winpdb es prácticamente la definición de un depurador de Python más inteligente. Es explícitamente compatible con bajar un fork , no estoy seguro de que funcione bien con multiprocessing.Process() pero vale la pena intentarlo.

Para obtener una lista de candidatos para verificar el soporte de su caso de uso, consulte la lista de Depuradores de Python en la wiki.