引用：https://zhuanlan.zhihu.com/p/32513483

共享 numpy 数组

需要用到 numpy 时往往是数据量较大的场景，如果直接复制会造成大量内存浪费。共享 numpy 数组则是通过上面一节的 Array 实现，再用 numpy.frombuffer 以及 reshape 对共享的内存封装成 numpy 数组，代码如下：

# encoding:utf8

import ctypes

import os

import multiprocessing

import numpy as np

NUM_PROCESS = multiprocessing.cpu_count()

def worker(index):

    main_nparray = np.frombuffer(shared_array_base, dtype=ctypes.c_double)

    main_nparray = main_nparray.reshape(NUM_PROCESS, 10)

    pid = os.getpid()

    main_nparray[index, :] = pid

    return pid

if __name__ == "__main__":

    shared_array_base = multiprocessing.Array(

        ctypes.c_double, NUM_PROCESS * 10, lock=False)

    pool = multiprocessing.Pool(processes=NUM_PROCESS)

    result = pool.map(worker, range(NUM_PROCESS))

    main_nparray = np.frombuffer(shared_array_base, dtype=ctypes.c_double)

    main_nparray = main_nparray.reshape(NUM_PROCESS, 10)

    print( main_nparray )

运行结果：

===============================================================

多进程共享较大数据，如numpy数组的情况下我们需要使用multiprocessing下面的Value , Array从而实现多进程的共享，但是还有一个重要的问题就是数据的读写方式，由于CPython是在语言的数据结构上进行再次包装的，所以对于数据的读写是需要进行翻译的，也就是说对数据读写是需要对Python数据类型下对应的C类型的数据结构进行读写的，也正是因为这种数据读写方式所以对Python数据进行操作要比对C类型数据进行读写操作要慢上很多。

numpy数据的底层同样也是C类型的数据结构，同时numpy下面的数据操作很多都是可以直接对numpy类型下的底层数据结构来操作的，这样也就会省掉数据结构转换的时间花销，只要不把numpy数据转为Python类型数据，都是可以在numpy下对底层数据进行直接操作的。

虽然mulprocessing模块提供了共享数据类型，但是不同进程对共享数据的读写本身也会存在数据类型的转换。

用更直接的话来说，虽然mutprocessing提供了共享数据类型Value和Array，但是不同进程其实也是无法直接对其进行操作的，子进程如果要读取或写入共享数据Value和Array就需要将共享数据转为可以进行操作的Python数据类型或numpy数据类型，否则就难以直接对共享数据进行直接操作，这时候numpy.frombuffer函数就派上用场了，numpy.frombuffer函数可以直接读取Python数据类型、numpy数据类型和共享数据类型的底层数据类型，即C数据类型，这样的话使用numpy.frombuffer函数就会省去数据类型转换这一环节。numpy.frombuffer可以直接读取共享数据类型Value和Array，因为Value和Array的底层实现就是C数据类型。

下面给出几种多进程共享数据的读写方式代码，以验证最佳的多进程大数据量数据的共享方式。

运行环境介绍：

软件：Ubuntu18.04系统、python3.7.5

硬件：intel i7-8700 cpu，6物理核心12逻辑核心

1.  使用multiprocessing.Value / multiprocessing.Array + numpy.frombuffer方式：

（使用numpy.frombuffer 对数据的读写不需要类型的转换可以直接对数据进行读写操作）

import ctypes

import time

import multiprocessing

import numpy as np

NUM_PROCESS = multiprocessing.cpu_count()

size = 1000000

def worker(index):

    main_nparray = np.frombuffer(shared_array_base[index], dtype=ctypes.c_double)

    for i in range(10000):

        main_nparray[:] = index + i

    return index

if __name__ == "__main__":

    shared_array_base = []

    for _ in range(NUM_PROCESS):

        shared_array_base.append(multiprocessing.Array("d", size, lock=False))

    pool = multiprocessing.Pool(processes=NUM_PROCESS)

    a = time.time()

    result = pool.map(worker, range(NUM_PROCESS))

    b = time.time()

    print(b-a)

    #print(result)

    for i in range(NUM_PROCESS):

        main_nparray = np.frombuffer(shared_array_base[i], dtype=ctypes.c_double)

        print(main_nparray)

        print(type(main_nparray))

        print(main_nparray.shape)

    # 73.216189146

    # 73.2605750561

    # 73.3307318687

    # 73.4090409279

    # 73.4219110012

