精华内容
下载资源
问答
  • ->', duringTime2) print(result) print('-------------最终结果-------------') if duringTime1>duringTime2: print('并行运算更快') else: print('普通运算更快') 结果展示 更多参考 Python并行执行for循环 ...

    pool模块

    pool类能够提供指定数量的进程,供用户调用。当有新的请求提交到pool中时,如果池还没有满,就会创建一个新的进程来执行请求。如果池满,请求就会告知先等待,知道池中有进程借书,才会创建新的进程来执行这些请求。

    • apply()
      -该函数用于传递不定参数,同python中的apply函数一致,主进程会被阻塞知道函数执行结束。3.x之后不再出现

    • map()
      map(func, iterable[, chunksize=None])
      Pool类中的map方法,与内置的map函数用法基本一致,它会使得进程阻塞直到结果返回。注意:虽然第二个参数是一个迭代器,但再实际使用中,必须在整个队列都就绪后,程序才会运行子进程。

    • starmap()
      starmap( func, iterable, chunksize=None)
      使用起来像map方法。
      Like map() method but the elements of the iterable are expected to
      be iterables as well and will be unpacked as arguments. Hence
      func and (a, b) becomes func(a, b).

    • close()
      关闭进程池(pool),使其不再接受新的任务

    • join()
      主进程阻塞等待子进程的退出,join方法要在close或者terminate之后使用。

    Pool有一个processes参数,这个参数可以不设置,如果不设置函数会跟根据计算机的实际情况来决定要运行多少个进程
    我们也可自己设置,但是要综合考虑自己计算机的处理器性能,一般可以设置为CPU核心数,可以自己建立一个试验脚本进行测试
    注意:进程池pool对象定义放在main函数下,否则会报错

    map()函数中,第一个参数是我们需要引用的函数,第二个参数是需要迭代的参数列表。
    map()函数会自动将参数列表中的每一个数据作为参数传到第一个参数引用的函数中,得到最终结算结果,作为一个列表result输出。

    # -*- encoding: utf-8 -*-
    """
    @File    :   processesMore.py    
    @Contact :   ag@team-ag.club
    @License :   (C)Copyright 2019-2020, CodingPark
    
    @Modify Time      @Author    @Version    @Desciption
    ------------      -------    --------    -----------
    2020-10-17 19:52   AG         1.0         None
    """
    
    from multiprocessing.pool import Pool
    import time
    import datetime
    
    '''
    1
    时间小工具函数,方便进行时间处理
    @author: PurePeace
    @time: 2020年2月10日 02:42:55
    '''
    
    
    # get now timeString or timeStamp
    # 获取当前时间字符串或时间戳(都可精确到微秒)
    def getTime(needFormat=0, formatMS=True):
        if needFormat != 0:
            return datetime.datetime.now().strftime(f'%Y-%m-%d %H:%M:%S{r".%f" if formatMS else ""}')
        else:
            ft = time.time()
            return (ft if formatMS else int(ft))
    
    
    # timeString to timeStamp
    # 时间字符串转时间戳(有无微秒都可)
    def toTimeStamp(timeString):
        if '.' not in timeString:
            getMS = False
        else:
            getMS = True
        timeTuple = datetime.datetime.strptime(timeString, f'%Y-%m-%d %H:%M:%S{r".%f" if getMS else ""}')
        ft = float(f'{str(int(time.mktime(timeTuple.timetuple())))}' + (f'.{timeTuple.microsecond}' if getMS else ''))
        return (ft if getMS else int(ft))
    
    
    # timeStamp to timeString
    # 时间戳转时间字符串
    def toTimeString(timeStamp):
        if type(timeStamp) == int:
            getMS = False
        else:
            getMS = True
        timeTuple = datetime.datetime.utcfromtimestamp(timeStamp + 8 * 3600)
        return timeTuple.strftime(f'%Y-%m-%d %H:%M:%S{r".%f" if getMS else ""}')
    
    
    '''
    
    2
    并行运算时间及其效率检测
    
    '''
    
    print('普通运算')
    timeOn = getTime(1)
    print('开始时间-->', timeOn)
    
    
    def double(i):
        return i ** 2
    
    
    result = map(double, [123, 2234, 315])
    
    timeOff = getTime(1)
    print('结束时间-->', timeOff)
    duringTime1 = toTimeStamp(timeOff) - toTimeStamp(timeOn)
    print('总共耗时-->', duringTime1)
    print(result)
    for cc in result:
        print(cc, end=" ")
    
    print('\n----------------------------')
    
    print('使用Pool并行运算')
    timeOn = getTime(1)
    print('开始时间-->', timeOn)
    
    
    def double(i):
        return i ** 3
    
    
    pool = Pool(processes=4)
    result = pool.map(double, [123, 2234, 315])
    timeOff = getTime(1)
    print('结束时间-->', timeOff)
    duringTime2 = toTimeStamp(timeOff) - toTimeStamp(timeOn)
    print('总共耗时-->', duringTime2)
    print(result)
    
    
    print('-------------最终结果-------------')
    if duringTime1>duringTime2:
        print('并行运算更快')
    else:
        print('普通运算更快')
    
    

    结果展示
    在这里插入图片描述

    更多参考

    📍Python并行执行for循环
    https://blog.csdn.net/qq_23869697/article/details/84798614?utm_medium=distribute.pc_aggpage_search_result.none-task-blog-2allfirst_rank_v2~rank_v25-4-84798614.nonecase&utm_term=for循环并行&spm=1000.2123.3001.4430

    在这里插入图片描述

    展开全文
  • Python 并行编程

    2020-11-12 01:52:53
    第一章 认识并行计算Python 1. 介绍 2. 并行计算的内存架构 3. 内存管理 4. 并行编程模型 5. 如何设计一个并行程序 6. 如何评估并行程序的性能 7. 介绍Python 8. 并行世界的Python 9. 介绍线...

     

    参考:python-parallel-programming-cookbook-cn:https://python-parallel-programmning-cookbook.readthedocs.io/zh_CN/latest/

     

     

    第一章 认识并行计算和Python

     

    第二章 基于线程的并行

     

    第三章 基于进程的并行

     

    第四章 异步编程

     

    第五章 分布式Python编程

     

    第六章 Python GPU编程

     

     

     

    展开全文
  •  所谓执行,是指指令在数据上执行,所得的计算结果,存储到另一个寄存器中。  以上三个操作,不只是在SISD结构中存在,它们是所有计算机运行执行的基本操作。  在这种体系结构中,CPU按照顺序执行相应的程序...

    基于指令和可被同时处理的存储单元的数目,计算机系统可以分为以下四种类目:

    • 单指令,单数据单元(SISD)在该体系结构中,计算机是单处理器机器,一次只能用单一的指令来操作单一的数据流。在SISD中,机器指令按照顺序被处理。在一个计算机的时钟周期里,CPU执行三个操作,匹配、译指(decode,解码)和执行。

          所谓匹配,指的是CPU从寄存器中读取需要进行操作处理的数据以及需要执行的指令;

          所谓译指,是指CPU对指令的解码,使得计算机能够将指令转换为机器所能读懂的二进制码;

          所谓执行,是指指令在数据上执行,所得的计算结果,存储到另一个寄存器中。

       以上三个操作,不只是在SISD结构中存在,它们是所有计算机运行执行的基本操作。

         在这种体系结构中,CPU按照顺序执行相应的程序,该架构主要包含三个部分,中心存储单元、CPU以及I/O系统,中心存储单元用于存储指令和程序数据;CPU用于从存储单元中获取数据和指令,并且     对指令进行译指,然后按照程序既定的顺序执行它。I/O系统则是用来输入和输出程序的数据。

    • 单指令,多数据单元(SIMD)SIMD结构的计算机,由n个相同的处理器构成,每个处理器拥有其独有的存储单元,用于存储数据。所有处理器在单一指令流的控制下工作,另外,每个处理器处理相对应的一条数据流。每个处理器对不同的数据,同时执行同一条指令。这种架构比MISD架构功能更为全面和强大。在这种结构的计算机中,结合并行算法,适合解决涵盖多种功能的问题,此外,在这种计算机结构中,算法更容易设计、分析以及嵌入。唯一的限制是,需要将一个大问题分成多个子问题,要求每个子问题都是相同性质的,这样每个子问题才能通过相同的指令被同时处理。
    • 多指令,单数据单元(MISD)在这个结构中,计算机拥有多个处理器核,每个处理器拥有其自己的控制单元,它们共享存储单元。在每个时钟周期中,每个处理器根据从自己的控制单元中读取的指令,同时处理从存储器中读取的数据。在这个结构下,并行性(指令层面的并行性)是通过对同一段数据执行多种操作而获得的。在这个结构中,能够解决的问题类型相当特殊,比如与数据加密有关的问题。
    • 多指令,多数据单元(MIMD)。

    转载于:https://www.cnblogs.com/sgatbl/p/9222391.html

    展开全文
  • 目前CUDA支持的编程语言包括C/C++/Python/Java/Fortran等。 2.CUDA生态 上图从上到下依次为:基于GPU计算的应用程序,一些GPU计算的库与中间件,编程语言,不同架构的GPU设备。 3.CUDA并行计算模式 并行计算即是...

    一、CUDA异构计算基础

    1.CUDA简介

    CUDA(Compute Unified Device Architecture),是一种基于C/C++的编程方法,支持异构编程的扩展方法,提供了简单明了的APIs,能够轻松的管理存储系统。目前CUDA支持的编程语言包括C/C++/Python/Java/Fortran等。

    2.CUDA生态

    CUDA生态架构
    上图从上到下依次为:基于GPU计算的应用程序,一些GPU计算的库与中间件,编程语言,不同架构的GPU设备。

    3.CUDA并行计算模式

    并行计算即是同时应用多个计算资源解决一个可以并行处理计算问题。
    关键点有两个:一是拥有多个计算资源或处理器,二是一个大问题可以拆分为多个离散的部分同时进行
    并行处理计算问题

    4.术语:

    当今的显卡拥有强大的计算能力,它有自己的计算核心和内存(在显卡中的内存称为现存),为了对CPU计算资源和GPU计算资源进行区分,异构计算中给出以下术语。
    host:指的是CPU和主机内存(host memory)
    device:指的是GPU和显存(device memory)
    kernels:核函数,是一个由CPU发起的在GPU上执行的函数。
    device function:只能由GPU调用的GPU上执行的函数
    Host与Device

    5.CPU结构

    CPU结构图
    上图是一个8核心CPU内部结构图,可以看到核心(Core)所占的芯片的面积大概只有三分之一,更多的空间被用于作为存储(高速缓存Cache和内存控制器等)。

    6、GPU结构

    GPU结构则与CPU的设计理念有所不同,下图为GPU结构示意图,可以看到GPU中的计算核(图中深绿色部分)明显增多且数量巨大(实际的核心比示意图更多,多达上千个)。
    GPU结构
    可以看到计算单元又被划分到不同的SM(stream multi-processor,流多处理器) 中,其中又包括了处理不同数据的核,有用于双精度浮点型计算的FP64,整数型计算的INT,单精度计算的FP32以及用于深度学习的TENSOR CORE以及计算之外寄存器和缓存等。
    SM结构

    7.计算流程

    ①首先需要将数据从主机内存复制到GPU显存,因为CPU只能访问主机内存,GPU只能访问显存,因此需要并行计算的任务数据需要从host 拷贝到device。
    数据从host到device
    ②然后,CPU会下发指令给GPU,使其加载GPU程序并进行执行
    GPU执行程序
    ③GPU程序执行完毕后,将显存中的结果从device拷贝回主机内存中,再进行其他的操作(保存,打印,展示等)。
    执行结果拷贝回主机内存
    上面三步便是GPU编程的基本步骤,可以总结出一个简单的异构计算流程如下:先顺序执行CPU代码,遇到耗时的可以并行执行的程序时,采用GPU并行编程,然后回到CPU顺序执行处理逻辑,如此反复进行。
    异构计算的一般步骤

    8.CUDA的线程层次

    之前都是根据硬件的物理结构进行讨论的,接下来再对编程模型上CUDA的线程层次进行描述。CUDA将线程进行了二级分组,从大到小依次为Grid,Block,Thread。一个Grid包含多个Block,一个Block包含多个Thread。Grid与Block均可以是二维的或者三维的,一个二维的Grid和Block如图所示:
    CUDA线程层次
    在默认情况下,执行一个GPU并行计算任务时,一个Thread对应于一个Thread Processor,即硬件里面的一个处理器核心。一个Block会对应一个SM单元。一个Grid则对应了一个GPU设备,如下所示:
    编程模型与硬件的对应关系

    9.CUDA存储结构

    下图为一个Grid(对应一个物理GPU设备)的存储结构示意图。图中的Global Memory(全局内存),Constant Memory(常量内存)与Texture Memory(纹理内存)都属于显存的一部分,与Host主机内存相对,在每一个Block之中又有Shared Memory(共享内存)提供给该Block所有线程的共享内存。每一个Thread(线程)又拥有自己的寄存器组(Registers)和本地内存(Local Memory)。
    CUDA存储结构

    二、CUDA图像处理简单例子

    1.环境需求

    • python3.6+
    • numba
    • py-opencv

    2.示例代码

    import cv2
    from numba import cuda
    import time
    import math
    
    # GPU function
    @cuda.jit()
    def process_gpu(img):
        tx = cuda.blockIdx.x * cuda.blockDim.x + cuda.threadIdx.x
        ty = cuda.blockIdx.y * cuda.blockDim.y + cuda.threadIdx.y
        for channel in range(3):
            color = img[tx, ty][channel] * 2.0 + 30
            if color > 255:
                img[tx, ty][channel] = 255
            elif color < 0:
                img[tx, ty][channel] = 0
            else:
                img[tx, ty][channel] = color
    
    
    # CPU function
    def process_cpu(img, dst):
        height, width, channels = img.shape
        for h in range(height):
            for w in range(width):
                for c in range(channels):
                    color = img[h, w][c] * 2.0 + 30
                    if color > 255:
                        dst[h, w][c] = 255
                    elif color < 0:
                        dst[h, w][c] = 0
                    else:
                        dst[h, w][c] = color
    
    
    if __name__ == '__main__':
        img = cv2.imread("../image.jpg")
        height, width, channels = img.shape
    
        dst_cpu = img.copy()
        start_cpu = time.time()
        process_cpu(img, dst_cpu)
        end_cpu = time.time()
        time_cpu = (end_cpu - start_cpu)
        print("CPU process time: " + str(time_cpu))
    
        ##GPU function
        dImg = cuda.to_device(img)
        threadsperblock = (32, 32)
        blockspergrid_x = int(math.ceil(height / threadsperblock[0]))
        blockspergrid_y = int(math.ceil(width / threadsperblock[1]))
        blockspergrid = (blockspergrid_x, blockspergrid_y)
    
        cuda.synchronize()
        start_gpu = time.time()
        process_gpu[blockspergrid, threadsperblock](dImg)
        end_gpu = time.time()
        cuda.synchronize()
        time_gpu = (end_gpu - start_gpu)
        print("GPU process time: " + str(time_gpu))
        dst_gpu = dImg.copy_to_host()
    
        # save
        cv2.imwrite("result_cpu.jpg", dst_cpu)
        cv2.imwrite("result_gpu.jpg", dst_gpu)
        print("Done.")
    

    3.代码解读

    为了方便查看,再将线程层次图放在这里:CUDA线程层次
    示例程序主要读入图片并进行亮度变换,算法为针对图片的每一个像素点的每一个通道的值都乘以2加上30。因为每一个像素都是独立的,所以该任务可以拆分为并行执行的任务。GPU部分,需要根据线程模型给每一个GPU处理核心分配任务。首先使用cuda.to_device(img) 将图片从主机内存拷贝到显存。然后,分配一个Block有(32,32)即1024个线程。然后根据图像的宽高和刚刚定义的Block大小,来确定Grid中分为多少个Block。

    #GPU function
    dImg = cuda.to_device(img)
    threadsperblock = (32, 32)
    blockspergrid_x = int(math.ceil(height / threadsperblock[0]))
    blockspergrid_y = int(math.ceil(width / threadsperblock[1]))
    blockspergrid = (blockspergrid_x, blockspergrid_y)
    

    准备好以后,便通过调用核函数(Kernel function)来执行GPU程序,需要指定上方代码计算出的threadsperblock和blockspergrid :

        process_gpu[blockspergrid, threadsperblock](dImg)
    

    关于核函数(即GPU执行的函数)的定义,需要在函数上方写上 @cuda.jit() 注解,用于标识其为核函数。核函数内部可以根据定义的block大小和grid大小将计算任务分配到不同的计算单元上。根据cuda.blockIdx.x获取块ID的横坐标,乘以块的横坐标维度(本例为32)再加上线程ID的横坐标,即可唯一确定图像上的一个横坐标点。纵坐标的表示类似(这一块的实现类似于如何将二维数组转化为一维数组进行表示,可以参考相关内容进行理解)。

    def process_gpu(img):
        tx = cuda.blockIdx.x * cuda.blockDim.x + cuda.threadIdx.x
        ty = cuda.blockIdx.y * cuda.blockDim.y + cuda.threadIdx.y
        for channel in range(3):
            color = img[tx, ty][channel] * 2.0 + 30
            if color > 255:
                img[tx, ty][channel] = 255
            elif color < 0:
                img[tx, ty][channel] = 0
            else:
                img[tx, ty][channel] = color
    

    4.结果展示

    运行本程序,可以看到GPU处理速度比CPU快很多,对比结果如下:
    GPU与CPU处理时间对比
    PS:上述实验结果为R7 1700X与RTX 2070对比。
    原图为988 x 988如下:
    在这里插入图片描述
    CPU与GPU处理获得相同的结果如下:
    处理后的图片

    参考

    https://images.nvidia.cn/cn/webinars/2020/jun09/download-358293.pdf
    https://info.nvidia.com/358293-ondemand.html

    展开全文
  • Fork/Join 模式是处理并行编程的一个经典的方法,python中也早已有了Parallel Python模块支持多核并行计算,erlang等为并行计算而生的语言也大红大紫,下面我们通过计算给定数组中数据所有素数之和这样一个实例,来...
  • 该模块给我们提供一个抽象层,我们的程序最终解决还是要依靠多线程和多进程,但是我们不用考虑多进程和多线程的实现细节,我们通过python封装好的组件,能够快速实现多进程和多线程的编码 当我们解决需求时,需...
  • python并行编程 中文版

    2018-08-24 11:46:34
    易用和易学、可扩展性和丰富的库以及应用,让它成为了一个全能性的工具,当然,在并行计算方面也得 心应手。最后结合在Python中的应用讲了线程和进程。解决一个大问题的一般方法是,将其拆分成若干小 的、独立的问题...
  • Python并行编程手册.pdf

    2019-07-03 08:38:09
    的工具, 当然, 对于并行计算亦如此。 本章的最后一部分将会介绍线程与进程的概念, 以及它们在Python语言中的使 用。 解决大问题的一种典型方式是将其分解为一系列小问题以及独立的部分, 这样就可以同时解决它们...
  • 不过,在Python中进行并行编程可能会非常棘手。 在本教程中,我们将研究为什么并行性很难,尤其是在Python上下文中,为此,我们将经历以下内容: 为什么在Python并行性会很棘手 (提示:这是由于GIL(全局...
  • 之前讲解了多线程的开发,合理利用多线程可以提高效率,但是由于Python GIL全局解释器锁的限制,多线程更多的适合IO密集型的操作,因为IO密集型会随时释放GIL,这样可以允许更多的并发。所以IO密集型首选多线程。 ...
  • 一. 线程和进程的概念 进程是操作系统中正在执行的不同应用程序的一个实例 ...Python的asyncio模块实现的异步IO编程框架中,协程是对使用async关键字定义的异步函数的调用 一个进程包含多个线程,同样,一个程序可以包
  • Python并行编程中文版

    2020-03-03 00:07:24
    SISD single CPU处理器架构 对于每一个CPU时钟按照Fetch:CPU从一片内存区域中获得数据和指令. Decode: CPU对指令进行解码 . Excute:执行, 将结果保存在另一个寄存器中 在计算机中寄存器最快, 内存次之, 硬盘最慢 ...
  • 前面讲了Python中的线程并行编程,这里来说说,Python中的进程编程吧。线程相对于进程来说,创建时间消耗更短,是机器调度的最小单元,但是机器是按照进程来分配计算资源的。正由于进程消耗时间才有了线程。在Python...
  • 第3章 Python并行计算第4章 Celery分布式应用第5章 云平台部署Python第6章 超级计算机群使用Python第7章 测试和调试分布式应用第8章 继续学习 我们在前两章提到了线程、进程,还有并发编程。我们在很高的层次,用...
  • 分布式计算的基本理念是将工作划分为一个一个小任务,分发给多台设备处理,再汇总结果。在分布式计算中,网络中的机器必须要保持可用(延迟误差、意外宕机等等),需要一个持续监控架构 分布式多进程2 ...
  • 计算机科学的研究,不仅应该涵盖计算处理所基于的原理,还因该反映这些领域目前的知识状态。当今,计算机技术要求来自计算机科学所有分支的专业人员理解计算机处理的基础的关键,在于知道软件和硬件在所有层面上的...
  • 水罐:基于任务的并行化框架 Jug允许您编写分解为任务的代码,并在不同的处理器上运行不同的任务。 它使用文件系统在进程之间进行通信,并且可以通过NFS正常工作,因此您可以协调不同计算机上的进程。 Jug是一个纯...
  • 该存储库包含该课程的所有笔记本:Python中的Dask并行计算
  • python 多cpu并行编程

    千次阅读 2017-06-03 19:05:07
    python 多线程只能算并发,...python 下 pp包支持多cpu并行计算 安装 pip install pp 使用 #-*- coding: UTF-8 -*- import math, sys, time import pp def IsPrime(n): """返回n是否是素数""" if not isinstan
  • 2、做并行计算、数据挖掘,机器学习等一般都要用的numpy,这个在Windows版本上安装有点问题,安装比较麻烦,建议在linux上搭建环境 3、安装openmpi,(不太好装)这个在网上目前还没有比较好的快捷安装方法,一般是...
  • 前言:本系列将包含Python并行编程的相关技术内容,包括Python线程、Python进程、并发编程的异步模式及终极大法Python分布式计算如Celery、SCOOP等相关技术。 关键词: threading multiprocessing asyncio Celery ...
  • 前言:本系列将包含Python并行编程的相关技术内容,包括Python线程、Python进程、并发编程的异步模式及终极大法Python分布式计算如Celery、SCOOP等相关技术。 关键词: threading multiprocessing asyncio Celery ...
  • Python 多进程并行编程实践: multiprocessing 模块 2017/04/17 · 实践项目 ...并行计算是使用并行计算机来减少单个计算问题所需要的时间,我们可以通过利用编程语言显式的说明计算中的不同部分如何再不同的处理...
  • Pytlab Python 中文社区专栏作者主要从事科学计算与 高性能计算领域的应用主要语言为 Python CC++ 熟 悉数值算法 最优化方法蒙特卡洛算法等与并行化算法 MPI,OpenMP 等多线程以及多进程并行化以及 python 优化方法...
  • 并行计算是使用并行计算机来减少单个计算问题所需要的时间,我们可以通过利用编程语言显式的说明计算中的不同部分如何再不同的处理器上同时执行来设计我们的并行程序,最终达到大幅度提升程序效率的目的。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 395
精华内容 158
关键字:

python并行计算编程

python 订阅