Python多处理：如何在辅助进程中度量子进程的运行时？

让

work\u one（）

成为如下函数：

def work_one(program_path):
    task = subprocess.Popen("./" + program_path, shell=True)
    t = 0
    while True:
        ret = task.poll()
        if ret != None or t >= T: # T is the max time we allow for 'task'
            break;
        else:
            t += 0.05
            time.sleep(0.05)
    return t

   def work_all(programs):
       pool = multiprocessing.Pool(20)
       ts = pool.map(work_one, programs)
       return ts

有许多这样的程序可以提供给

work\u one（）

。当这些程序按顺序运行时，每个

work\u one（）

报告的时间是每个程序运行时的可靠粗略度量

---

但是，假设我们有一个由20个worker组成的

multiprocessing.Pool（）

实例，

Pool

，我们调用如下函数：

def work_one(program_path):
    task = subprocess.Popen("./" + program_path, shell=True)
    t = 0
    while True:
        ret = task.poll()
        if ret != None or t >= T: # T is the max time we allow for 'task'
            break;
        else:
            t += 0.05
            time.sleep(0.05)
    return t

   def work_all(programs):
       pool = multiprocessing.Pool(20)
       ts = pool.map(work_one, programs)
       return ts

现在，

work\u all（）

报告的运行时度量值大约是顺序

work\u one（）

报告的运行时度量值的20倍

这是合理的，因为在

work\u one（）；相反，操作系统可能会决定将CPU分配给另一个并发工作进程。因此，在任务完成之前，
worker_one（）
内部的迭代次数可能会增加20倍

问题:

知道
work\u one（）
可能同时运行，如何正确实现
work\u one（）
以获得良好的运行时度量
如果子进程
任务
未在
t
秒内完成，我还希望
work\u one（）
尽早返回，因此
os.wait*（）
函数似乎不是一个好的解决方案，因为它们会阻塞父进程

一个过程有几个相关的时间；下面是如何获取它们的方法（请参阅；tl；dr:CPU参与进程的总时间是
user\u time+system\u time
）：

编辑：修改以提供超时。但是，我无法生成
资源。getrusage
在我的测试用例中只返回零；也许这需要一个更长的过程，或者我做错了什么

def timeout_handler(signum, frame):
    raise TimeoutError()

timeout = 2

def work_one(program_path):
    try:
        timed_out = False
        signal.signal(signal.SIGALRM, timeout_handler)
        signal.alarm(timeout)
        start = time.perf_counter()
        task = subprocess.Popen(program_path, shell=True)
        pid, exit_status, resource_usage = os.wait4(task.pid, 0)
    except TimeoutError:
        timed_out = True
        resource_usage = resource.getrusage(resource.RUSAGE_CHILDREN)
        os.kill(task.pid, signal.SIGTERM)
    finally:
        signal.alarm(0)
    end = time.perf_counter()
    real_time = end - start
    user_time = resource_usage.ru_utime
    system_time = resource_usage.ru_stime
    return (timed_out, real_time, user_time, system_time)

很抱歉我忘了添加重要的部分：如果子流程
任务
没有在
t
秒内完成，我还希望
work\u one（）
提前返回。。我将修改这个问题。除此之外，这是一个非常好的答案！