运行时间：

73.216189146
73.2605750561
73.3307318687
73.4090409279
73.4219110012

运行过程中各进程CPU使用率情况：

可以看到在运行过程中12个子进程的使用率为100%，而主进程的使用率为0.3%，可以看到使用 multiprocessing.Value / multiprocessing.Array + numpy.frombuffer 的方式各子进程在读写共享空间内容基本是不需要太多等待的，可以保证子进程基本以全速进行运行，而且主进程基本不参与计算（cpu利用率：0.3%）。也就是说采用该种方式各子进程操作父进程中的共享数据可以和操作自身进程空间内的数据达到基本一致的速度，为证明给出下面代码：

import multiprocessing

import numpy as np

NUM_PROCESS = multiprocessing.cpu_count()

size = 1000000

def worker(index):

    main_nparray = np.zeros(size)

    for i in range(10000):

        main_nparray[:] = index + i

    return index

if __name__ == "__main__":

    pool = multiprocessing.Pool(processes=NUM_PROCESS)

    a = time.time()

    result = pool.map(worker, range(NUM_PROCESS))

    b = time.time()

    print(b-a)

运行时间：

73.0335

73.2103

73.1925

73.1642

73.2643

也就是说使用该种方式，各子进程对父进程中的共享内存的操作其性能与操作自己进程空间下内存基本一致，没有什么性能损耗。

=======================================================================

2. 使用multiprocessing.Manger方式：

（共享数据，隐式的、自动的进行数据类型的转换）

from multiprocessing import Process, Manager

import multiprocessing

import numpy as np

import time

NUM_PROCESS = multiprocessing.cpu_count()

size = 1000000

def worker(index):

    shared_array_base[index][0] = np.zeros(shape=size)

    shared_array_base[index][0] += index

    for i in range(10000):

        shared_array_base[index][0] += 1

        #1246.2459

        #1226.7996

        #1238.3933

        #1241.1819

        #print(shared_array_base[index][0])

    return index

if __name__ == '__main__':

    shared_array_base = []

    manager = Manager()  # 字典方式

    for _ in range(NUM_PROCESS):

        shared_array_base.append(manager.dict())

    pool = multiprocessing.Pool(processes=NUM_PROCESS)

    a = time.time()

    result = pool.map(worker, range(NUM_PROCESS))

    b = time.time()

    print(b - a)

    for index in range(NUM_PROCESS):

        print(shared_array_base[index][0])

运行时间：

1246.2459
1226.7996
1238.3933
1241.1819
1241.2889

运行时个子进程CPU利用率：

可以看到使用Manger的方式虽然可以实现共享内存的操作，但是该种方式需要父进程进行参与，随着子进程数量的增多父进程的负担也就越重，同时各子进程需要等待的时间也就越多。从运行时间上可以看到使用Manger的方式对共享内存进行操作整体性能下降了十多倍，其性能远低于Value/Array+numpy.frombuffer方式。

使用Manger方式对共享内存的操作是需要父进程参与的，这一点和Value/Array方式不同，同时使用Manger方式各子进程需要对共享数据进行类型转换而这又进一步的影响性能表现。

如果上面代码修改为：

#encoding:UTF-8

from multiprocessing import Process, Manager

import multiprocessing

import numpy as np

import time

NUM_PROCESS = multiprocessing.cpu_count()

#NUM_PROCESS = 1  #125.9360  125.2017  118.3942  133.9661  99.3769  118.5580

size = 1000000

def worker(index):

    shared_array_base[index][0] = np.zeros(shape=size)

    shared_array_base[index][0] += index

    for i in range(10000):

        shared_array_base[index][0][:] = index+i #wrong result

        ###shared_array_base[index][0] += 1

        #1246.2459

        #1226.7996

        #1238.3933

        #1241.1819

        #1241.2889

        #print(shared_array_base[index][0])

    return index

if __name__ == '__main__':

    shared_array_base = []

    manager = Manager()  # 字典方式

    for _ in range(NUM_PROCESS):

        shared_array_base.append(manager.dict())

    pool = multiprocessing.Pool(processes=NUM_PROCESS)

    a = time.time()

    result = pool.map(worker, range(NUM_PROCESS))

    b = time.time()

    print(b - a)

    for index in range(NUM_PROCESS):

        print(shared_array_base[index][0])

