引用：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. vitepress 如何更换 favicon.ico

    favicon.ico 它出现在浏览器标签页上,是网站的标识之一. 准备图标 首先,你需要准备一个符合您要求的图标.通常,favicon.ico 使用的是 .ico 格式的图标文件,大小为 16x16 ...

  2. 基于Web3.0的区块链图片上传

    开始前,我们先简单了解一下基本的概念,我大致归纳为以下几个点 什么是Web3.0,和区块链又有什么关系?(上回的文章不就派上用场了) 需求:开发一个基于Python的Web 3.0图片上传系统.这个系 ...

  3. VIP视频解析

    效果图 新建窗口 import tkinter as tk# 创建一个窗口 root = tk.Tk() # 设置窗口大小 root.geometry('700x250+200+200') # 设置标 ...

  4. spring事务传递特性-REQUIRES_NEW和NESTED

    spring对于事务的实现的确是它的一大优点,节省了程序员不少时间. 关于事务,有许多可以聊的内容,例如实现方式.实现原理.传递特性等. 本文讨论传递特性中的REQUIRES_NEW,NESTED. ...

  5. Windows批处理文件(.bat和.cmd)

    cmd文件和bat文件的区别 从文件描述中的区别是,cmd文件叫做:Windows命令脚本,bat文件叫:批处理文件,两者都可以使用任意一款文本编辑器进行创建.编辑和修改,只是在cmd中支持的命令要多 ...

  6. SpringBoot连接数据库的方式

    1.Spring集成的服务 直接通过注入方式使用,如redis,jdbc等等服务. spring: redis: host: localhost port: 6379 password: 123456 ...

  7. 使用过 Vue SSR 吗？说说 SSR？

    先说下基本概念: ssr 的全称是 server side render,服务端渲染,vue ssr 的意思就是在服务端进行 vue 的渲染,直接对前端返回带有数据,并且是渲染好的HTML页面: 而不 ...

  8. Express手稿

  9. Linux Centos7搭建RabbitMQ

    下载依赖 yum -y install epel-release yum -y update 安装Erlang yum -y install erlang socat 测试安装成功 erl -vers ...

  10. Vue源码学习(二十):$emit、$on实现原理

    好家伙, 0.一个例子 <!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset= ...