精华内容
下载资源
问答
  • 并行处理包括
    千次阅读
    2021-07-14 10:56:47

    1. 背景

    本文是一个短文章,介绍Java 中的并行处理。

    说明:10多分钟读完的文章我称之为短文章,适合快速阅读。

    2.知识

    并行计算(parallel computing)一般是指许多指令得以同时进行的计算模式。在同时进行的前提下,可以将计算的过程分解成小部分,之后以并发方式来加以解决。

    也就是分解为几个过程:

    • 1、将一个大任务拆分成多个子任务,子任务还可以继续拆分。
    • 2、各个子任务同时进行运算执行。
    • 3、在执行完毕后,可能会有个 " 归纳 " 的任务,比如 求和,求平均等。

    再简化一点的理解就是: 先拆分 --> 在同时进行计算 --> 最后“归纳”

    为什么要“并行”,优点呢?

    • 1、为了获得 “节省时间”,“快”。适合用于大规模运算的场景。从理论上讲,在 n 个并行处理的执行速度可能会是在单一处理机上执行的速度的 n 倍。
    • 2、以前的计算机是单核的,现代的计算机Cpu都是多核的,服务器甚至都是多Cpu的,并行计算可以充分利用硬件的性能。

    3. Java 中的并行处理

    JDK 8 新增的Stream API(java.util.stream)将生成环境的函数式编程引入了Java库中,可以方便开发者能够写出更加有效、更加简洁的代码。

    steam 的另一个价值是创造性地支持并行处理(parallel processing)。示例:

    final Collection< Task > tasks = Arrays.asList(
        new Task( Status.OPEN, 5 ),
        new Task( Status.OPEN, 13 ),
        new Task( Status.CLOSED, 8 ) 
    );
    
    // 并行执行多个任务,并 求和
    final double totalPoints = tasks
       .stream()
       .parallel()
       .map( task -> task.getPoints() ) // or map( Task::getPoints ) 
       .reduce( 0, Integer::sum );
     
    System.out.println( "Total points (all tasks): " + totalPoints );

    对于上面的tasks集合,上面的代码计算所有任务的点数之和。
    它使用 parallel 方法并行处理所有的task,并使用 reduce 方法计算最终的结果。

    4. 扩展

    线程池方式实现并行处理

    jdk1.5引入了并发包,其中包括了ThreadPoolExecutor,相关代码如下:

    public class ExecutorServiceTest {
     
        public static final int THRESHOLD = 10_000;
        public static long[] numbers;
     
        public static void main(String[] args) throws Exception {
            numbers = LongStream.rangeClosed(1, 10_000_000).toArray();
            ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors() + 1);
            CompletionService<Long> completionService = new ExecutorCompletionService<Long>(executor);
            int taskSize = (int) (numbers.length / THRESHOLD);
            for (int i = 1; i <= taskSize; i++) {
                final int key = i;
                completionService.submit(new Callable<Long>() {
     
                    @Override
                    public Long call() throws Exception {
                        return sum((key - 1) * THRESHOLD, key * THRESHOLD);
                    }
                });
            }
            long sumValue = 0;
            for (int i = 0; i < taskSize; i++) {
                sumValue += completionService.take().get();
            }
            // 所有任务已经完成,关闭线程池
            System.out.println("sumValue = " + sumValue);
            executor.shutdown();
        }
     
        private static long sum(int start, int end) {
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += numbers[i];
            }
            return sum;
        }
    }
    复制代码

    使用 fork/join框架

    分支/合并框架的目的是以递归的方式将可以并行的认为拆分成更小的任务,然后将每个子任务的结果合并起来生成整体结果;相关代码如下:

    public class ForkJoinTest extends java.util.concurrent.RecursiveTask<Long> {
        
        private static final long serialVersionUID = 1L;
        private final long[] numbers;
        private final int start;
        private final int end;
        public static final long THRESHOLD = 10_000;
     
        public ForkJoinTest(long[] numbers) {
            this(numbers, 0, numbers.length);
        }
     
        private ForkJoinTest(long[] numbers, int start, int end) {
            this.numbers = numbers;
            this.start = start;
            this.end = end;
        }
     
        @Override
        protected Long compute() {
            int length = end - start;
            if (length <= THRESHOLD) {
                return computeSequentially();
            }
            ForkJoinTest leftTask = new ForkJoinTest(numbers, start, start + length / 2);
            leftTask.fork();
            ForkJoinTest rightTask = new ForkJoinTest(numbers, start + length / 2, end);
            Long rightResult = rightTask.compute();
            // 注:join方法会阻塞,因此有必要在两个子任务的计算都开始之后才执行join方法
            Long leftResult = leftTask.join();
            return leftResult + rightResult;
        }
     
        private long computeSequentially() {
            long sum = 0;
            for (int i = start; i < end; i++) {
                sum += numbers[i];
            }
            return sum;
        }
     
        public static void main(String[] args) {
            System.out.println(forkJoinSum(10_000_000));
        }
     
        public static long forkJoinSum(long n) {
            long[] numbers = LongStream.rangeClosed(1, n).toArray();
            ForkJoinTask<Long> task = new ForkJoinTest(numbers);
            return new ForkJoinPool().invoke(task);
        }
    }

    上面的代码实现了 递归方式拆分子任务,并放入到线程池中执行。

    5.参考:

    https://zh.wikipedia.org/wiki/%E5%B9%B6%E8%A1%8C%E8%AE%A1%E7%AE%97

    END

    更多相关内容
  • Python并行处理

    2021-02-02 20:03:01
    例如,这个所谓的进程环境包括该进程使用的内存页,处理该进程打开的文件,用户和组的访问权限,以及它的整个命令行调用,包括给定的参数。此信息保存在UNIX/Linux系统的流程文件系统中,该系统是一个虚拟文件系统,...
  • 图像并行处理包括并行算法和多处理器并行硬件系统,图像处理并行算法的执行效率依赖于多处理器系统的硬件结构。通常,一种并行结构只适合于一类并行算法的映射。  20世纪90年代至今,图像并行处理技术一直是图像...
  • 随着多媒体图像处理应用的迅速发展,体积小、重量轻、结构灵活、处理能力强的嵌入式数字图像处理系统在...图像并行处理包括并行算法和多处理器并行硬件系统,图像处理并行算法的执行效率依赖于多处理器系统的硬件结构。
  • 并行处理及分布式系统

    千次阅读 2021-12-24 17:43:45
    并行计算基础 本篇博客记录了我在学习并行计算过程中的收获,包含以下部分的内容: 为什么要并行计算 并行硬件和并行软件 MPI编程 Pthreads编程 OpenMP编程 并行程序开发 CUDA编程基础。 1 为什么要并行计算 ...

    并行处理及分布式系统

    1 为什么要并行计算

    1.1 为什么需要不断提升性能

    • 随着计算能力的增加,我们所面临的计算问题和需求也在增加
    • 随着技术的进步,我们从未想过的技术得到了解决,比如:人类基因解码、更准确的医疗成像、更快速准确的网络搜索…
    • 更复杂的问题仍有待解决,比如:气候模拟、蛋白质折叠、药物发现、能源研究、数据分析…

    1.2 为什么要构建并行系统

    单处理器性能大幅度提升的主要方法是增加集成电路晶体管密度。但是随着晶体管尺寸的减小,晶体管的传递速度增快,它们的能耗也在增加,大多数的能量是以热能的形式消耗,当一块集成电路变得太热的时候,就会变得不可靠。在 21 世纪的第一个 10 年中,使用空气冷却集成电路的散热能力已达到极限。也就是说,只通过增加集成电路的速度来提升处理器的性能的方法不可取。在这种条件下,集成电路制造商提出多核处理器的思路。

    1.3 为什么要编写并行程序

    大多数为传统单核系统编写的程序无法利用多核处理器,为了使程序能够更快地运行,有更加逼真的图像,就需要将串行程序改写为并行程序。

    1.4 如何编写并行程序

    想要解决某个问题,需要编写其对应的并行程序,首先需要对任务进行划分,确定其属于任务并行还是数据并行。

    • 任务并行:当许多任务或函数可以独立地、大规模地并行执行时,这就是任务并行。任务并行的重点在于利用多核系统对任务进行分配,将待解决的问题所需要的执行的各个任务分配到各个核上执行。
    • 数据并行:当可以同时处理许多数据时,这就是数据并行。数据并行的重点在于利用多核系统对数据进行分配,每个核在分配到的数据集上执行大致相似的数据操作

    1.5 接下来做什么

    首先我会参考《并行程序设计导论》所讲的 C 语言的三种拓展:消息传递接口(Message-Passing Interface,MPI)、POSIX 线程(POSIX threads,Pthreads) 和 OpenMP 来编写基本的并行程序。

    选择并行程序实现框架的时候应该根据计算机的架构来选择,即根据硬件选择软件。Pthreads 和 OpenMP 是为 共享内存系统 的编程而设计的,它们提过访问共享内存的机制;而 MPI 是为 分布式内存系统 的编程而设计的,它提供发送消息的机制。

    图中(a)表示共享内存系统,(b)表示分布式内存系统。

    1.6 并发、并行、分布式

    • 并发计算:一个程序的多个任务再同一个时段内可以同时执行
    • 并行计算:一个程序通过多个任务紧密协作来解决某个问题
    • 分布式计算:一个程序需要与其他程序写作来解决某个问题

    2 并行硬件和并行软件

    2.1 背景知识

    并行计算涉及到两个不同的技术领域:

    • 计算机架构(硬件)
    • 并行程序设计(软件)

    硬件主要的目标就是为软件提供更快的计算速度,更低的性能功耗比,硬件结构上支持更快的并行。
    软件的主要目的是使用当前的硬件压榨出最高的性能,给应用提供更稳定快速的计算结果。

    2.1.1 冯 · 洛依曼结构

    经典的冯 · 洛依曼结构包括存储器、运算器、控制器、输入设备、输出设备,其中运算器和控制器都在 CPU 之中,CPU 和主存通过总线连接。当数据或指令从主存传送到 CPU 时,称为数据或指令从内存中取出或者读出;当数据或指令从 CPU 传送到主存时,称为数据或指令写入或者存入内存中。这样主存和 CPU 之间的分离称为 冯 · 洛依曼瓶颈。

    2.1.2 进程、多任务及线程

    • 进程:正在运行的程序的一个实例。

    • 多任务:通过时间片轮转的方式使人产生多个任务同时执行的错觉。

    • 线程:线程包含在进程中,同一个进程内的线程共享内存和 I/O 设备,利用线程程序员可以将程序划分为多个大致独立的任务。

    2.2 对冯 · 洛依曼模型的改进

    《并行程序设计导论》介绍了三种对冯 · 洛依曼模型的改进措施:缓存、虚拟内存、低层次并行

    2.2.1 缓存(Cache)

    基于访存局部性而设计的 CPU 缓存(CPU Cache)有着比其他存储器更小的访问开销,CPU Cache 通常和 CPU 位于同一块芯片上,访存开销比普通内存小很多。

    局部性原理

    • 访问一个位置之后,接着访问其附近的位置
    • 空间局部性:访问临近的位置
    • 时间局部性:最近访问的位置,在不久的将来还会访问

    CPU Cache 一般分为不同的层(level),第一层(L1)最小但是访问速度最快,更高层的 Cache (L2, L3, …)更大但访问速度较慢。大多数系统采用 3 层 Cache,每层 Cache 中的数据不重合,且都会存放在主存中。

    当 CPU 需要访问数据或指令时,它会沿着 L1 Cache -> L2 Cache -> L3 Cache -> 主存 这条路径查询,若从 Cache 中查询到数据或指令时,则称为 Cache 命中 或 命中;若没有从 Cache 中查询到则称为 Cache 缺失 或 缺失。

    Cache 命中 Cache 缺失

    当 CPU 向 Cache 写数据时,会出现 Cache 中的值与主存中的值不一致的情况,为了解决这个问题,数中介绍了两种方法:

    • 写直达:当 CPU 向 Cache 写数据时,更新主存中的数据。
    • 写回:将 Cache 中的数据标记为 脏数据,当 Cache line 被主存中的新的 Cache line 替换时,脏的 Cache line 会被写入主存。

    在 Cache 设计中,另一个问题是 Cache line 应该存储在什么位置。当从主存中取出一个 Cache line 时,应该把这个 Cache line 放到 Cache 中的什么位置,不同的系统采用不同的方式,这些方式分别为:

    • 全相联:一个新的 Cache line 可以放在 Cache 中的任意位置
    • 直接映射:每一个 Cache line 在 Cache 中都有唯一的位置
    • n路组相联:每个 Cache line 可以被放在 n 个不同的位置中的一个

    当主存中的行能被映射到不同到 Cache 中的不同位置时,需要决定替换或者驱逐 Cache 中的某一行。常用的方案是最近最少使用

    2.2.2 虚拟内存

    如果一个大型的程序或者程序需要访问大型数据集,那么所有的指令或者数据可能在主存中放不下。采用 虚拟内存,使得主存可以作为辅存的缓存。利用时空局部性的原理,只把正在运行程序的活动部分保存在主存中。

    2.2.3 低层次并行

    指令级并行

    指令级并行通过让多个处理器部件或者功能单元同时执行指令来提高处理器的性能。有两种主要方法来实现指令级并行:

    • 流水线:将功能单元分阶段安排。
    • 多发射:让多条指令同时启动。
      • 静态多发射:功能单元在编译时调度
      • 动态多发射:功能单元在运行时调度

    硬件多线程

    硬件多线程为系统提供了一种机制,使得当前执行的任务被阻塞时,系统能够继续其他有用的工作。

    • 细粒度多线程:处理器在每条指令执行完后切换线程,从而跳过被阻塞的线程。
    • 粗粒度多线程:只切换那些需要等待较长时间才能完成操作而被阻塞的线程。
    • 同步多线程:通过允许多个县城同时使用多个功能单元来利用超标量处理器的性能。

    2.3 并行硬件

    利用 Flynn 分类法 对计算机体系结构进行划分:

    分别以数据和指令进行分析:

    • 单指令单数据 SISD (传统串行计算机,386)
    • 单指令多数据 SIMD (并行架构,比如向量机,所有核心指令唯一,但是数据不同,现在 CPU 基本都有这类的向量指令)
    • 多指令单数据 MISD (少见,多个指令围殴一个数据)
    • 多指令多数据 MIMD (并行架构,多核心,多指令,异步处理多个数据流,从而实现空间上的并行,MIMD 多数情况下包含 SIMD,就是 MIMD 有很多计算核,计算核支持 SIMD)

    注:GPU 属于 SPMD,但是其可以使用 SIMD 并行

    计算机架构也可以 根据内存划分:

    • 共享内存系统
      共享内存系统
    • 分布式内存系统
      分布式内存系统

    2.4 并行软件

    负载均衡:将任务在线程或进程之间分配,并使得每个进程或线程获得大致相等的工作量。

    将串行程序或者算法转换为并行程序的过程称为 并行化。某些程序,如果能够通过简单地将会任务分配给进程或线程来实现并行化,我们称该程序是 易并行的

    动态线程

    • 主线程等待工作请求,当一个请求到达时,它会派生出一个新线程来执行该请求。当新线程完成任务后,就会终止执行再合并到主线程中。
    • 资源的有效使用,但是线程的创建和终止非常耗时。

    静态线程

    • 创建线程池并分配任务,但线程不被终止直到被清理。

    • 性能更好,但可能会浪费系统资源。

    非确定性:在任何一个 MIMD 系统中,如果处理器异步执行,那么很可能会引发 非确定性。给定的输入能产生不同的输出,这种计算称为非确定性。

    临界区:一次只能被一个线程执行的代码块。访问临界区的行为应该是 互斥的

    保证互斥执行的最常用机制是 互斥锁 或者 互斥量

    2.5 输入和输出

    为了解决多个进程或线程直接输入或输出的矛盾,需要遵循以下规则:

    • 在分布式内存程序中,只有进程 0 能够访问 stdin。在共享内存程序中,只有主线程或线程 0 能够访问 stdin。
    • 在分布式内存和共享内存系统中,所有进程或线程都能够访问 stdout 和 stderr。
    • 但是,因为输出到 stdout 的非确定性顺序,大多数情况下,只有一个进程或线程会将结果输出到 stdout。但输出调试程序的结果是一个里外,在这种情况下,允许多个进程或线程写 stdout
    • 只有一个进程或线程会尝试访问一个除 stdin、stdout 或者 stderr 外的文件。
    • 调试程序输出在生成输出结果时,应该包括进程或线程的序号或者进程标识符。

    2.6 性能

    线性加速比 T 并 行 = T 串 行 / p T_{并行}=T_{串行}/p T=T/p,其中 p p p 表示程序运行所运行的系统的核数。

    加速比
    S = T 并 行 T 串 行 S=\cfrac{T_{并行}}{T_{串行}} S=TT
    并行程序的效率
    E = S P = T 串 行 p ⋅ T 并 行 E=\frac{S}{P}=\cfrac{T_{串行}}{p\cdot{T_{并行}}} E=PS=pTT
    并行开销的影响
    T 并 行 = T 串 行 / p   +   T 开 销 T_{并行}=T_{串行}/p\ +\ T_{开销} T=T/p + T

    阿姆达尔定律

    除非一个串行程序的执行几乎全都并行化,否则,不论有多少可以利用的核,通过并行化所产生的加速比都会是受限的。

    假设原串行程序所需时间为 T 串 行 T_{串行} T,其中的 α \alpha α 的比例能够并行化,假设并行化的这一部分使用 p p p 个核,则程序中可以并行化的部分的加速比为 p p p。当 p p p 趋于无穷大时,该程序的加速比为:
    S ∞ = 1 1 − α S_{\infty} = \frac{1}{1-\alpha} S=1α1
    假设该程序可并行化部分并行化之后,其整体的加速比为:
    S = T 串 行 α × T 串 行 / p   +   ( 1 − α ) × T 串 行 = 1 α / p   +   ( 1 − α ) S=\frac{T_{串行}}{\alpha\times{T_{串行}}/p\ +\ (1-\alpha)\times{T_{串行}}}=\frac{1}{\alpha/p\ +\ (1-\alpha)} S=α×T/p + (1α)×TT=α/p + (1α)1
    所以可得:
    S ≤ 1 1 − α S\le \frac{1}{1-\alpha} S1α1

    可扩展性

    假设我们运行一个拥有固定进程或线程数目的并行程序,并且它的输入规模也是固定的,那么我们可以得到一个效率值 E E E。现在,我们增加该程序所用的进程或线程数,如果在输入规模也以相应增长率增加的情况下,该程序的效率一直都是 E E E,那么我们就称该程序是 可拓展的

    如果在增加进程或线程的个数时,可以维持固定的效率,却不增加问题的规模,那么程序称为 强可拓展性的

    如果在增加进程或线程个数的同时,只有以相同倍率增加问题的规模才能使效率值保持不变,那么程序就称为 弱可拓展的

    2.7 并行程序设计

    Foster 方法

    • 划分 问题并识别任务:将要执行的指令和数据按照计算拆分为多个小任务。这一步的关键在于识别出可以并行执行的任务。
    • 在任务中识别要执行的 通信:确定前一步所识别出来的任务之间需要执行哪些通信。
    • 凝聚聚合 任务使之变成较大的组任务:将第一步中确定的任务和通信合并成更大的任务。
    • 将聚合任务 分配 给进程或线程:将聚合好的任务分配给进程或线程,还要使通信最小化,使得每个进程或线程得到的工作量大致均衡(负载均衡)。

    3 MPI编程

    分布式内存系统

    MPI 是为 分布式内存系统 的编程而设计的,它提供发送消息的机制。本节将会介绍怎么利用 MPI 使用 消息传递 来对分布式内存系统进行编程。

    3.1 预备知识

    头文件

    #include <mpi.h>
    

    编译

    mpicc -g -Wall -o outputname.out filename.c
    

    执行

    mpiexec -n <number of processes> <executable>
    

    例如:

    mpiexec -n 4 ./mpi_hello.out
    

    运行 mpi_hello.out 文件并开启 4 个进程。

    程序框架

    //...
    #include <mpi.h>
    //...
    int main(int argc, char *argv[])
    {
        //...
        MPI_Init(&argc, &argv);
        //...
        MPI_Finalize();
        //...
        return 0;
    }
    

    通信子

    int my_rank;//进程编号
    int comm_sz;//进程数量
    MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);
    MPI_Comm_size(MPI_COMM_WORLD, &Comm_sz);
    

    其中 MPI 创建,由所有进程组成的通信子,称为 MPI_COMM_WORLD。

    SPMD 程序

    • 单程序多数据流
    • 只编译一个程序
    • 进程 0 做一些不同的事情
    • if-else 结构使程序是 SPMD

    通信

    MPI_Send(send_buf_p, send_buf_sz, send_type, dest, send_tag, send_comm);//q 号进程调用
    MPI_Recv(recv_buf_p, recv_buf_sz, recv_type, src, recv_tag, recv_comm, &status);//r 号进程调用
    

    则 q 号进程调用 MPI_Send 函数所发送的消息可以被 r 号进程调用 MPI_Recv 函数接受,如果:

    • recv_comm = send_comm
    • recv_tag = send_tag
    • dest = r
    • src = q
    MPI_Recv(result, result_sz, result_type, MPI_ANY_SOURCE, result_tag, comm, MPI_STATUS_IGNORE);
    

    当设置 src 为 MPI_ANY_SOURCE 时,该进程接收所有进程发送给他的信息。

    集合通信

    集合通信 不同于只涉及两个进程的 MPI_Send 和 MPI_Recv,它涉及到一个通信子汇总的所有进程。为了区分这两种通信方式,MPI_Send 和 MPI_Recv 常常称为 点对点通信

    4 Pthreads编程

    共享内存系统

    4.1 预备知识

    头文件

    #include <pthread.h>
    

    编译

    gcc -g -Wall -o outputname.out filename.c -lpthread 
    

    执行

    ./filename.out <number of threads>
    

    例如,运行 4 个线程的程序:

    ./filename.out 4
    

    4.2 竞争条件

    当多个线程同时执行时,多个线程执行语句的顺序通常是非确定的。当多个线程试图访问同一个共享资源时,并且其中至少有一个访问是更新操作,这样的访问可能会导致错误,导致结果的不确定性,我们称这种现象为 竞争条件。编写共享内存程序时最重要的任务之一就是识别和更正竞争条件。

    4.3 临界区

    临界区 是一个代码块,在这个代码块中,任意时刻还有一个线程能够更新共享资源,因此临界区中的代码执行应该作为串行代码执行。因此在设计程序时,应该尽可能少地使用临界区,并且使用的临界区应该尽可能短。

    有三种避免对临界区竞争访问的基本方法:忙等待、互斥量和信号量。

    4.4 忙等待

    在忙等待中,线程不停地测试某个条件,但实际上,直到某个条件满足之前,不会执行任何有用的工作。

    但是要注意编译器的优化会影响忙等待的正确执行。

    4.5 互斥锁

    互斥量 是互斥锁的简称,它是一个特殊类型的变量,通过某些特殊类型的函数,互斥量可以用来限制每次只有一个线程能进入临界区。互斥量保证了一个线程独享临界区,其他线程在有线程已经进入该临界区的情况下,不能同时进入。

    4.6 信号量

    产生原因:

    • 忙等待强制顺序线程访问临界区,造成资源浪费。

    • 使用互斥量,顺序由系统自己决定。

    • 在一些应用程序中,我们需要控制线程访问临界区的顺序。

    5 OpenMP编程

    共享内存系统

    5.1 预备知识

    预处理器指令:#pragma

    编译

    gcc -g -Wall -fopenmp -o outputname.out filename.c
    

    执行

    ./filename.out <number of processes>
    

    例如:

    ./omp_hello.out 4
    

    程序

    最基本的 parallel 指令可以以如下简单的形式表示:

    #pragma omp parallel
    

    子句

    许多 OpenMP 指令可以被 子句 修改。使用最频繁的是 num_threads 子句,当时用 OpenMP 指令启动线程组时,可以通过修改 num_threads 子句来启动需要数目的线程。

    6 并行程序开发

    7 代码附录

    梯形积分法 MPI 程序

    矩阵向量乘

    通过数学求和公式计算π

    蒙特卡洛方法计算π

    奇偶交换排序

    展开全文
  • p_tqdm使带有进度条的并行处理变得容易。 p_tqdm是和的包装器。 与Python的默认多处理库不同,pathos提供了更灵活的并行映射,该映射可以应用几乎任何类型的函数-包括lambda函数,嵌套函数和类方法-并可以轻松地...
  • 一个Python应用程序,它使用Batch与ffmpeg开源工具并行处理媒体文件。 Python 天蓝色 使用ffmpeg批处理Python文件 一个Python应用程序,该应用程序使用Batch与开源工具并行处理媒体文件。 有关详细信息和说明,请...
  • 并行处理源码及报告

    2014-01-11 22:01:10
    压缩包包括基于mpi的矩阵乘法源码,以及实验报告
  • 用于单机多核大数据结构的python并行处理的实用函数。 避免对只读大数据结构进行不必要的复制。 它包括: 1. map功能的并行版本。 它旨在以内存高效的方式在具有多个内核的单台机器上执行无限并行化的任务。 在...
  • 本篇是郑纬民《计算机系统结构》的读书笔记,欢迎各位路过指正!今天是第八章:并行处理机~

    200803本篇是郑纬民《计算机系统结构》的读书笔记,欢迎各位路过指正!今天是第八章:并行处理机。

    8. 并行处理机

    8.1 并行处理机模型

    • 三条技术途径:资源重复、时间重叠、资源共享。

    • 并行处理机:多个处理部件PU按照一定方式互连,在同一个控制部件CU控制下,对各自的数据完成同一条指令规定的操作。从CU看,指令是串行执行的,从PU看,数据是并行处理的。

    • 并行处理机的操作模型可用五元组M=(N,C,I,M,R)表示。N为PE个数。C为控制部件CU执行的指令集,包括标量指令和程序控制指令。I为所有PE并行执行的指令集。M为屏蔽操作集,将PE划分为允许操作和禁止操作两个子集。R是数据寻径集,互连网络中PE间通信所需要的各种模式。

    并行处理机

    8.2 并行处理机结构

    • 一台并行处理机由五个部分组成:多个处理单元PE,多个存储器模块M,一个控制器CU,一个互连网络ICN,一台输入输出处理机IOP。
    • 并行处理机有两种典型结构:分布存储器并行处理机,共享存储器并行处理机。
      • 分布存储器并行处理机:CU是控制部件。对于标量指令,在CU中直接执行;对于向量指令,CU把它广播到各个PE中去执行。IOP是输入输出处理机,或称为主机。分布式存储器并行处理机必须依靠并行算法来提高PE的利用率。
        在这里插入图片描述

      • 共享存储器并行处理机:共享多体并行存储器SM通过互连网络与各处理单元PE相连。存储模块的数目等于或略大于处理单元的数目。

    在这里插入图片描述

    • 并行处理机的特点:速度快、模块性好、可靠性高、效率低。

    • 并行处理机的两个发展方向:保留阵列结构,但每个处理单元的规模减小;去掉阵列结构和分布存储器。

    • 并行处理机特别依赖于并行算法。并行算法的一个关键是提高向量化的程度。 充分利用互连网络的结构。

    展开全文
  • python并行运算库 Python一直以来都以便利性和程序员... 虽然您可以使用Python内置的threading模块来加快处理速度,但threading只能提供并发性 ,而不能提供并行性 。 这对于运行不依赖于CPU的多个任务非常有好处...

    python并行运算库

    Python一直以来都以便利性和程序员友好性着称,但是它并不是周围最快的编程语言。 它的某些速度限制是由于其默认实现cPython是单线程的。 也就是说,cPython一次不会使用多个硬件线程。

    虽然您可以使用Python内置的threading模块来加快处理速度,但threading只能提供并发性 ,而不能提供并行性 。 这对于运行不依赖于CPU的多个任务非常有好处,但是对于加快每个都需要一个完整CPU的多个任务却无济于事。

    [ 也在InfoWorld上:隔离期间最好的免费数据科学课程 ]

    Python确实包含一种在多个CPU上运行Python工作负载的本地方法。 multiprocessing模块旋转Python解释器的多个副本,每个副本位于单独的内核上,并提供用于在多个内核之间拆分任务的原语。 但是有时候甚至multiprocessing还不够。

    有时,这项工作要求不仅在多个内核之间而且还要在多个计算机之间分配工作。 这就是这六个Python库和框架的所在。下面的所有六个Python工具箱都允许您采用现有的Python应用程序,并将工作分散在多个内核,多个机器或两者之间。

    射线

    由加利福尼亚大学伯克利分校的一组研究人员开发的Ray是许多分布式机器学习库的基础。 但是Ray不仅限于机器学习任务,即使那是它的原始用例。 使用Ray,可以分解任何Python任务并将其分布在整个系统中。

    Ray的语法极少,因此您无需大量修改现有应用程序即可对其进行并行化。 @ray.remote装饰器在Ray群集中的所有可用节点上分配该功能,并使用可选指定的参数来指定要使用的CPU或GPU的数量。 每个分布式函数的结果都作为Python对象返回,因此它们易于管理和存储,并且跨节点或节点内的复制量保持最小。 例如,在处理NumPy数组时,此最后一个功能非常有用。

    Ray甚至包括其自己的内置群集管理器,该管理器可以根据需要在本地硬件或流行的云计算平台上自动启动节点。

    相关视频:使用multiprocessing来加速Python

    达斯克

    从外部看, Dask看起来很像Ray。 它也是一个使用Python进行分布式并行计算的库,具有自己的任务调度系统,对Python数据框架(如NumPy)的了解以及从一台计算机扩展到多台计算机的能力。

    Dask有两种基本工作方式。 第一种是通过并行化的数据结构-本质上是Dask自己的NumPy数组,列表或Pandas DataFrames版本。 将这些构造的Dask版本交换为默认值,Dask将自动在整个集群中分散其执行。 这通常只涉及更改导入名称而已,但有时可能需要重写才能完全起作用。

    第二种方法是通过Dask的低级并行化机制(包括函数装饰器),该机制将节点之间的作业分包并同步(“立即”模式)或异步(“惰性”)返回结果。 两种模式也可以根据需要进行混合。

    Dask和Ray之间的主要区别在于调度机制。 Dask使用集中式调度程序来处理集群的所有任务。 Ray是分散式的,这意味着每台机器都运行自己的调度程序,因此,与计划任务有关的任何问题都在单台机器而不是整个群集的级别上进行处理。

    [ 同样在InfoWorld上:8个出色的Python库,用于自然语言处理 ]

    达斯克还提供了一个高级且仍处于实验阶段的功能,称为“演员”。 角色是指向另一个Dask节点上的作业的对象。 这样,需要大量本地状态的作业可以就地运行并被其他节点远程调用,因此不必复制该作业的状态。 雷缺乏像达斯克的演员模型那样的东西来支持更复杂的工作分配。

    显示

    通过Dispy ,您可以在整个计算机集群中分发整个Python程序或仅单个函数,以进行并行执行。 它使用平台本机机制进行网络通信,以使事情快速高效地进行,因此Linux,MacOS和Windows计算机均能很好地工作。

    Dispy语法在某种程度上类似于multiprocessing ,因为您显式地创建了一个集群(在multiprocessing中您将创建一个过程池),将工作提交给该集群,然后检索结果。 可能需要更多工作来修改作业以与Dispy一起使用,但是您还可以精确控制这些作业的分配和返回方式。 例如,您可以返回临时或部分完成的结果 ,在作业分配过程中传输文件 ,并在传输数据时使用SSL加密

    潘达拉尔·雷尔

    顾名思义Pandaral·lel是一种跨多个节点并行化Pandas作业的方法。 不利之处在于,Pandaral·lel 与Pandas合作。 但是,如果您使用的是Pandas,而您所需要的只是在单台计算机上跨多个内核加速Pandas作业的方法,那么Pandaral·lel将专注于这项任务。

    请注意,尽管Pandaral·lel确实可以在Windows上运行,但只能从Windows子系统(用于Linux)中启动的Python会话运行。 MacOS和Linux用户可以按原样运行Pandaral·lel。

    平行

    Ipyparallel是另一个紧密关注的多处理和任务分配系统,专门用于跨集群并行执行Jupyter笔记本代码。 已经在Jupyter中工作的项目和团队可以立即开始使用Ipyparallel。

    Ipyparallel支持许多使代码并行化的方法。 在最简单的一端,有map ,它将任何函数应用于序列,并在可用节点之间平均分配工作。 对于更复杂的工作,您可以修饰特定的功能以始终远程或并行运行。

    Jupyter笔记本电脑支持仅在笔记本电脑环境中才能执行的操作的“魔术命令”。 Ipyparallel添加了一些自己的魔术命令。 例如,您可以为任何Python语句加上%px前缀,以自动对其进行并行化。

    作业库

    Joblib有两个主要目标:并行运行作业,并且在没有任何变化的情况下不重新计算结果。 这些效率使Joblib非常适合科学计算,在这些计算中,可重复的结果是不可替代的。 Joblib的文档提供了大量有关如何使用其所有功能的示例

    用于并行化工作的Joblib语法非常简单-它相当于一个装饰器,可用于在处理器之间拆分作业或缓存结果。 并行作业可以使用线程或进程。

    [ 同样在InfoWorld上:8个正确使用Python的标志 ]

    Joblib包括用于由计算作业创建的Python对象的透明磁盘缓存。 如上所述,此缓存不仅可以帮助Joblib避免重复工作,而且还可以用于挂起和恢复长时间运行的作业,或者在发生崩溃后继续处理作业。 高速缓存还针对大型对象(如NumPy数组)进行了智能优化。 使用numpy.memmap在同一系统上的进程之间在内存中共享数据区域。

    Joblib不提供的一件事是一种在多台单独的计算机上分配作业的方法。 从理论上讲,可以使用Joblib的管道来执行此操作,但是使用另一个本地支持它的框架可能会更容易。

    进一步了解Python

    翻译自: https://www.infoworld.com/article/3542595/6-python-libraries-for-parallel-processing.html

    python并行运算库

    展开全文
  • 计算体系包括组成和硬件两个方面,随着计算机系统的发展,逐渐由单个处理器的简单计算系统发展为由多个处理器,甚至多个不同架构处理器组成的复杂计算系统。这篇文章就计算体系结构展开讨论,从计算框架特别是异构...
  • GPU 图像并行处理

    千次阅读 2018-03-23 16:58:09
    GPGPU、GPU、CUDA ...与CPU相比,GPU具有以下优势:强大的并行处理能力和高效率的数据传输能力。其中,并行性主要体现了指令级、数据级和任务级三个层次。高效率的数据传输主要体现在两个方面: G...
  • 旨在介绍数字图像处理的入门级并行算法,引导编程爱好者们在GPU或者APU上实现图像处理算法的并行程序,主要内容包括实现并行算法的主要步骤和性能的调整及优化,并以图像滤波和插值做为典型例子。
  • 并行计算与分布式处理的区别

    千次阅读 2017-06-09 15:29:42
    一、一些概念 ... 超线程技术的目的是提高物理处理器的利用效率,开销是模拟的多个逻辑处理器在工作切换时,有不少的数据保存和恢复工作,因此实际处理性能的提升要弱于多核CPU的多个物理处理器;双核CPU的两
  • 并行传输数据和串行传输数据 计算机系统中的并行处理和数据传输模式 (Parallel Processing and Data Transfer Modes in a Computer System) Instead of processing each instruction sequentially, a parallel ...
  • HEVC并行处理方法

    千次阅读 2018-08-08 11:33:17
    HEVC提供了适用于进行数据并行处理的结构单元,如片和Tile,在不同的片和Tile中,数据信息是相互独立的,这样有利于将其分配给不同的运算单元来处理;...在HEVC中,并行处理技术主要包括:基于Tile的并行和波前...
  • tensorFlow中主要包括了三种不同的并行策略,其分别是数据并行、模型并行、模型计算流水线并行,具体参考Tenssorflow白皮书,在接下来分别简单介绍三种并行策略的原理。 数据并行 一个简单的加速训练的技术是并行地...
  • 谷歌公司最先提出了分布式并行编程模型MapReduce,Hadoop MapReduce是它的 开源实现,后者比前者使用门槛低很多。 MapReduce和传统的并行计算框架的比较 传统并行计算框架 MapReduce 集群架构/容错性 共享...
  • 一、并行计算的定义 1、定义 并行计算是指同时对多个任务或多条指令... 并行计算的研究内容广泛,包括并行计算机系统结构、并行算法设计、并行编程环境等,具体表现在下面几个方面: 1、并行计算机的设计  包括并行
  • 本篇内容 用并行流并行处理数据 并行流的性能分析 分支/合并框架 使用Spliterator分割流
  •  全书共十五章,分为四篇:第一篇包括并行计算机的系统结构模型,当代对称多处理机、大规模并行处理机、机群系统和并行计算的性能评测;第二篇包括并行算法的一般设计策略、基本设计技术和一般设计过程;第三篇包括...
  • MPP(大规模并行处理)简介

    万次阅读 多人点赞 2018-06-07 15:35:56
    MPP (Massively Parallel Processing),即大规模并行处理,在数据库非共享集群中,每个节点都有独立的磁盘存储系统和内存系统,业务数据根据数据库模型和应用特点划分到各个节点上,每台数据节点通过专用网络或者...
  • 多CPU 的并行计算机技术,在很大程度上提高了系统计算速度,突破了单CPU 处理速度的极限。同时采用多个CPU 的单板计算机设计,可以减少计算机系统的体积、降低开发成本、减少系统的开发周期。本文中介绍的技术,在我...
  • 并行程序设计》

    2018-09-16 11:24:42
    除介绍常用的一些算法范例,包括分治、流水、同步计算、主从及工作池,还介绍了一些常用的经典数值和非数值算法,如排序、矩阵相乘、线性方程组求解、图像处理中的预处理和相应的变换、搜索和优化等。第2版新增了...
  • 标准组件越来越多地与最初设计用于高速图形处理的GPU(图形处理单元)和FPGA(可编程门阵列)相结合,以构建具有各种高速处理功能的并行计算机。这种强大硬件的规模仅受能耗和热控制等因素的限制。然而,除了硬件...
  • 有时,为了配合信号处理算法,甚至要求采样率在一定范围内随意设定。而且,这些应用通常要求多个通道并行采集,甚至是差分单端方式可选择的输入。针对这些要求,我们提出了一种最多可达12通道的同步并行多通道数据...
  • 并行信号处理技术-序

    千次阅读 2017-09-11 22:27:38
    下面几篇将连载并行信号处理技术,内容来自于我原来的工作,略作总结。 背景和意义 然而随着材料科学和电子对抗技术发展,雷达面临着前所未有的挑战。隐身、低空、高速、高机动目标对雷达的探测能力提出了新的要求...
  • 多通道并行采集系统包括前端模拟放大、抗混叠滤波、模数(A/D)转换、数据存储器、现场可编程门阵列(FPGA)控制和通用串行总线(USB)传输等部分,它实现了64路信号的全并行采集和数字化处理。模拟样品实验结果表明,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 314,979
精华内容 125,991
热门标签
关键字:

并行处理包括