运行结果：

672.297180891037
[0. 0. 0. ... 0. 0. 0.]
[1. 1. 1. ... 1. 1. 1.]
[2. 2. 2. ... 2. 2. 2.]
[3. 3. 3. ... 3. 3. 3.]
[4. 4. 4. ... 4. 4. 4.]
[5. 5. 5. ... 5. 5. 5.]
[6. 6. 6. ... 6. 6. 6.]
[7. 7. 7. ... 7. 7. 7.]
[8. 8. 8. ... 8. 8. 8.]
[9. 9. 9. ... 9. 9. 9.]
[10. 10. 10. ... 10. 10. 10.]
[11. 11. 11. ... 11. 11. 11.]

运行时CPU使用率：

可以看到：

语句：

shared_array_base[index][0] += index

可以实现对共享内存的写操作。

语句：

shared_array_base[index][0][:] = index+i #wrong result

并不能实现对共享内存的写操作。

而即使不对共享内存进行写操作其运行时间也只是缩减了一半，与Value/Array+numpy.frombuffer方式相比使用Manager的方式操作共享内存即使是只进行读操作也是一种很耗费父进程计算资源的事情。使用Manager的方式各子进程读取共享内存中的数据也是需要对共享数据进行格式转换的，而这部分工作也是需要父进程参与的，因此使用Manager的方式并不能达到较好的性能表现。

如果使用单子进程的话：

代码：

#encoding:UTF-8

from multiprocessing import Process, Manager

import multiprocessing

import numpy as np

import time

#NUM_PROCESS = multiprocessing.cpu_count()

NUM_PROCESS = 1  #125.9360  125.2017  118.3942  133.9661  99.3769  118.5580

size = 1000000

def worker(index):

    shared_array_base[index][0] = np.zeros(shape=size)

    shared_array_base[index][0] += index

    for i in range(10000):

        shared_array_base[index][0] += 1

        #1246.2459

        #1226.7996

        #1238.3933

        #1241.1819

        #1241.2889

        #print(shared_array_base[index][0])

    return index

if __name__ == '__main__':

    shared_array_base = []

    manager = Manager()  # 字典方式

    for _ in range(NUM_PROCESS):

        shared_array_base.append(manager.dict())

    pool = multiprocessing.Pool(processes=NUM_PROCESS)

    a = time.time()

    result = pool.map(worker, range(NUM_PROCESS))

    b = time.time()

    print(b - a)

    for index in range(NUM_PROCESS):

        print(shared_array_base[index][0])

运行时间：

125.9360

125.2017

118.3942

133.9661

99.3769

118.5580

123.2825

运行时cpu使用率：

这充分说明子进程对父进程的共享内存进行读写操作是需要父进程参与的，而这部分需要父进程参与的工作就是共享内存数据的类型转换工作。随着子进程数量的增加会加重父进程的负担，从而导致各子进程均难以获得较好的性能表现。

=========================================================================

3. 只使用multiprocessing.Value / multiprocessing.Array 方式：

（共享数据，使用中间数据进行操作后再直接赋值给共享数据：因为没有进行数据类型转换的共享数据难以直接进行读写操作）

代码：

import numpy as np

import multiprocessing

import time

import ctypes

NUM_PROCESS = multiprocessing.cpu_count()

size = 1000000

def worker(index):

    temp = shared_array_base[index]

    temp2 = np.zeros(size)+index

    for i in range(100*100):

        temp2 += 1

        temp[:] = temp2[:]

        ###2129.3716

        ###2253.2248

        ###2127.4056

        ###2128.4252

    return index

if __name__ == '__main__':

    shared_array_base = []

    for _ in range(NUM_PROCESS):

        shared_array_base.append(multiprocessing.Array(ctypes.c_double, size, lock=False))

    pool = multiprocessing.Pool(processes=NUM_PROCESS)

    a = time.time()

    result = pool.map(worker, range(NUM_PROCESS))

    b = time.time()

    print(b-a)

    for i in range(NUM_PROCESS):

        main_nparray = np.frombuffer(shared_array_base[i], dtype=ctypes.c_double)

        print(main_nparray)

        print(type(main_nparray))

        print(main_nparray.shape)

