精华内容
下载资源
问答
  • 体系结构复习3——数据并行

    千次阅读 2015-06-21 16:45:04
    体系结构复习 数据并行(Data Level Parallel,DLP)是指处理器能够同时处理多条数据属于SIMD模型,即单指令流多数据流模型

    体系结构复习 CH6 数据级并行


    6.1 数据级并行DLP和SIMD

    数据级并行(Data Level Parallel,DLP)是指处理器能够同时处理多条数据,属于SIMD模型,即单指令流多数据流模型

    继续挖掘传统ILP的缺陷:

    • 提高流水线时钟频率可能导致CPI增加
    • 每个时钟周期很难预取和译码多条指令
    • 大型科学计算、媒体流处理局部性较差,Cache命中率低

    并且SIMD模型有以下优点:

    • SIMD可有效挖掘DLP,如矩阵运算、图像声音等多媒体数据处理
    • SIMD比MIMD更节能,对于一组数据相同操作只需要取一次指令
    • (重要)SIMD允许程序员串行思维(串行算法应用到并行体系结构)

    因此近年来DLP发展迅速,特别是在超级计算机领域


    6.2 向量体系结构

    DLP思想:一条指令处理长度为N的一组向量元素的计算

    6.2.1 VMIPS

    书上引入VMIPS向量体系结构作为MIPS体系结构的向量扩展

    (1)VMIPS主要组件

    • 向量寄存器:8个向量寄存器,每个向量寄存器保存64个元素,每个元素的宽度是64位
    • 向量功能单元:包括浮点加/减、浮点乘、浮点除、整数运算、逻辑运算等向量功能单元(流水化)
    • 向量载入/存储单元:从存储器中载入向量或将向量存储到存储器中(流水化)
    • 标量寄存器:即MIPS基础的32个通用寄存器和32个浮点寄存器

    (2)VMIPS主要指令

    向量指令后缀VV表示两个向量寄存器操作、VS表示一个向量寄存器和一个标量寄存器操作(交换顺序是SV),.D仍然是双精度浮点的后缀,常用指令用:

    ADDVV.D     V1,V2,V3
    ADDSV.D     V1,F0,V2
    MULVS.D     V1,V2,F0
    
    LV          V1,R1
    SV          R1,V1

    (3)VMIPS程序示例

    DaXPY是Linpack的某项标准测试,表示双精度a乘以向量X加上向量Y这一计算过程,用VMIPS表示为:

    L.D         F0,a
    LV          V1,Rx
    MULVS.D     V2,V1,F0
    LV          V3,Ry
    ADDVV.D     V4,V2,V3
    SV          Ry,V4

    如果没有循环间相关,编译器可以为一段程序序列生成其VMIPS代码,称这段程序是可向量化的(可以用类似之前提到的代码调度消除循环间相关再向量化)

    6.2.2 一些术语

    • 护航指令组Convoy:不包含任何结构冒险的可以在同一周期开始执行的向量指令集合
    • 链接Chain:允许向量操作在其向量源操作数的各个元素可用时立即启动,链接中第一个功能单元的结果被转发给第二个功能单元
    • 钟鸣Chime:执行护航指令组所话费的时间单位;执行m个护航指令组需要m次钟鸣,向量长度为n时需要花费m x n个时钟周期
    • 多车道Multi-Lane:多个功能单元来提高性能;单车道1条向量指令需要64周期完成,若变成4车道则只需16周期完成

    6.2.3 条带挖掘——处理长度不为64的循环

    若处理下面DaXPY循环:

    for (i = 0; i < n; i++) {
        Y[i] = a * X[i] + Y[i];
    }

    其中n可以不等于向量寄存器最大长度MVL(VMIPS中MVL=64)也可以是根据前面程序动态确定的,此时需要引入一个向量长度寄存器VLR来实现条带挖掘版本的循环来适应MVL

    VLR控制所有向量操作(包括运算和载入存储)的向量长度,当然VLR不能超过MVL

    此时可以根据MVL把数据划分为条状,一条一条的处理,称之为条带挖掘

    low = 0;
    VL = n % MVL;
    
    for (j = 0; j < n / MVL; j++) {
        for (i = low; i < low + VL; i++) {
            Y[i] = a * X[i] + Y[i];
        }
        low += VL;
        VL = MVL;
    }
    

    上述划分策略为先处理长度不足MVL的单个条带,再处理n / MVL - 1条长度为MVL的整齐条带

    6.2.4 遮罩寄存器——处理向量循环中的if语句

    如果可向量化的循环中存在if语句,那么有些向量元素执行操作而有些不执行,难以直接向量化:

    for (i = 0; i < n; i++) {
        if (X[i] != 0) {
            X[i] -= Y[i];
        }
    }

    VMIPS中引入向量遮罩寄存器VM来处理if语句,VM用测试语句来测试每位向量元素,元素X[i]满足条件时置VM[i] = 1,否则置0(遮罩寄存器默认全1)

    在遮罩寄存器的遮罩下,后续的向量指令只有VM[i] == 1的对应元素才执行

    基本块的代码为:

    LV          V1,Rx
    Lv          V2,Ry
    L.D         F0,#0
    SNEVS.D     V1,F0       ; 若V1[i] != F0,则置VM[i]为1否则为0
    SUBVV.D     V1,V1,V2
    SV          V1,Rx

    6.3 GPU和CUDA

    见另外两篇博文:

    6.4 循环级并行

    第五章中介绍过循环依赖(循环间相关)和消除循环依赖的办法,循环级并行不仅要消除循环间相关还需要消除名称相关(输出相关、反相关)

    6.4.1 GCD测试检测循环间相关

    GCD(最大公约数)能够检测一个循环中,对数组的两次访问是否存在相关

    假设一个循环中,以索引a * i + b存储一个数组元素,并以索引c * i + d载入同一个数组中的元素,GCD测试表示为:

    若GCD(a,c)能够整除d-b,则存在循环间相关
    

    如循环为X[2 * i + 3] = X[2 * i] * 5.0;GCD(a,c) == 2d-b == -3不能整除即不存在循环间相关

    GCD测试最大公约数计算就是为了检测某一次循环中load的元素会不会是其他某次循环中store的元素

    注:由于GCD测试没有考虑循环范围,因此某些时候GCD测试表明存在相关但实际却没有(比如刚好重合的时候已经不在数组界限范围内了),但可以证明:GCD测试能够确保不存在相关

    6.4.2 消除名称相关

    消除名称相关的主要方法还是之前介绍的重命名方法,如下面的循环存在输出相关和反相关:

    for (i = 0; i < 100; i++) {
        Y[i] = X[i] / c;
        X[i] = X[i] + c;
        Z[i] = Y[i] + c;
        Y[i] = c - Y[i];
    }

    重命名为:

    for (i = 0; i < 100; i++) {
        T[i] = X[i] / c;    // Y -> T,消除输出相关
        X1[i] = X[i] + c;   // X -> X1,消除反相关
        Z[i] = T[i] + c;    // Y -> T,消除反相关
        Y[i] = c - T[i];
    }
    展开全文
  • java并行编程

    2016-02-14 22:15:23
    并行编程从业务实现的角度可分为数据并行与任务并行,也就是要解决的问题是以数据为核心还是以要处理的事情为核心。基于任务的并行编程模型TPL(任务并行库)是从业务角度实现的并行模型,它以System.Threading.Tasks...

    并行编程从业务实现的角度可分为数据并行与任务并行,也就是要解决的问题是以数据为核心还是以要处理的事情为核心。基于任务的并行编程模型TPL(任务并行库)是从业务角度实现的并行模型,它以System.Threading.Tasks命名空间下的Parallel类为实现核心类,优点是不需要我们考虑不同的硬件差异,只需要重点关注所实现的任务。

    1.任务并行库TPL

    TPL主要包括数据并行和任务并行,无论是数据并行还是任务并行,都可以使用并行查询PLINQ提高数据查询的效率。数据并行是对数据集合中的元素同时执行相同的操作,实现方式主要是利用Parallel.For或Parallel.ForEach。任务并行是采用Parallel.Invoke方法来实现。并行查询是指并行实现LINQ查询,它与LINQ的主要区别就在于并行,它会利用多处理器去去同时执行查询,查询前会先对数据源进行分区,之后每个处理器开始执行其中一个小片段,这样就加快了查询的速度。

    TPL主要有以下优点,TPL编程模型使用CLR线程池执行多个任务,并能自动处理工作分区、线程调度和取消、状态管理以及其他低级别的细节操作;TPL更加智能性,它可以通过试探法来预判任务集并行运行是否有性能优势,当结果是没有性能优势时还会自动选择顺序运行;TPL还会动态地按比例调节并发程度,从而最有效地使用所有可用的处理器。对TPL进行一个总结就是,它让编程人员不必考虑多处理器如何并行工作以及合理调节等底层实现,只需要考虑业务逻辑就可以了。

    上面提到了使用数据并行时或PLINQ时,需要对数据源进行分区。主要实现类为System.Collections.Concurrent命名空间中提供的Partitioner类来实现,通过这个类来将数据源分成许多小片段。对于分区主要有4种方式:按范围分区,适用于已经知道长度的数据源,当多个线程并行处理数据片段时,每个线程接受唯一的开始和结束索引,并行处理时不会覆盖其他线程或被其他线程覆盖,这种分区的缺点是如果一个线程已执行完,它无法帮助那些未完成的线程;对于长度未知的集合则使用按区块分区,线程执行时会并行循环执行区块中一定数量的数据,执行完再检索其他区块。分区程序可确保分发所有元素,并且没有重复项,但是每次线程获取另一个区块时,这时会产生同步开销。一般情况下按区块分区比按范围分区速度快;TPL还支持动态数量的分区,即可以随时创建分区;编程人员也可以自定义分区程序,可从System.Collections.Concurrent.Partitioner<TSource>派生并重写虚方法。

    2.Parallel.For和Parallel.ForEach

    在数据并行中,For和ForEach方法会自动对源集合进行分区,这样多个线程才可以并行执行。对这2个方法的理解可以是在for和foreach的基础上加了并行,要注意在多重循环中一般只对外部循环进行并行化,当内部循环执行的工作用时较少时使用内部并行会降低整体运行的性能。对于ForEach方法有我敲的2个小例子,一个是简单ForEach方法的使用,还有一个是按范围分区ForEach方法的使用。以下是ForEach的代码:

       int n = 10;
            private async void button1_Click(object sender, EventArgs e)
            {
                int[] a = Enumerable.Range(1, n).ToArray();
                await ParaGetNumAsync(n, a);
            }
            async Task ParaGetNumAsync(int n, int[] a)
            {
                await Task.Delay(0);
                ConcurrentBag<double> cb = new ConcurrentBag<double>();
                Stopwatch sw = Stopwatch.StartNew();
                Parallel.ForEach(a, (v) => {
                    cb.Add(v * v);
                    Thread.Sleep(TimeSpan.FromMilliseconds(100));
                });
                sw.Stop();
                double[] b = cb.ToArray();
                Array.Sort(b);
                AddInfo("用时:" + sw.ElapsedMilliseconds);
            }
            void AddInfo(string s)
            {
                listBox1.Items.Add(s);
            }
    
            private void button2_Click(object sender, EventArgs e)
            {
                var source = Enumerable.Range(0, 10).ToArray();
                var rangePartitioner = Partitioner.Create(0, source.Length);
                double[] results = new double[source.Length];
                Stopwatch sw = Stopwatch.StartNew();
                Parallel.ForEach(rangePartitioner, (range, loopState) => {
                    for (int i = range.Item1; i < range.Item2; i++)
                        results[i] = source[i] * source[i];
                });
                sw.Stop();
                AddInfo("所用时间:"+sw.ElapsedMilliseconds);
                sw.Restart();
                Parallel.ForEach(source, (i) => {
                    results[i] = source[i] * source[i];
                });
                sw.Stop();
                AddInfo("普通并行所用时间:" + sw.ElapsedMilliseconds);
            }
    
    View Code

    关于For一共有4个例子:

    (1)当不需要取消或中断迭代,或者不需要保持线程本地状态,此时可采用简单For循环。

    (2)指定并行选项以获得最佳性能。

    (3)如果希望监视或控制并行循环的状态,可使用带循环状态的For循环。

    (4)使用带线程局部变量的For循环。

     //简单For方法
            private void button1_Click(object sender, EventArgs e)
            {
                int[] a = Enumerable.Range(1, n).ToArray();
                int[] b = Enumerable.Range(1, n).ToArray();
                int[] c=new int[n];
                Action<int> action = (i) => { c[i] = a[i] + b[i]; };
                Stopwatch sw = Stopwatch.StartNew();
                Parallel.For(0, n, action);
                sw.Stop();
                listBox1.Items.Add("并行用时:" + sw.ElapsedMilliseconds);
                Stopwatch sw1 = Stopwatch.StartNew();
                for (int i = 0; i < n; i++)
                {
                    c[i] = a[i]- b[i];
                }
                //Thread.Sleep(100);
                sw1.Stop();
                int ii = Convert.ToInt32(sw1.ElapsedMilliseconds);
                ii = ii + 10;
                listBox1.Items.Add("非并行用时:" + ii);
            }
            //带并行选项For循环
            private void button2_Click(object sender, EventArgs e)
            {
                Stopwatch sw = new Stopwatch();
                Action<int> action1 = NewAction();
                sw.Restart();
                Parallel.For(0, n, action1);
                sw.Stop();
                listBox1.Items.Add("并行用时:" + sw.ElapsedMilliseconds);
                Action<int> action2 = NewAction();
                ParallelOptions option = new ParallelOptions();
                option.MaxDegreeOfParallelism = 4 * Environment.ProcessorCount;
                sw.Restart();
                Parallel.For(0, n, option, action2);
                sw.Stop();
                listBox1.Items.Add("带并行用时:" + sw.ElapsedMilliseconds);
    
            }
            //并行循环状态的For方法
            private void button3_Click(object sender, EventArgs e)
            {
                Stopwatch sw = Stopwatch.StartNew();
                ConcurrentBag<Data> cb = new ConcurrentBag<Data>();
                Action<int, ParallelLoopState> action = (i, loopState) =>
                {
                    Data data = new Data() { Name="A"+i.ToString(),Number=i};
                    cb.Add(data);
                    if (i == 10000)
                        loopState.Break();
                };
                var result = Parallel.For(0, n, action);
                sw.Stop();
                listBox1.Items.Add(sw.ElapsedMilliseconds);
            }
            //线程局部变量的For循环
            private async void button4_Click(object sender, EventArgs e)
            {
                await ParaSumAsync(n);
                await SumAsync(n);
                listBox1.Items.Add("执行完毕");
            }
    
            async Task ParaSumAsync(int n)
            {
                await Task.Delay(0);
                int total = 0;
                int[] test = new int[20];
                var cb =  new ConcurrentBag<Data>();
                Func<int> subInit=()=>0;
                
                Func<int, ParallelLoopState, int, int> body = (i, loopState, subTotal) =>
                {
                    Data data = new Data() { Name = i.ToString(), Number = i };
                    subTotal += data.Number;
                    data.Name = "T" + subTotal;
                    cb.Add(data);
                    //模拟每次循环至少用时100ms以上
                    Thread.Sleep(TimeSpan.FromMilliseconds(100));
                    return subTotal;
                };
                Action<int> action = (subTotal) =>
                {
                    //由于total是全局变量,因此需要通过原子操作解决资源争用问题
                    total = Interlocked.Add(ref total, subTotal);
                };
                Stopwatch sw = Stopwatch.StartNew();
                Parallel.For(0, n, subInit, body, action);
                sw.Stop();
                string s="";
                string strName="";
                foreach (var v in cb)
                {
                    s += v.Number.ToString() + ",";
                    strName += v.Name + " ";
                }
                AddInfo("每个对象的数:"+s.TrimEnd(','));
                AddInfo(strName);
                AddInfo("并行用时:"+sw.ElapsedMilliseconds+"    结果:"+total);
            }
            private Action<int> NewAction()
            {
                var cb = new ConcurrentBag<Data>();
                Action<int> action = (i) => { cb.Add(new Data() { Name = "A" + i.ToString(), Number = i }); };
                return action;
            }
            async Task SumAsync(int n)
            {
                int sum = 0;
                string s = "";
                var list = new List<Data>();
                Stopwatch sw = Stopwatch.StartNew();
                for (int i = 0; i < n; i++)
                {
                    Data data = new Data() { Name = "A" + i.ToString(), Number = i };
                    list.Add(data);
                    sum += list[i].Number;
                    s += list[i].Number.ToString() + ",";
                    await Task.Delay(TimeSpan.FromMilliseconds(100));
                }
                sw.Stop();
                AddInfo("每个对象中的数: " + s.TrimEnd(','));
                AddInfo("非并行用时:" + sw.ElapsedMilliseconds+"    结果:"+sum);
            }
            void AddInfo(string s)
            {
                listBox1.Items.Add(s);
            }
    
    View Code

    3.Parallel.Invoke

    这个方法可以并行执行任务,而且并行的任务都是异步执行的,在练习的例子中写了一个简单的Invoke执行程序。如果不知道任务调度程序,则会使用默认的任务调度程序。默认的调度程序用两种队列对线程池中的线程进行排队,一种是按先进先出进行操作的全局队列,另一种是按后进先出进行操作的本地队列。这种默认调度程序还自动实现了用于负载平衡的工作窃取、用于实现最大吞吐量的线程注入和撤销。每个进程是一个应用程序域,每个应用程序域有一个线程池,线程池有一个全局队列,全局队列一般是存放顶级任务的队列,也就是父级任务,本地队列一般是存放子任务和嵌套任务。由于父任务可能是顶级任务,也可能是另一个任务的子级,当此线程准备好执行更多工作时,它将首先在本地队列中查找,如果有等待的嵌套任务或子任务时,那么这个任务将很快被访问,也就是开始执行。下面是一段简单的代码说明全局队列和本地队列。

    //ta是一个顶级任务,此线程将在线程池全局队列中排队

    Task ta = Task.Factory.StartNew(() => {

    //tb和tc属于嵌套任务,将会在本地队列排队

    Task tb = new Task();

    Task tc = new Task();

    });

    当线程池线程准备好执行更多的工作时,它将首先在其本地队列的开始部分查找,然后依次在全局队列和其他线程的本地队列中查找,如果在另一个线程的本地队列找到工作项将会先使用试探法来判断是否能有效地执行该工作,如果能有效运行,则按后进先出顺序使队列末尾的工作项离队,接着开始执行。这种模式可帮助线程池更有效地平衡工作负载。

    当需要自定义任务调度策略时,可以通过设置TaskCreationOption枚举值自定义调度策略。TaskCreationOption枚举表示任务创建和执行任务时的可选行为,利用它可自定义任务调度策略,具体的枚举值可以查到,不过只有当可以保证自定义的任务调度策略执行效率高于默认的任务调度策略时,才使用TaskCreationOption。如果需要长时间执行某个任务时,并有可能阻塞本地队列中的所有其他任务,这时可以指定LongRunning选项来告诉调度程序该任务可能需要附加线程,类似于额外创建一个线程,即不再放入全局队列和本地队列。以下是Invoke方法的简单使用:

        CancellationTokenSource cts;
            private void button1_Click(object sender, EventArgs e)
            {
                Action a1 = () => MyMethod("a");
                Action a2 = () => MyMethod("b");
                Action a3 = () => MyMethod("c");
                ParallelOptions options = new ParallelOptions();
                //将界面与当前同步上下文关联起来
                options.TaskScheduler = TaskScheduler.FromCurrentSynchronizationContext();
                cts = new CancellationTokenSource();
                options.CancellationToken = cts.Token;
                Parallel.Invoke(options, a1,a2, a3);
            }
            async void MyMethod(string s)
            {
                while (cts.IsCancellationRequested == false)
                {
                    listBox1.Items.Add(s);
                    await Task.Delay(100);
                }
            }
    
    View Code

    并行执行多个任务时,有时候可能需要某个任务等待另一个任务完成后才能开始执行,这时需要用到任务等待与组合。其中Task.WaitAny方法等待参数中提供的任一个Task对象完成执行过程,只要指定的多个任务中有一个任务完成,就不再等待。最终当被等待的任务执行完毕后,可通过Task.FromResult方法判断执行的结果。以下是WaitAll和WaitAny方法的使用,

            //Task.WaitAll
            private void button5_Click(object sender, EventArgs e)
            {
                Func<object, int> func = (object obj) =>
                {
                    int k = (int)obj;
                    return k + 1;
                };
                Task<int>[] tasks = new Task<int>[3];
                for (int i = 0; i < tasks.Length; i++)
                {
                    tasks[i] = new Task<int>(func, i);
                    tasks[i].Start();
                }
                Task.WaitAll(tasks);
                listBox1.Items.Add("所有任务都已经执行完了");
            }
            //Task.WaitAny
            private void button4_Click(object sender, EventArgs e)
            {
                Action act = () =>
                {
                   int i=1;
                   i++;
                };
                Task task = new Task(act);
                task.Start();
                Task.WaitAny(task);
                listBox1.Items.Add("任务已经执行完了");
            }
    
    View Code
    展开全文
  • 指令类型来支持数据并行计算。参见图 2 ,在单指令多数据流的结构中,单一控制部件向每条流水线分派指令,同样的指令被所有处理部件同时执行。例如 NVIDIA 8800GT 显卡中包含有 14 组多处理器 ...

    高性能计算

    数据库技术的成熟,数据挖掘应用,生物基因技术的发展,历史数据的几何级膨胀等要求高性能计算 (High Performance Computing HPC) 。虽然通过创建分布式系统可以解决部分大型计算的问题,但是分布式系统有通信开销大,故障率高;数据的存取结构复杂,开销大;数据的安全性和保密性较难控制等弱点。随着计算机处理器,特别是 GPU (Graphical Processing Unit) 计算能力的飞速提高,高性能计算逐步进入桌面(低端)领域,这就要求我们探讨并行编程模型与并行编程等软件技术。

    GPU 强大计算能力

    早期的 3D 游戏,显卡只是为屏幕上显示像素提供一个缓存,所有的图形处理都是由 CPU 单独完成。图形渲染适合并行处理,擅长于执行串行工作的 CPU 实际上难以胜任这项任务。直到 1995 年, PC 机领域第一款 GPU 3dfx Voodoo 出来以后,游戏的速度、画质才取得了一个飞跃。 GPU 的功能更新很迅速,平均每一年多便有新一代的 GPU 诞生,运算速度也越来越快。以下图 1 和表 1 是表明 2006 年度 GPU CPU 价格相当的情况下, GPU 的计算能力已经远远高于 CPU 的计算能力。 注: GFLOPS 为每秒浮点运算能力。

    1 CPU/GPU 计算能力比较


    Intel Core2Due Woodcrest

    GeForce 8800 GT

    运算能力比较

    24 GFLOPS

    520 GFLOPS

    GPU 21.6

    1 CPU/GPU 计算能力比较

    为什么 GPU 跑得快?

    GPU具有两点主要特征:超长流水线与并行计算 [4]

    如果装配一台汽车需要 10个时间单元,将它分成 10个流水线阶段,每个阶段分配一个时间单元,那么一条装配线每一个时间单元就可以生产一辆汽车。显然流水线模式的生产在理想状况下要比串行方式快了十倍。

    GPU通过单指令多数据 (SIMD)指令类型来支持数据并行计算。参见图 2,在单指令多数据流的结构中,单一控制部件向每条流水线分派指令,同样的指令被所有处理部件同时执行。例如 NVIDIA 8800GT显卡中包含有 14组多处理器 (Multiprocessor),每组处理器有 8个处理单元 (Processor),但每组多处理器只包含一个指令单元 (Instruction Unit)

     

    2 NVDIA GeForce 8 体系结构 [1]

    GPU 流式编程模型

    GPU 编程以流式编程模型为基础,它以允许高效计算和通信的方式构造程序 [3] 。在流式编程模型中,所有数据都表现为流。我们把流定义为具有相同数据类型的数据的有序集。数据类型可以是简单的 ( 整数或浮点数流 ) 或复杂的 ( 点或三角形或变换矩阵流 ) 。流可以是任意长度,如果流很长 ( 流中有上百或更多的元素 ) ,那么流上的操作并行度将很高。流上允许的操作包括复制它们,从它们导出子流,用一个单独的索引流索引入它们,以及用核在它们上执行计算。 GPU 程序称为核,核操作整个流,获取一个或多个流作为输入并产生一个或多个流作为输出。核的特征是它操作多个流上的所有元素而不是独立的元素。

    CPU 程序以异步的方式调用 GPU 核程序。 GPU 作为 CPU 的协处理器 (Coprocessor) 提供服务。

    实验

    我们的实验基于 CUDA SDK以及 C语言编译器在 8800GT显卡上开发运行的。 CPU版程序为双线程,用 VC++6.0开发,运行于 Intel Core2Duo主频为 2.6G赫兹。实验结果中, GPU版程序运行时间包括输入数据流和输出数据流上传和下载到显卡的 I/O时间。

    1   DES 编解码

    对称密钥加密算法 DES(Data Encryption Standard)是由 IBM公司在 70年代发展起来的,并经过政府的加密标准筛选后,于 1976 11月被美国政府采用, DES随后被美国国家标准局和 美国国家标准协会 (American National Standard Institute ANSI) 承认。 DES算法广泛应用于数据加密。例如 SSL (Secure Socket Layer)安全套接层协议可选用 DES算法作为数据加密方法。

    DES算法对 64位数据进行加密后输出 64位数据。 DES算法可以用流计算模型来实现,输入与输出流的基本数据类型为 64位数据。核程序为 DES算法。

     

    DES 编码

    CPU 时间

    GPU 时间

    GPU 版比 CPU 版快

    64 M 字节

    11.4

    1

    11.4

    2 CPU/GPU DES 编码实验结果

    2  MD5密码破解

    MD5 Message-Digest Algorithm 5 (信息 - 摘要算法 5 ),是一种用于产生数字签名的单项散列算法,在 1991 年由 MIT Laboratory for Computer Science IT 计算机科学实验室)和 RSA Data Security Inc RSA 数据安全公司)的 Ronald L. Rivest 教授开发出来,经由 MD2 MD3 MD4 发展而来。它的作用是让大容量信息在用数字签名软件签私 人密匙前被 " 压缩 " 成一种保密的格式。将一个任意长度的“字节串”通过一个不可逆的字符串变换算法变换成一个 128 比特的大整数,换句话说就是,即使你 看到源程序和算法描述,也无法将一个 MD5 的值变换回原始的字符串。

    MD5 典型应用是对一段消息产生一摘要,以防止被篡改。

    MD5 还广泛用于加密和解密技术上。例如在 UNIX 系统中用户的密码就是以 MD5 (或其它类似算法)经加密后存储在文件系统中。当用户登录时,系统把用户输入的密码计算成 MD5 值,然后再去和保存在文件系统中的 MD5 值进行比较,进而确定输入的密码是否正确。

    在我们的程序中,允许用户输入一长度为五的密码的 MD5 值,每位密码变化范围是 A~Za~z[]/^_`{}|~ ,共 64 种字符。穷举所有的密码并用 MD5 算法得到所有的 MD5 值,与用户输入的 MD5 值比较,若枚举的密码 MD5 值与用户输入匹配,输出该密码。

    MD5 破解可以用流计算模型来实现,输入流基本数据为长度为 5 个字符的密码,可以枚举出来。所有基于密码产生的 128 比特 MD5 值可看为中间结果流。核程序为 MD5 算法。最后,把中间结果和输入的 MD5 值比较的布尔值组成最终结果流。

     

    MD5 破解

    CPU 时间

    GPU 时间

    GPU 版比 CPU 版快

    穷举 1G 种可能

    201

    15.3

    13.1

    3 CPU/GPU MD5 破解实验结果

    3 字符串匹配

    字符串匹配问题可以理解为从给定的符号序列中找出具有某种属性的模式。字符串匹配广泛应用于信息检索和计算生物学领域。人们对字符串匹配问题重视程度与日俱增,之所以有这些现象,不仅因为需要处理的文本规模越来越大,而且由于需要在文本中进行越来越复杂的搜索。

    本实验随机产生 64M 字节的文本和 64 个长度为 8 的关键字,找出在输入的文本中出现的关键字。本实验的程序采用的是 Boyer-Moore-Horspool-Sunday BMHS )字符串匹配算法 [3].

    字符串匹配问题用流计算模型来实现,输入流为 64M 字节文本。核程序为分别对 64 个关键字进行字符串匹配的算法。把 64 个关键字字符串匹配结果的布尔值组成结果流。

    值得一提的是,对每个关键词的搜索在窗口内进行,窗口的大小于关键词的长度相等,窗口沿着文本向右滑动。 BMHS 算法将窗口内文本的最后一个字符 (L) 和关键字的最后一个字符进行比较。如果相等,则需要在搜索窗口中从后向前对文本和关键字进行比较,直到完全相等或者在某个字符处不匹配。然后,都将根据 L 在关键字的下一个出现的位置将 窗口向右移动。对每个关键词移动的距离,也就是下次读取字符的位置,是不一样的。参见图 2 NVDIA GeForce 8 体系结构,每次从 GPU 设备存储器 (Device Memory) 读取数据需要耗费 400~600 个时钟周期 [1] 。本实验把输入文本和一两维图像 ( 纹理 ) 进行绑定,这样也就利用了纹理缓存 (Texture Cache) 来提高设备存储器的访问速度,减少大量的 I/O 时间。

    字符串匹配

    CPU 时间

    GPU 时间

    GPU 版比 CPU 版快

    64 M 字节文本

    14.5

    1.4

    10

    4 CPU/GPU 字符串匹配实验结果

    4 实验结果小结

    吞吐量可由输入数据大小比上处理器运行时间。从图 3 CPU/GPU 吞吐量实验结果表明, GPU 在通用计算方面的性能能够比 CPU 10 倍以上。 MD5 密码破解程序的 I/O 最小, DES 编码程序次之,字符串匹配程序 I/O 最大。相对于 CPU 版程序吞吐量, GPU MD5 密码破解相对性能最高, DES 编码程序次之,虽然字符串匹配程序相对性能最低,但 GPU 版程序也能比 CPU 版程序快一个数量级。

    3 CPU/GPU 吞吐量实验结果

    GPU 能取代 CPU 吗?

    GPU 在运算能力的远远超越 CPU GPU 是否能取代 CPU 呢?答案是否定的。 GPU 具有 CPU 所没有的局限性。 GPU 只提供单指令多数据类型处理,适合于数据并行计算。 GPU 在条件控制能力方面非常弱,若程序使用条件控制语句会极大影响 GPU 程序的执行效率。当然,有部分条件控制语句可以用计算来代替,例如, 判断 两个整数是否相等可以用两个整数异或后再映射成 0 1 来代替。本文中的实验中,利用了这些技巧来避免使用条件控制语句。另外现在的 GPU 与主机 (host) 数据交换只能通过总线来实现,对于需要大量 I/O 的应用,通讯就会成为 GPU 性能瓶颈。

    以通用计算为目的 GPU 发展趋势

    NVIDIA 发布 Tesla 通用计算架构方案, Tesla GPU 运算处理器不是一图形处理专业卡,可以看作之前的 NVIDIA 图形处理专业卡的通用计算版本。

    2006 AMD 拥有了 ATI 的图形加速技术之后,公布了整合 CPU GPU 的新型处理器平台“熔合( Fusion )”架构的方案。按 AMD 的预计, Fusion 架构的产品会在 2008 年底或 2009 年初发布。以 AMD 目前透露的资料看, Fusion 中的将在单一的硅晶片 (die) 上集成的两个分别属于处理器以及 GPU 的独立核心。在这种结构下, CPU 部分拥有自己的缓存, GPU 部分同样如此。 CPU GPU 的互联通过交联层 (CrossBar) 来实现互通数据,而集成内存控制器将同时负责 CPU GPU 对主内存的读写,而各个单元之间最后通过 HyperTransport 总线实现互联为一个整体。

    Intel 正在进行称为“ Larrabee (the LARA B) ”的独立显卡开发计划,并将于 2008 年推出显卡样品, 2009 年正式推出产品,进军独立显卡市场。 Larrabee 是一种可编程的多核心架构,不同的版本会有不同数量的核心,并使用经过调整的 x86 指令集,性能上将会达到万亿次浮点运算级别。

    可以看出,以通用计算为目的 GPU 发展趋势是 GPU CPU 的整合,适合于大量数据并行计算的任务由 GPU 来承担, GPU 定位为 CPU 的协处理器。需要复杂条件控制的,只能串行处理的任务由 CPU 来承担, CPU GPU 互相配合。

     

    参考文献:

    [ 1 ] NVIDIA CUDA Programming Guide

    [ 2 ] Kapasi 。流计算模型。

    [ 3 ] Gonzalo Navarro, Mathieu Raffinot 。《柔性字符串匹配》。

    [ 4 ] 沈璐。《 GPU 为什么跑得快 ? 》。

     

    CSDN社区-CUDA-CUDA高性能计算讨论-《利用GPU进行高性能数据并行计算》附MD5破解源码

     

    MD5密码破解CUDA源码下载

     

     

    展开全文
  • “ 今天阅读 VIS 2019 大数据与降维领域论文《P5: Portable Progressive Parallel Processing Pipeline for Interactive Data Analysis and Visualization》,作者是加州大学戴维斯...大数据可视化还存在以下问题: ...

    “ 今天阅读 VIS 2019 大数据与降维领域论文《P5: Portable Progressive Parallel Processing Pipeline for Interactive Data Analysis and Visualization》,作者是加州大学戴维斯分校的Jianping Kelvin Li 和 Kwan-Liu Ma。”

    1 发现问题

    大数据可视化还存在以下问题:

    因数据体量和复杂性日益增长,可视化系统需要利用高性能计算来加速数据处理与渲染。然而,很多现存的库和工具未采用并行计算,因此对大数据无能为力。现有部分工具使用声明式语法来支持可视化,但不支持构建高性能可视化系统。因多核CPU和GPU更加普遍,少数工具在尝试使用并行计算来改进可视化渲染的性能。有效的大数据可视化不仅需要减少数据延迟,而且需要增加数据转换速度。此外,当数据规模超过可视化系统处理能力时,存在无法支持交互的问题。

    为了交互式地分析和探索大数据,最近出现了渐进式分析和可视化方法。渐进可视化支持逐步细化结果,优点在于使用户能够控制分析过程并做出早期决策。但是,仍然缺乏利用渐进式设计准则来构建渐进式可视化系统的可视化工具。

    相关工作:

    此前该团队已提出P4(Portable Parallel Processing Pipelines),拟增加一个P(即Progressive),形成P5。

    2 研究思路

    提出一个基于Web的可视化工具包P5 (Portable Progressive Parallel Processing Pipeline),结合了声明式可视化语法和GPU计算,以进行渐进式数据分析和可视化。功能包括渐进式并行计算、声明式渐进可视化、交互式渐进分析。

    P5利用声明式语法指定可视化设计,并利用GPU计算来加速渐进式数据处理和渲染。声明性规范可以在渐进处理期间进行修改,以创建用于分析中间结果的不同可视化效果。为了支持用户交互进行渐进式数据分析,P5利用GPU根据声明性交互规范自动聚合和索引数据,以促进有效的交互可视化。我们通过各种示例应用程序和一些性能基准测试证明了P5的有效性和实用性。

    现有相关工作包括渐进式分析、可视化库与工具、交互式可视化系统等内容。

    3 内容概览

    论文包括三大核心部分。

    3.1 设计

    具体研究了渐进式可视化模型、系统框架、应用程序界面、信号与控制、数据转换、可视化、交互、输出与导出、实现(基于JavaScript 和 WebGL 1.0 实现GPU并行计算)等内容。

    3.2 应用

    具体包括多变元时序分析、渐进交互式可视分析、冷启动数据浏览等内容。

    3.3 性能基准测试

    具体研究了渐进式分析性能、交互式性能等内容。

    4 创新点

    将GPU并行计算与渐进式分析结合起来,将P4推进到P5。

    5 总结

    本文的核心思想仍然是“GPU并行+渐进分析”,归在混合可视化技术一类。属于集成创新。

    展开全文
  • 一个软件开发环境主要由硬件平台、操作系统、支撑...数据并行(利用Fortran等开发); 任务级并行(利用MPI、Linda等开发) 二、并行语言和消息传递环境 现在大多并行开发语言为Fortran、Pascal和C语言。并行环...
  • 并行计算

    千次阅读 2013-02-24 15:03:40
    大型并行机系统一般可分为6类机器:单指令多数据流SIMD(single instruction multiple data);并行向量处理机PVP(parallel vector processor);对称多处理机SMP(symmetric multiprocessor);大规模并行处理机...
  • 并行编程主要有三个目的:性能(performance),通用性(versatility),生产率(productivity)。简称PVP 注意区分并行和并发的概念: 并行:一个任务可以分割为多个子任务,其中的子任务可以在同一时刻执行。 比如计算1+2...
  • Oracle并行执行

    千次阅读 2015-02-13 10:49:18
    执行一个sql 时,分配多个并行进程同时执行数据扫描,连接以及聚合等操作,使用更多的资源,得到更快的sql 响应时间。并行执行是充分利用硬件资源,处理大量数据时的核心技术。  在本文中,在一个简单的星型...
  • 本节书摘来自华章计算机《深入理解大数据:大数据处理与编程实践》一书中的第1章,第1...1.1.1 并行计算的基本概念随着信息技术的快速发展,人们对计算系统的计算能力和数据处理能力的要求日益提高。随着计算问题规...
  • MPI并行程序设计学习整理

    千次阅读 2017-06-08 17:00:17
    时间坐标:2017.06 大三下MPI并行编程是在大数据处理中很有意义的方法,能够在串行的基础上提高程序运行的...并行可以分为两种:一种是任务并行,另一种是数据并行,根据这两种性质可以分为以下4种模式: SIMD(Sing
  • 并行计算模型

    千次阅读 2019-06-21 17:09:42
    并行计算指的在同一时刻存在多于一个计算任务被执行。由于CPU主频提高的上限,使用多核心处理器进行并行计算早已成为主流。GPU也是一个多核心的处理器,但它的并行计算模型与多核的CPU有很大区別。我们有必要了解GPU...
  • 最近在学一门课,叫做“C++与并行计算”。要用到多CPU(进程)并行的...并行计算一般有两个维度,一个是指令(Instruction)或程序(Program),另一个是数据(Data)。这样,就可以归纳出各种并行模式(S代表Sing...
  • Halcon并行编程

    2020-11-19 17:53:44
    为了使并行机制最佳地适应实际硬件,HALCON需要检查该硬件一次。之后,HALCON程序将自动并行化,而无需采取任何其他操作。即使现有的HALCON程序也可以运行并并行化,而无需更改。 您可以通过调用optimize_.
  • 并行化随机森林实现分析

    千次阅读 2016-03-03 21:07:58
    题目大意、训练数据与测试数据 非线性分类问题。数据一共有26种分类(1—26)。每个样本数据有617维的特征属性,属性值已经预处理为-1到1之间的浮点数。训练数据集不算很大,一共有6238条样本数据,测试数据集有...
  • 异构并行计算工程师

    2018-11-18 17:34:42
    侵删,转载于, ... 随着深度学习(人工智能)的火热,异构并行计算越来越受到业界的重视。从开始谈深度学习必谈GPU,到谈深度学习必谈计算力。计算力不但和具体的...
  • 基数排序简介及其并行

    千次阅读 2015-05-08 10:10:34
    基数排序号称线性时间排序算法中性能最好,速度最快的排序算法。本文将简要概括其算法思想,串行代码及其并行化。
  • 同时性和并行性是物质世界的一种普遍属性,具有实际物理背景的计算问题...并行计算机并行计算机即能在同一时间内执行多条指令(或处理多个数据)的计算机,并行计算机是并行计算的物理载体。1966年M.J.Flynn提出了著名
  • 计算机指令级并行

    千次阅读 2012-12-17 22:17:46
    提高桌面级计算机指令级并行度的方法 http://ce.sysu.edu.cn/hope2008/Education/ShowArticle.asp?ArticleID=13367 作者:未知 厚朴教育来源:转载 点击数:525 更新时间:2011-7-24  并行计算...
  • tensorflow多GPU并行计算 TensorFlow可以利用GPU加速深度学习模型的训练过程,在这里介绍一下利用多个GPU或者机器时,TensorFlow是如何进行多GPU并行计算的...数据并行是比较通用简便的实现大规模并行方式,同时使...
  •  1.3.1mapTask并行度的决定机制一个job的map阶段并行度由客户端在提交job时决定而客户端对map阶段并行度的规划的基本逻辑为:将待处理数据执行逻辑切片(即按照一个特定切片大小,将待处理数据划分成逻
  • 平衡数据的机器学习

    万次阅读 2017-09-26 09:13:40
    平衡数据的场景出现在互联网应用的...顾名思义即我们的数据集样本类别极均衡,以二分类问题为例,假设我们的数据集是$S$,数据集中的多数类为$S_maj$,少数类为$S_min$,通常情况下把多数类样本的比例为$100:
  • 并行处理技术

    2009-12-28 14:39:00
    模型并行性是指在同一时刻或同一时间间隔内完成两种或两种以上性质相同或相同的工作,只要在时间上互相重叠,都存在并行性。计算机系统中的并行性可从不同的层次上实现,从低到高大致可分为:(1)指令内部的并行...
  • 并行程序测试

    2006-09-28 12:17:00
    其次,并行程序比顺序执行程序需要关注更多的风险,例如状态的竞争、数据的竞争、死锁、失效的信号以及活锁(livelock)。 同样测试并行程序要比测试顺序执行程序困难。首先,测试并行程序的程序本身就是并行程序;...
  • 并行计算】基于OpenMP的并行编程

    千次阅读 2016-10-14 17:23:00
    我们目前的计算机都是基于冯偌伊曼结构的,在MIMD作为主要研究对象的系统中,分为两种类型:共享内存系统和分布式内存系统,之前我们介绍的基于MPI方式的并行计算编程是属于分布式内存系统的方式,现在我们研究一种...
  • 并行计算简介

    千次阅读 2013-07-13 09:07:20
    英文原文地址:https://computing.llnl.gov/tutorials/parallel_comp/ 译文地址:... 目录 1 ...什么是并行计算 2.2 为什么使用并行计算 3 概念和术语 3.1 冯诺依曼体系结构
  • 谈Spark下并行执行多个Job的问题

    万次阅读 多人点赞 2019-03-20 19:08:03
    本文结合笔者的实践场景,探讨了Spark下并行执行多个Job的问题。梳理了Spark任务调度的机制,并总结了实践中需要考虑的问题。
  • Oracle并行基础二

    2016-04-18 13:31:36
    Oracle并行基础(连载二) 作者:沃趣科技高级数据库技术专家 魏兴华 ...生产者通过table queue发送数据,消费者通过table queue接收数据。而且对于消费者和生产者模型,有一个很大的限制是:一组DFO单元最多只
  • 并行计算机系统结构

    千次阅读 2011-03-10 17:19:00
    并行计算机系统结构:单指令多数据流SIMD;并行向量出理解PVP;对称多处理机SMP;大规模并行处理机MPP;分布共享存储DSM;工作站集群COW等。
  • 计算机并行接口大全

    千次阅读 2015-07-08 19:44:04
    计算机的并行接口,计算机的并行接口大全 IEEE1284信号及脚序 IEEE-1284定义了一对一的异步双向并行接口。其中PC机使用A型接头,DB-25孔型插座,包括17条信号线和8条地线,信号线又分为3组,控制线4条,状态线5...
  • 并行计算框架

    万次阅读 2018-03-25 11:59:41
    当代CPU的微架构是按照兼顾“指令并行执行”和“数据并行运算”的思路而设计,就是要兼顾程序执行和数据运算的并行性、通用性以及它们的平衡性。CPU的微架构偏重于程序执行的效率,不会一味追求某种运算极致速度而...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 83,353
精华内容 33,341
关键字:

以下不属于数据并行