如何在python子进程之间传递大型numpy数组而不保存到磁盘？

Question

有没有一种好方法可以在不使用磁盘的情况下在两个python子进程之间传递大量数据？这是我希望完成的动画片示例：

import sys, subprocess, numpy

cmdString = """
import sys, numpy

done = False
while not done:
    cmd = raw_input()
    if cmd == 'done':
        done = True
    elif cmd == 'data':
        ##Fake data. In real life, get data from hardware.
        data = numpy.zeros(1000000, dtype=numpy.uint8)
        data.dump('data.pkl')
        sys.stdout.write('data.pkl' + '\\n')
        sys.stdout.flush()"""

proc = subprocess.Popen( #python vs. pythonw on Windows?
    [sys.executable, '-c %s'%cmdString],
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE)

for i in range(3):
    proc.stdin.write('data\n')
    print proc.stdout.readline().rstrip()
    a = numpy.load('data.pkl')
    print a.shape

proc.stdin.write('done\n')

这将创建一个子进程，该子进程生成一个numpy数组并将该数组保存到磁盘。然后，父进程从磁盘加载阵列。有用！

问题是，我们的硬件生成数据的速度比磁盘读写速度快10倍。有没有一种方法可以将数据从一个python进程传输到另一个纯粹的内存中，甚至可能不复制数据？我可以做类似参考传递的事情吗？

我第一次尝试纯粹在内存中传输数据非常糟糕：

import sys, subprocess, numpy

cmdString = """
import sys, numpy

done = False
while not done:
    cmd = raw_input()
    if cmd == 'done':
        done = True
    elif cmd == 'data':
        ##Fake data. In real life, get data from hardware.
        data = numpy.zeros(1000000, dtype=numpy.uint8)
        ##Note that this is NFG if there's a '10' in the array:
        sys.stdout.write(data.tostring() + '\\n')
        sys.stdout.flush()"""

proc = subprocess.Popen( #python vs. pythonw on Windows?
    [sys.executable, '-c %s'%cmdString],
    stdin=subprocess.PIPE,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE)

for i in range(3):
    proc.stdin.write('data\n')
    a = numpy.fromstring(proc.stdout.readline().rstrip(), dtype=numpy.uint8)
    print a.shape

proc.stdin.write('done\n')

这非常慢（比保存到磁盘要慢得多），而且非常脆弱。一定有更好的方法！

只要数据获取过程不会阻止父应用程序，我就不会嫁给“子流程”模块。我短暂地尝试了“多处理”，但到目前为止没有成功。

背景：我们有一块硬件，可以在一系列ctypes缓冲区中生成高达〜2 GB /
s的数据。处理这些缓冲区的python代码正忙于处理大量信息。我想将此信息流与在“主”程序中同时运行的其他几个硬件进行协调，而子进程之间不会相互阻塞。我当前的方法是在保存到磁盘之前将数据在子进程中分解一些，但是最好将全部资金传递给“主”进程。

Answer 1

在四处搜寻有关Joe Kington发布的代码的更多信息时，我发现了numpy-
sharedmem
软件包。从这个numpy
/ multiprocessing教程
来看，它似乎具有相同的知识遗产（也许基本上是相同的作者？–我不确定）。

使用sharedmem模块，您可以创建一个共享内存的numpy数组（太棒了！），并将其与如下所示的多重处理一起使用：

import sharedmem as shm
import numpy as np
import multiprocessing as mp

def worker(q,arr):
    done = False
    while not done:
        cmd = q.get()
        if cmd == 'done':
            done = True
        elif cmd == 'data':
            ##Fake data. In real life, get data from hardware.
            rnd=np.random.randint(100)
            print('rnd={0}'.format(rnd))
            arr[:]=rnd
        q.task_done()

if __name__=='__main__':
    N=10
    arr=shm.zeros(N,dtype=np.uint8)
    q=mp.JoinableQueue()    
    proc = mp.Process(target=worker, args=[q,arr])
    proc.daemon=True
    proc.start()

    for i in range(3):
        q.put('data')
        # Wait for the computation to finish
        q.join()   
        print arr.shape
        print(arr)
    q.put('done')
    proc.join()

运行收益

rnd=53
(10,)
[53 53 53 53 53 53 53 53 53 53]
rnd=15
(10,)
[15 15 15 15 15 15 15 15 15 15]
rnd=87
(10,)
[87 87 87 87 87 87 87 87 87 87]