运行时间：

2129.3716
2253.2248
2127.4056
2128.4252

运行时CPU使用率：

为估计该种形式下读写共享数据的耗时，给出下面代码：

import numpy as np

import multiprocessing

import time

import ctypes

NUM_PROCESS = multiprocessing.cpu_count()

size = 1000000

def worker(index):

    temp = shared_array_base[index]

    temp2 = np.zeros(size)+index

    for i in range(100*100):

        temp2 += 1

        ###temp[:] = temp2[:]

        ###2129.3716

        ###2253.2248

        ###2127.4056

        ###2128.4252

    return index

if __name__ == '__main__':

    shared_array_base = []

    for _ in range(NUM_PROCESS):

        shared_array_base.append(multiprocessing.Array(ctypes.c_double, size, lock=False))

    pool = multiprocessing.Pool(processes=NUM_PROCESS)

    a = time.time()

    result = pool.map(worker, range(NUM_PROCESS))

    b = time.time()

    print(b-a)

    for i in range(NUM_PROCESS):

        main_nparray = np.frombuffer(shared_array_base[i], dtype=ctypes.c_double)

        print(main_nparray)

        print(type(main_nparray))

        print(main_nparray.shape)

运行时间：

75.1454

75.0409

75.0613

74.9661

75.3398

74.6730

从上面的代码的运行时间上我们可以看出如果我们只使用multiprocessing.Value / multiprocessing.Array而不使用numpy.frombuffer函数的话也难以取得很好的性能表现，其中对共享数据的读写耗时大致需要2000秒以上，也就是说对共享数据的读操作如果不使用numpy.frombuffer的方式直接对数据底层进行操作，而是进行手动的类型转换，其耗时是巨大的，而如果使用nump.frombuffer的方式对共享数据进行读写其耗时是几乎可以不计的。同时我们也可以看到使用multiprocessing.Value / multiprocessing.Array方式子进程对父进程的共享数据进行读写操作是不需要父进程参与的，其中读写共享数据时进行的数据类型转换的工作都是在子进程内进行的。

同时可以看到如果不使用numpy.frombuffer方式直接对共享数据底层操作而是进行数据转换的话，Manager的方式要比手动转换性能高。

=================================================

最终结论就是在Python中如果多进程对共享内存操作的话，最佳性能的实现是使用multiprocessing.Value / multiprocessing.Array + numpy.frombuffer方式   。

以上功能使用Structure结构编写：

import time

import ctypes

from ctypes import *

import multiprocessing

import numpy as np

NUM_PROCESS = multiprocessing.cpu_count()

size = 1000000

class Test(Structure):

    pass

Test._fields_ = [(str(i), c_double*(size)) for i in range(NUM_PROCESS)]

data = multiprocessing.Value(Test, lock=False)    # all zero init

def worker(index):

    main_nparray = np.frombuffer(data, 'd', size, index*size*sizeof(ctypes.c_double))

    for i in range(10000):

        #print(index, main_nparray)

        main_nparray[:] = index + i

    return index

pool = multiprocessing.Pool(processes=NUM_PROCESS)

a = time.time()

result = pool.map(worker, range(NUM_PROCESS))

b = time.time()

print(b - a)

nparray = np.frombuffer(data, 'd', NUM_PROCESS*size, 0)

nparray.resize(NUM_PROCESS, size)

print("result:")

#print(nparray.shape)

print(nparray)

