如何使用 Python 多处理队列访问 GPU（通过 PyOpenCL）？

Question

我的代码需要很长时间才能运行，因此我一直在研究 Python 的多处理库以加快速度。我的代码还有几个步骤通过 PyOpenCL 利用 GPU。问题是，如果我将多个进程设置为同时运行，它们最终都会尝试同时使用 GPU，这通常会导致一个或多个进程抛出异常并退出。

为了解决这个问题，我错开每个进程的开始，这样它们就不太可能相互碰撞：

process_list = []
num_procs = 4

# break data into chunks so each process gets it's own chunk of the data
data_chunks = chunks(data,num_procs)
for chunk in data_chunks:
    if len(chunk) == 0:
        continue
    # Instantiates the process
    p = multiprocessing.Process(target=test, args=(arg1,arg2))
    # Sticks the thread in a list so that it remains accessible
    process_list.append(p)

# Start threads
j = 1
for process in process_list:
    print('\nStarting process %i' % j)
    process.start()
    time.sleep(5)
    j += 1

for process in process_list:
    process.join()

我还在调用 GPU 的函数周围包裹了一个 try except 循环，这样如果两个进程确实尝试同时访问它，则无法访问的进程将等待几秒钟并重试：

wait = 2
n = 0
while True:
    try:
        gpu_out = GPU_Obj.GPU_fn(params)
    except:
        time.sleep(wait)
        print('\n Waiting for GPU memory...')
        n += 1
        if n == 5:
            raise Exception('Tried and failed %i times to allocate memory for opencl kernel.' % n)
        continue
    break

这种解决方法非常笨拙，尽管它在大多数情况下都有效，但进程偶尔会抛出异常，我觉得应该有一个更有效/优雅的解决方案，使用 multiprocessing.queue 或类似的东西。但是，我不确定如何将它与 PyOpenCL 集成以进行 GPU 访问。

Answer 1

听起来您可以使用multiprocessing.Lock 来同步对 GPU 的访问：

data_chunks = chunks(data,num_procs)
lock = multiprocessing.Lock()
for chunk in data_chunks:
    if len(chunk) == 0:
        continue
    # Instantiates the process
    p = multiprocessing.Process(target=test, args=(arg1,arg2, lock))
    ...

然后，在您访问 GPU 的 test 内部：

with lock:  # Only one process will be allowed in this block at a time.
    gpu_out = GPU_Obj.GPU_fn(params)

编辑：

要对池执行此操作，您可以这样做：

# At global scope
lock = None

def init(_lock):
    global lock
    lock = _lock

data_chunks = chunks(data,num_procs)
lock = multiprocessing.Lock()
for chunk in data_chunks:
    if len(chunk) == 0:
        continue
    # Instantiates the process
    p = multiprocessing.Pool(initializer=init, initargs=(lock,))
    p.apply(test, args=(arg1, arg2))
    ...

或者：

data_chunks = chunks(data,num_procs)
m = multiprocessing.Manager()
lock = m.Lock()
for chunk in data_chunks:
    if len(chunk) == 0:
        continue
    # Instantiates the process
    p = multiprocessing.Pool()
    p.apply(test, args=(arg1, arg2, lock))