Python多进程共享numpy 数组的更多相关文章

  1. Python数据分析之numpy数组全解析

    1 什么是numpy numpy是一个在Python中做科学计算的基础库,重在数值计算,也是大部分Python科学计算库的基础库,多用于大型.多维数据上执行数值计算. 在NumPy 中,最重要的对象是 ...

  2. python：将numpy数组写入csv文件

    import numpy as np np.savetxt('E:\\forpython\\featvector.csv',data_to_save,delimiter=',')

  3. python 多进程共享全局变量之Manager()

    Manager支持的类型有list,dict,Namespace,Lock,RLock,Semaphore,BoundedSemaphore,Condition,Event,Queue,Value和A ...

  4. 利用Python进行数据分析——Numpy基础：数组和矢量计算

    利用Python进行数据分析--Numpy基础:数组和矢量计算 ndarry,一个具有矢量运算和复杂广播能力快速节省空间的多维数组 对整组数据进行快速运算的标准数学函数,无需for-loop 用于读写 ...

  5. python numpy 数组拼接

    我就写一下我遇到的,更多具体的请看Python之Numpy数组拼接,组合,连接 >>> aarray(［0, 1, 2],       [3, 4, 5],       [6, 7, ...

  6. python : 将txt文件中的数据读为numpy数组或列表

    很多时候,我们将数据存在txt或者csv格式的文件里,最后再用python读取出来,存到数组或者列表里,再做相应计算.本文首先介绍写入txt的方法,再根据不同的需求(存为数组还是list),介绍从tx ...

  7. Python数据分析工具库-Numpy 数组支持库（一）

    1 Numpy数组 在Python中有类似数组功能的数据结构,比如list,但在数据量大时,list的运行速度便不尽如意,Numpy(Numerical Python)提供了真正的数组功能,以及对数据 ...

  8. numpy数组与python的list互转，然后用json写入文件与c交互

    1.对于numpy的tofile方法,一个一维数组可以直接写成二进制形式,用c语言或者numpy.fromfile()可以读出来内容.而如果数组超过一维,tofile并不区分,也就是arr1=[1,2 ...

  9. 【Python】numpy 数组拼接、分割

    摘自https://docs.scipy.org 1.The Basics 1.1 numpy 数组基础 NumPy’s array class is called ndarray. ndarray. ...

  10. Python：numpy数组转换为json格式

    在python中,如何将一个numpy数组转换为json格式? 这是最近遇到的一个问题,做个笔记. 假设arr为numpy数组,将其转换为json格式: 总体思想是①首先转换为python的list, ...

随机推荐

  1. 请写出常用的linux指令

    a.cd /home 进入 '/ home' 目录' b.cd .. 返回上一级目录 c.cd ../.. 返回上两级目录 d.mkdir dir1 创建一个叫做 'dir1' 的目录' e.mkdi ...

  2. xshell+ssh+网络+加密

    使用xshell+ssh用于管理linux服务器,大概是目前最为流行的方式. 这个工具和技术涉及到: 计算机网络 加密解密 虽然不是专门的系统工程师,但还是相对频繁使用这套工具,有时候难免遇到一些不知 ...

  3. 解决Linux下无法编译带有中文的JAVA程序问题

    只要在编译的时候加上-encoding gbk即可 例如: javac -encoding gbk Myclass.java

  4. 实验11.ACL实验

    # 实验11.ACL实验 本实验用于测试ACL,类似于防火墙. 拓扑 要求阻塞PC1到PC2和server的全部协议,阻塞client1到server1的icmp协议 具体配置 首先利用ospf协议实 ...

  5. Vim的移动大法

    Vim的移动大法 移动光标的按键 "h" 向左移动 "j"向下移动 "k"向上移动 "l"向右移动 在单词之间移动 注: ...

  6. 详解Web应用安全系列(4)失效的访问控制

    在Web安全中,失效的访问控制(也称为权限控制失效或越权访问)是指用户在不具备相应权限的情况下访问了受限制的资源或执行了不允许的操作.这通常是由于Web应用系统未能建立合理的权限控制机制,或者权限控制 ...

  7. 高通Andriod开机流程与镜像说明

    # 高通Andriod开机流程与镜像说明 Android镜像说明 Android设备刷机时都需要ROM包,ROM包下面有很多的.img和其他的相关镜像文件,其中这里面包含了Android很多的分区,A ...

  8. 3568F-麒麟KylinOS国产操作系统演示案例

  9. Notepad++ 搭建简单Java编译运行环境

    简介 有时候使用Eclips进行Java相关方法的测试和验证太繁琐,经过查询实践,使用了Notepad++和JDK搭建了一个简单的编译运行环境. 搭建过程 在电脑上安装Java环境(网上教程很多,此过 ...

  10. Pypi配置API Token

    技术背景 在许久之前写的一篇博客中,我们介绍过使用twine向pypi上传我们自己的开源包的方法.最近发现这个方法已经不再支持了(报错信息如下所示),现在最新版需要使用API Token进行文件上传, ...