精华内容
下载资源
问答
  • 我们实验室有两台联想ThinkServer RD630 S2609 4/1THROD服务器老师想用其做并行运算做数据处理,作为电脑小白啥都不同有没有大佬给解答下疑惑啊!本人qq9355515795. ...

    我们实验室有两台联想ThinkServer   RD630 S2609 4/1THROD服务器老师想用其做并行运算做数据处理,作为电脑小白啥都不同有没有大佬给解答下疑惑啊!本人qq9355515795.

     

     

    展开全文
  • Matlab并行运算

    千次阅读 2014-06-06 17:14:31
    今天为了在8核的dell服务器上跑程序才专门看了一下。本身写的程序就很容易实现并行化,因为beamline之间并没有考虑相互作用。等于可以拆成n个线程并行,要是有550核的话,估计1ms就算完了。。。 先转下网上找到的...

    今天搞了一下matlab的并行计算,效果好的出乎我的意料。

    本来CPU就是双核,不过以前一直注重算法,没注意并行计算的问题。今天为了在8核的dell服务器上跑程序才专门看了一下。本身写的程序就很容易实现并行化,因为beamline之间并没有考虑相互作用。等于可以拆成n个线程并行,要是有550核的话,估计1ms就算完了。。。

    先转下网上找到的资料。

    一、Matlab并行计算原理梗概

    Matlab的并行计算实质还是主从结构的分布式计算。当你初始化Matlab并行计算环境时,你最初的Matlab进程自动成为主节点,同时初始化多个(具体个数手动设定,详见下文)Matlab计算子节点。Parfor的作用就是让这些子节点同时运行Parfor语句段中的代码。Parfor运行之初,主节点会将Parfor循环程序之外变量传递给计算子节点。子节点运算过程时互不干扰,运算完毕,则应该有相应代码将各子节点得到的结果组合到同一个数组变量中,并返回到Matlab主节点。当然,最终计算完毕应该手动关闭计算子节点。

    二十六、初始化Matlab并行计算环境

    这里讲述的方法仅针对多核机器做并行计算的情况。设机器的CPU核心数量是CoreNum双核机器的CoreNum2,依次类推。CoreNum以不等于核心数量,但是如果CoreNum于核心数量则核心利用率没有最大化,如果CoreNum于核心数量则效率反而可能下降。因此单核机器就不要折腾并行计算了,否则速度还更慢。下面一段代码初始化Matlab并行计算环境:

    %Initialize Matlab Parallel Computing Enviornment by Xaero | Macro2.cn

    CoreNum=2; %设定机器CPU核心数量,我的机器是双核,所以CoreNum=2

    if matlabpool('size')<=0 %判断并行计算环境是否已然启动

    matlabpool('open','local',CoreNum); %若尚未启动,则启动并行环境

    else

    disp('Already initialized'); %说明并行环境已经启动。

    end

     

    运行成功后会出现如下语句:

    Starting matlabpool using the 'local' configuration ... connected to 2 labs.

    如果运行出错,按照下面的办法检测:

    首先运行:

    matlabpool size

     

    如果出错,说明你没有安装Matlab并行工具箱。确认安装了此工具箱后,运行:

    matlabpool open local 2;

    如果出错,证明你的机器在开启并行计算时设置有问题。请联系MathWorks的售后服务。

     

    二十七、终止Matlab并行计算环境

    用上述语句启动Matlab并行计算环境的话,在你的内存里面有CoreNumMatlab进程存在,每个占用内存都在百兆以上。(可以用Windows任务管理器查看),故完成运行计算后可以将其关闭。关闭的命令很简单:

    matlabpool close

    二十八、MatlabMonte Carlo并行的算法

    Matlab并行计算比较特别。下图节选自Matlab并行计算工具箱用户手册。这个列表告诉你Matlab如何处理Parfor并行计算程序段中的各种变量。所以写代码时要注意不少问题,否则写出的并行代码可能还不如非并行的代码快。

    MATLAB并行计算 - CD_Keanu - 智慧人生

     

    这里我推荐大家用MatlabMonte Carlo并行代码时按照以下注意事项来写:

    1.将Monte Carlo模拟过程中不会改变的参数都写在Parfor循环块外面

    2.生成随机数、计算f(x)等过程都写在Parfor里面

    3.不要将V0结果传递出Parfor,而是直接计算出V0的均值、方差传递出parfor

    4.最后用数学公式将传递出ParforV0的均值方差组合计算成最终结果

    这些事项如何体现到程序中请参照示例代码文件并结合视频教程学习。这样的并行办法简单易行,对原始程序没有太大的改动,同时传递变量耗费时间也较少,效率比较高。

    另外一个问题就是并行代码做模拟的次数问题。我们要达到用非并行的代码做N此模拟所能得到结果的精确程度,在核心为CoreNum并行代码中,Parfor语句段中只要做N/CoreNum次即可达到。

    二十九、将例子改写为并行代码

    附件中的pareg1.m,……,pareg5.m五个文件分别是前一章五个例子的并行代码。这里需要提到的是,这五个代码文件都是用向量化的代码编写。原因在于,在前一章大家都看到了,向量化的代码比循环语句代码一般快几十甚至上千倍,所以要提高速度,向量化代码是最重要的优化方法,并行计算倒是其次。

     

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    由于要搜索多核运行,找到这个帖子里来了

    刚才试了一下,我使用的MATLAB2010可以多核运行的。需要多核多线程跑的算法,在之前要让matlab在本地建立4个“实验室”(我的机器是4核,所以是4个)
    >> matlabpool local 4
    Starting matlabpool using the 'local' configuration ... connected to 4 labs.
    显示正在进行多核配置,一会说,连接到4个“实验室”。我理解就是在本地虚拟出4台可以运行matlab的工作站,这样用分布式计算工具箱可以进行并行计算(matlabpool这个命令好像是在并行计算工具箱里的)。观察windows任务管理器,可以发现一共有5个MATLAB.exe进程。其中一个占内存较多的,我理解是主控的,他基本不干活,只负责分配,进行计算时他的cpu占用率只有1~2%,剩下四个进程专门用来计算的,跑起来各占cpu 25%左右。看上去还是每个matlab进程单核运算,但是一下开4个进程,所以能把cpu用满。
    如果后续还需要多核运算,就直接用parfor好了,不用每次都用matlabpool命令。那个配置一次就好。
    算完了,不再跑了,临退出时关闭配置就行。
    >> matlabpool close
    Sending a stop signal to all the labs ... stopped.

    下面是我一个M文件的程序,测测4核并行计算和单核计算的差距,很简单。
    function testtime

    runtimes = 1e9;
    dummy1   = 0;
    dummy2   = 0;

    %matlabpool local 4

    tic
    %for x= 1:runtimes;
    parfor x= 1:runtimes;
        dummy1 = dummy1 + x;
        dummy2 = 2 * x + 1;
    end
    toc

    plot([1 2], [dummy1, dummy2]);

    第一次用普通for语句,单核跑,6.09秒
    >> testtime
    Elapsed time is 6.094267 seconds.

    第二次用parfor语句,4核跑,1.63秒
    >> matlabpool local 4
    Starting matlabpool using the 'local' configuration ... connected to 4 labs.
    >> testtime
    Elapsed time is 1.631350 seconds.
    >> matlabpool close

    加速比 6.09 / 1.63 = 3.736,将近4倍(还有开销吧),还比较可观。
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     
    然后说一下要注意的几个问题:
    1、parfor效果好,但是用起来要注意程序的细节。很多地方都会报错。比如下标必须为连续的整数!否则会报下面这个错误“The variable xxx in a parfor cannot be classified.”具体可以看parfor帮助文件里面的sliced variables这一节,帮助建议仔细全部看过最好。
    2、用了parfor之后,输出参数用nargout确定,会出错。不知道为什么。
    3、变量在parfor内外的传进传出要非常小心,因为并行的关系,依赖循环下标的变量都要仔细考虑。
     
    在我的程序里面,用profile监测,
    不用并行计算的时候,CPU时间为 84.742 S,
    用了并行计算的时候,CPU时间为 15.231 S
    加速比达到了5.6!!!!!!
     









    Parallel Computing Toolbox是一个matlab2011开始提供的组件,用于提供交互式的并行计算功能


    一、运用的场合

    很多应用程序中包含多个重复的代码部分,这些代码可能有多次循环迭代,也可能只有少量的循环迭代,但他们只是重复次数与输入参数的区别,对于处理这样的数据,并行计算是一个理想的方法,并行循环的唯一限制是每个循环间没有相互的依赖关系

    当然,对于相互依赖的程序代码,也有可以实现并行计算的技巧


    对于MATLAB,你可以选择运行一个庞大的批处理程序,也可以选择将他们拆分成多个任务由多个远程的计算机并行地执行,那将会极大的增加运行效率


    同时,如果要处理的数据过于庞大,并行计算的性能也将明显优于异步的计算与处理


    二、并行计算方案简介


    • 交互运行一个循环程序

    在这个例子中,我们只是要学习怎么将一个简单的for循环程序变成一个并行执行的程序,for循环中处理的数据量以及for循环的迭代次数都是很小的,因此,很难在这个例子中体现出并行计算的效率优势


    1、假设你的代码中包含下面一个显示正弦波形的for循环:

              for  i=1:1024

                   A(i)  =  sin(i*2*pi/1024);

             end

             plot(A)


    2、为了能够使用matlab提供的交互式工具,你需要首先打开matlabpool,这个组件可以运行在你的本地计算机上,也可以运行在多个远程计算机上

             matlabpool  open  local  3


    3、在matlabpool上,通过使用parfor关键字,你可以将你的代码修改为并行运行的程序:

            parfor  i=1:1024

                    A(i)  =  sin(i*2*pi/1024);

            end

            plot(A)


    4、当程序运行结束,我们要使用下面一条指令关闭matlabpool,并且释放被占用的处理器或


    两段代码唯一的区别是将关键字由for变为了parfor,而两段代码的执行结果也是极其相似的

    但是,因为这个程序中,每次循环迭代都只是参数不同,之间并没有依赖关系,因此,每次迭代并不一定运行于同一个处理器上,通过parfor关键字声明,每一个迭代可能在多个处理器或多个计算机上并行执行,但并没有任何保证执行顺序的技术,因此,A(900)可能在A(400)之前运行


    • 运行一个批处理作业(batch job)

    首先,先介绍一下matlab中的批处理作业的概念,使用批处理命令可以让matlab分担某个任务一段时间,下面是一个for循环的例子


    1、首先使用下面的命令创建一个脚本

            edit  mywave


    2、在 MATLAB Editor 中键入下面的代码,完成for循环显示函数

            for  i=1:1024

                    A(i)  =  sin(i*2*pi/1024);

            end


    3、保存并关闭 MATLAB Editor


    4、在Matlab命令窗口中输入批处理命令来让脚本在单独的Matlab工作间中执行

            job  =  batch('mywave')


    5、batch命令不会阻塞matlab,所以你必须等待工作的完成然后去查看他的结果

            wait(job)


    6、使用load命令可以把工作间中的变量传输到客户端前

            load(job,  'A')

            plot(A)


    7、工作完成后,要记得调用下面的命令清除数据

            destroy(job)


    上面的代码将matlab的工作间与客户端之间相分开,很大的提高了效率



    • 运行一个交互的批处理作业(batch job)

    下面的例子将上面的两个例子结合在一起,完成parfor的batch job


    1、在MATLAB Editor中编辑你的脚本

            edit  mywave


    2、如下修改你的脚本

            parfor  i=1:1024

                    A(i)  =  sin(i*2*pi/1024);

            end


    3、保存并退出MATLAB Editor


    4、和前面一样,我们运行这个脚本,但是这一次我们要使用一个MATLAB pool 来运行这个脚本

            job  =  batch('mywave',  'matlabpool',  3)


    5、和之前一样,我们要去查看结果需要执行下面的代码

            wait(job)

            load(job,  'A')

            plot(A)


    6、工作完成后,要记得调用下面的命令清除数据

            destroy(job)


    上面的这段代码将一个批处理工作分给了三个不同的工作间来协作完成













       相信很多朋友在利用matlab进行计算时,会遇到循环次数过大,或者是单次计算量过大的问题,比如需要计算的数值阵列数据量过大,利用传统的编程方式,跑一次程序几个小时,都要等的急死了是不是呢?如果遇到这种情况,则可以尝试一下MATLAB并行计算,传统的计算方式都是串行计算。并行计算之所以可行,取决于两方面因素:a)现在大家的计算机是多核的,至少也是双核了吧,有的可能8核都有,这是很重要的硬件基础。b)MATLAB本身提供了很好的并行计算函数,加上你的聪明智慧,设计合理的软件,这样就有了软件基础了。

    1. 并行计算的优势是什么?

      以自己的经验来看,MATLAB并行计算真是很厉害的,通过对原始程序很简单的改动,就能节省很多时间。我给出一个很简单的例子,说明并行计算的优势所在。例如一个遗传算法的MATLAB程序,通常的计算运行方式需要2个小时得到结果,那如果用一台双核的机器并行计算呢?理论上1个小时就可以跑完。那如果是用一台8核的计算机,就只是一刻钟(15分钟)了。而且并行计算可以配合分布式计算服务,同时调动若干台计算机同时工作,把刚才的程序计算时间缩短到分分钟绝对不是难事啊。

    2. 如何启动MATLAB并行计算?

      以单台双核计算机为例。首先打开MATLAB命令窗口,输入matlabpool open就OK了。如图所示:

      这样,就相当于将一台计算机的两个核心,当做两台机器用啦。接下来是编程序实现的方法。

    3. MATLAB并行计算的模式有几种?

      主要是两种:parfor模式和spmd模式。两种模式的应用都很简单。第一个中,parfor其实就是parallel+for简化而来,顾名思义啊,就是把原来程序中的for循环中的关键字forg改为parfor就OK啦。不过这是很初步的介绍,限于篇幅不能详细展开了,详细的可以用输入命令help parfor查看,如图:

    4. 同样地,可以适用于spmd模式。

    5. 程序举例:例如很简单的一个程序:

      tic

      %传统方式计算

      c1=1;

      for i = 1:500

         c1 = c1+max(eig(rand(i,i)));

      end

      t1 = toc;

      matlabpool open;

      %parfor并行方式计算

      tic

      c2=1;

      parfor ii = 1:500

        c2 = c2+max(eig(rand(ii,ii)));

      end

      t2 = toc;

      matlabpool close;

      display(strcat('parfor并行计算时间:',num2str(t2),'秒'));

      display(strcat('客户端串行计算时间:',num2str(t1),'秒'));

      分别用传统方式算和parfor算,时间区别如下图所示:

      这只是用双核计算的效果,如果是4核心8核心,效果要好的多啦,需要用MATLAB的童鞋不妨试试看咯。

    6. 关闭并行计算模式。

      不想用了?送一个命令进去就关了,估计你已经猜到那即是:matlabpool close.如图所示:

      早日学会哦!







    Matlab并行运算

    目前,新购置的电脑大部分都是多核的了,使用Matlab进行大量计算时如何有效利用多核呢?Matlab目前版本已经比较好的支持多核并行运算了。是用的Matlab版本是R2007b。电脑是双核的。


    先简单试试:

    >> matlabpool local 2
    Submitted parallel job to the scheduler, waiting for it to start.
    Connected to a matlabpool session with 2 labs.

    显示正在进行多核配置,然后,提示连接到2个“实验室”(labs)。我这也理解的:本地虚拟出2台可以运行matlab的工作站,这样用分布式计算工具箱可以进行并行计算(matlabpool这个命令好像是在并行计算工具箱里的)。

    >> testParallel
    Elapsed time is 7.750534 seconds.

    这里运行testParallel函数,已经开辟了2个labs,为了进行多核并行运算,testParallel中,要用parfor代替原来的for循环。

    在运行这个时,观察windows任务管理器,可以发现一共有3个MATLAB.exe进程。其中一个占内存较多的,应该是主控的,他基本不干活,只负责分配,进行计算时他的cpu占用率只有1~2%,剩下两个进程专门用来计算的,跑起来各占cpu 49%左右。看上去还是每个matlab进程单核运算,但是一下开2个进程,所以能把cpu用满。当运行完testParallel后,三个进程的cpu都立刻降为1%左右了。

    >> matlabpool close
    Sending a stop signal to all the labs...
    Waiting for parallel job to finish...
    Performing parallel job cleanup...
    Done.

    当要关闭开辟的2个labs时,使用matlabpool close关闭即可。


    代码及使用时间对比如下表:

     

    function testParallel

    %非并行

    % matlabpool local 2

    tic
    total=10^5;
    for (i=1:total)
        ss(i)=inSum;
    end
    plot(ss);
    toc

    % matlabpool close

    function [s]=inSum
    x=abs(round(normrnd(50,40,1,1000)));
    s=sum(x);

     

    function testParallel

    %并行

    matlabpool local 2

    tic
    total=10^5;
    parfor (i=1:total) 
        ss(i)=inSum;
    end
    plot(ss);
    toc

    matlabpool close

    function [s]=inSum
    x=abs(round(normrnd(50,40,1,1000)));
    s=sum(x);

    Elapsed time is 70.471469 seconds.Elapsed time is 7.750534 seconds.

       70.471469/7.750534 = 9.0925,并行与否的时间比竟然是9倍,足以表明,在Matlab中使用多核并行运算给我们带来很多好处。

    转载请注明出处http://hi.baidu.com/webas/item/438ed30e364e28cf905718d8


    先简单试试:

    >> matlabpool local 2
    Submitted parallel job to the scheduler, waiting for it to start.
    Connected to a matlabpool session with 2 labs.

    显示正在进行多核配置,然后,提示连接到2个“实验室”(labs)。我这也理解的:本地虚拟出2台可以运行matlab的工作站,这样用分布式计算工具箱可以进行并行计算(matlabpool这个命令好像是在并行计算工具箱里的)。

    >> testParallel
    Elapsed time is 7.750534 seconds.

    这里运行testParallel函数,已经开辟了2个labs,为了进行多核并行运算,testParallel中,要用parfor代替原来的for循环。

    在运行这个时,观察windows任务管理器,可以发现一共有3个MATLAB.exe进程。其中一个占内存较多的,应该是主控的,他基本不干活,只负责分配,进行计算时他的cpu占用率只有1~2%,剩下两个进程专门用来计算的,跑起来各占cpu 49%左右。看上去还是每个matlab进程单核运算,但是一下开2个进程,所以能把cpu用满。当运行完testParallel后,三个进程的cpu都立刻降为1%左右了。

    >> matlabpool close
    Sending a stop signal to all the labs...
    Waiting for parallel job to finish...
    Performing parallel job cleanup...
    Done.

    当要关闭开辟的2个labs时,使用matlabpool close关闭即可。

     


    代码及使用时间对比如下表:

     

     

    function testParallel

    %非并行

    % matlabpool local 2

    tic
    total=10^5;
    for (i=1:total)
        ss(i)=inSum;
    end
    plot(ss);
    toc

    % matlabpool close

    function [s]=inSum
    x=abs(round(normrnd(50,40,1,1000)));
    s=sum(x);

     

    function testParallel

    %并行

    matlabpool local 2

    tic
    total=10^5;
    parfor (i=1:total) 
        ss(i)=inSum;
    end
    plot(ss);
    toc

    matlabpool close

    function [s]=inSum
    x=abs(round(normrnd(50,40,1,1000)));
    s=sum(x);

    Elapsed time is 70.471469 seconds. Elapsed time is 7.750534 seconds.

     

       70.471469/7.750534 = 9.0925,并行与否的时间比竟然是9倍,足以表明,在Matlab中使用多核并行运算给我们带来很多好处。


    首先,LZ要搞清楚自己的电脑是几个核的。如果不是多核的,那就没有办法进行多核运算了。现在大多数电脑是双核的,也有一些高级一些的是四核。

    如果是双核的,进行多核运算前,写上代码:
    matlabpool local 2;
    四核的话写上代码:
    matlabpool local 4;
    依此类推。

    多核运算完以后,要记得关闭多核运算。写上代码:
    matlabpool close;

    要记住使用matlabpool和parfor缺一不可。开启了matlabpool,还是用for做循环的话,是无法回快速度的。

    我没有让你把所有的for循环都改成parfor循环.我的意思是多核运算只能加速parfor的部分.

    刚才试了一下,我使用的MATLAB2010可以多核运行的。需要多核多线程跑的算法,在之前要让matlab在本地建立4个“实验室”(我的机器是4核,所以是4个)
    >> matlabpool local 4
    Starting matlabpool using the 'local' configuration ... connected to 4 labs.
    显示正在进行多核配置,一会说,连接到4个“实验室”。我理解就是在本地虚拟出4台可以运行matlab的工作站,这样用分布式计算工具箱可以进行并行计算(matlabpool这个命令好像是在并行计算工具箱里的)。观察windows任务管理器,可以发现一共有5个MATLAB.exe进程。其中一个占内存较多的,我理解是主控的,他基本不干活,只负责分配,进行计算时他的cpu占用率只有1~2%,剩下四个进程专门用来计算的,跑起来各占cpu 25%左右。看上去还是每个matlab进程单核运算,但是一下开4个进程,所以能把cpu用满。
    如果后续还需要多核运算,就直接用parfor好了,不用每次都用matlabpool命令。那个配置一次就好。
    算完了,不再跑了,临退出时关闭配置就行。
    >> matlabpool close
    Sending a stop signal to all the labs ... stopped.

    下面是我一个M文件的程序,测测4核并行计算和单核计算的差距,很简单。
    function testtime

    runtimes = 1e9;
    dummy1 
      = 0;
    dummy2   = 0;

    %matlabpool local 4

    tic
    %for x= 1:runtimes;
    parfor x= 1:runtimes;
        dummy1 = dummy1 + x;
        dummy2 = 2 * x + 1;
    end
    toc

    plot([1 2], [dummy1, dummy2]);

    第一次用普通for语句,单核跑,6.09秒
    >> testtime
    Elapsed time is 6.094267 seconds.

    第二次用parfor语句,4核跑,1.63秒
    >> matlabpool local 4
    Starting matlabpool using the 'local' configuration ... connected to 4 labs.
    >> testtime
    Elapsed time is 1.631350 seconds.
    >> matlabpool close

    加速比 6.09 / 1.63 = 3.736,将近4倍(还有开销吧),还比较可观。


     由于处理器时钟频率的限制,增加核并不意味着是计算性能的提高。为了充分利用新的多核硬件在性能上的优势,软件的基层结构需要向并行计算转换。MATLAB并行计算工具箱就是这种需求的产物,它能很好地实现在多核系统上进行并行运算。文章以典型的数值计算问题为例描述如何使用基本的两种并行运算方式:线程和并行for循环。

    典型数值计算问题

          为了举例说明这两种方法,我们使用MATLAB 测试一个有关Girko圆定律的假设。Girko圆定律的内容是:一个N×N的随机矩阵(它的元素服从正态分布)的特征值位于半径为的圆内。假设Girko圆定律能被修改应用到奇异值上。这个假设是合理的因为奇异值是一个变换了的矩阵的特征值。首先我们用MATLAB代码实现Girko圆定律的一个实例:

    N = 1000;
    plot(eig(randn(N)) / sqrt(N), ‘.’);
    这段代码运行后得到图1,图上每个点代表复平面上一个特征值。注意所有的特征值都位于半径为1 ,圆心在轴的原点的圆内,特别指出的是结果与Girko圆定律是一致的,特征值的幅值没有超过矩阵维数的平方根。

    [转载]matlab <wbr>多核计算设置2
     
    图1 大小为1000的随机矩阵的特征值在半径为sqrt(1000)的圆内


          为了将Girko定律应用到奇异值分解上,我们用MATLAB生成随机矩阵,然后估算它们的奇异值,看是否能基于数值计算阐明这个假设。我们用任意变量N计算max(svd(randn(N)))的值,然后在结果中寻找规律,而这个规律是可以用奇异值分解的理论解释的。

          通过下面的循环产生正规随机矩阵,并计算它们的奇异值:

    y = zeros(1000,1);
    for n = 1:1000
     y(n) = max(svd(randn(n)));
    end
    plot(y);

          在单核计算机上运行这段循环代码时需要15分钟多的时间。为了减少计算时间,我们用线程和并行  for循环在多核计算机上运行这段循环代码,然后再来比较性能结果。

    使用线程

          线程是在多核计算机上进行并行计算的软件解决方案,但是需要记住的一点是多线程和多核处理器不是同一个概念。通常线程的数量和多核的数量一致时性能是最好的,但是也有线程比核少的情况。我们将通过实验去确定对于我们的计算所需的最佳的线程的个数。

          运行上面的代码,并通过MATLAB界面属性窗口或者使用maxNumCompThreads()函数去调节线程的个数。图2 显示了不同线程数量对应的结果。除了时间,还有加速情况和并行效率。前者是多核执行时间与单核执行时间的比率,理想地,我们期望在N个核上能达到N倍。后者是加速倍数与核的个数的比率,理想地,我们期望能达到100%。

     

    线程个数

    运行循环所需时间 

    加速倍数 

    效率 

    1

    902.6

    1.00  

    100%

    2

    867.2

    1.04 

    52%

    3

    842.3 

    1.07 

    35%

    4

    862.3

    1.05 

     26%

     

    图2 不同线程数量对应的代码性能

          结果呈现混合型的特点。使用线程确实能提高计算的速度,但是在我们的例子,只有对svd()的调用是被并行计算的。这是因为MATLAB所支持的线程是有限制的:用户不能决定代码的哪部分进行并行运算。

          一方面,我们使用多核在不改变代码的情况下加快了计算的速度。另一方面,当增加内核而并没有减少执行时间时就意味着是对成本的浪费。这个时候,我们需要另一种并行运算方法。

    使用并行for循环

          Parfor循环,即并行for循环,在简单计算中有大量循环语句时是非常有用的。使用Parfor需要并行计算工具箱的支持。图3 是用Parfor语句和前面代码的对比。

     

    y = zeros(1000,1);
    for n = 1:1000
     y(n) = max(svd(randn(n)));
    end
    plot(y); 
     
    y = zeros(1000,1);
    parfor n = 1:1000
     y(n) = max(svd(randn(n)));
    end
    plot(y);
     

     

    图3 左边:原来的代码  右边:用parfor实现的循环语句

          就像maxNumCompThreads()命令可以控制多核方法的并行运算,matlabpool命令能够控制parfor指令的并行行为。Matlabpool指令创建并行任务执行的环境,在此环境下并行for循环能够从MATLAB 的命令提示符交互执行。

          Parfor循环在labs上执行,labs之间是能够交互的。像线程一样,labs在处理器核上执行,但是labs的数量并不一定与核的数量相匹配。另不同于线程,labs互相之间是不共享存储单元的。所以,它们能够运行在联网的独立的计算机上。但是,在我们的例子中,我们仅需要知道并行运算工具箱使得parfor有效地工作在一个多核系统上。每个核或本地worker能主导一个lab。

          问题自然就出现了:改变代码值得吗?在我们的例子中,改变代码是值得的因为下面的表格清楚地表明了使用parfor的好处。

     

    Labs数量 

    运行循环所需时间 

    加速倍数 

    效率 

    1

    870.1 

    1.00  

    100% 

    2

    487.0 

    1.79 

    89% 

    3

    346.2 

    2.51 

    83% 

    4

    273.9 

    3.17 

    79% 

     

    图4 不同的lab数量对应的代码性能

          从结果可以看出,对于此奇异值分解的计算,无论从加速情况还是效率,parfor的性能是优于多线程的。

          不细究代码实现的细节,也有必要解释使用parfor带来的好处。例子中的代码最显著的特征是每个循环是独立的。独立性的特征使得parfor的应用很简单也很高效。使用parfor留给系统的唯一任务是分配循环任务到核执行并获取结果用于其他的运算。

          值得说明的一点是parfor在随机数产生的问题上。在parfor循环中使用诸如randn()函数产生的矩阵与for循环中使用类似函数产生的矩阵并不一致,因为parfor循环的是已经被预定了的。在绝大多情况下,这种差异完全是可以接受的。

          使用parfor有它的优点,但也有其局限性。例如,如果循环之间相互依赖,而且这种依赖能够通过代码分析得到,那么执行parfor循环就会得到错误的结果。如果这种依赖关系没有检测到,那么就会得到不正确的结果。下面的代码说明了这样的问题:

    total = 0;
    A = zeros(1000, 1);
    parfor i = 1:100
     total = total + i; % OK: this is ...
      ...a known reduction operation
     A(i+1) = A(i) + 1; % error: ...   ...loop iterations are dependent
    end

    利用parfor很容易计算total的表达式,但是对于第二个表达式,由于A(i+1)依赖于前一次循环得到的A(i),所以用parfor计算会产生问题。

    让我们来更进一步地看看每次循环发生了什么:

    Iteration 1: i = 1
     A(2) = A(1) + 1 = 0 + 1 = 1
    Iteration 2: i = 2
     A(3) = A(2) + 1 = 1 + 1 = 2
    Iteration 3: i = 3
     A(4) = A(3) + 1 = 2 + 1 = 3

    通过以上分析我们可以用下面的parfor循环的代码得到跟前面同样结果的代码:

    parfor i = 1:10
      A(i+1) = i;
    end

    扩展并行计算

          MATLAB已经支持几种并行方法,其他的方法将逐渐在高版本中实现。

          我们相信未来计算机将有越来越多的核。总是没过几年核的个数就翻倍,也意味着计算能力的翻倍。但是要利用好这种硬件的优势就需要正确的软件,而写正确的软件就需要正确的软件开发工具。MATLAB便旨在实现这种需求。
    ________________________________________

    所需产品

    • MATLAB 
    • Parallel Computing Toolbox

    资源与示例

    • Using parfor to Run Loops in Parallel 
    • Parallel Programming in MATLAB

    文章

    • Eigenvalues and Condition Numbers of Random Matrices. Alan Edelman. Ph.D. thesis, Massachusetts Institute of Technology, May 1989.
    • Language Design for an Uncertain Hardware Future. Roy Lurie. HPCwire, September 28, 2007
    • Multiple Processors and Multiple Cores. Cleve Moler. The MathWorks News & Notes, June 2007


    展开全文
  • 并行运算实例

    2007-08-08 21:09:51
    通过分配服务器运算单元分配到运算客户端,然后合成生成结果,提供相应的源代码,该源代码加密,需要者可以索取。
  • 原文地址:matlab并行计算,大家共同学习吧,涉及到大...今天为了在8核的dell服务器上跑程序才专门看了一下。本身写的程序就很容易实现并行化,因为beamline之间并没有考虑相互作用。等于可以拆成n个线程并行,要是...

    原文地址:matlab并行计算,大家共同学习吧,涉及到大规模数据量处理的时候还是效果很好的微笑

    今天搞了一下matlab的并行计算,效果好的出乎我的意料。

    本来CPU就是双核,不过以前一直注重算法,没注意并行计算的问题。今天为了在8核的dell服务器上跑程序才专门看了一下。本身写的程序就很容易实现并行化,因为beamline之间并没有考虑相互作用。等于可以拆成n个线程并行,要是有550核的话,估计1ms就算完了。。。

    先转下网上找到的资料。

    一、Matlab并行计算原理梗概

    Matlab的并行计算实质还是主从结构的分布式计算。当你初始化Matlab并行计算环境时,你最初的Matlab进程自动成为主节点,同时初始化多个(具体个数手动设定,详见下文)Matlab计算子节点。Parfor的作用就是让这些子节点同时运行Parfor语句段中的代码。Parfor运行之初,主节点会将Parfor循环程序之外变量传递给计算子节点。子节点运算过程时互不干扰,运算完毕,则应该有相应代码将各子节点得到的结果组合到同一个数组变量中,并返回到Matlab主节点。当然,最终计算完毕应该手动关闭计算子节点。

    二十六、初始化Matlab并行计算环境

    这里讲述的方法仅针对多核机器做并行计算的情况。设机器的CPU核心数量是CoreNum双核机器的CoreNum2,依次类推。CoreNum以不等于核心数量,但是如果CoreNum小于核心数量则核心利用率没有最大化,如果CoreNum大于核心数量则效率反而可能下降。因此单核机器就不要折腾并行计算了,否则速度还更慢。下面一段代码初始化Matlab并行计算环境:

    %Initialize Matlab Parallel Computing Enviornment by Xaero | Macro2.cn

    CoreNum=2; %设定机器CPU核心数量,我的机器是双核,所以CoreNum=2

    if matlabpool('size')<=0 %判断并行计算环境是否已然启动

    matlabpool('open','local',CoreNum); %若尚未启动,则启动并行环境

    else

    disp('Already initialized'); %说明并行环境已经启动。

    end

     

    运行成功后会出现如下语句:

    Starting matlabpool using the 'local' configuration ... connected to 2 labs.

    如果运行出错,按照下面的办法检测:

    首先运行:

    matlabpool size

     

    如果出错,说明你没有安装Matlab并行工具箱。确认安装了此工具箱后,运行:

    matlabpool open local 2;

    如果出错,证明你的机器在开启并行计算时设置有问题。请联系MathWorks的售后服务。

     

    二十七、终止Matlab并行计算环境

    用上述语句启动Matlab并行计算环境的话,在你的内存里面有CoreNumMatlab进程存在,每个占用内存都在百兆以上。(可以用Windows任务管理器查看),故完成运行计算后可以将其关闭。关闭的命令很简单:

    matlabpool close

    二十八、MatlabMonte Carlo并行的算法

    Matlab并行计算比较特别。下图节选自Matlab并行计算工具箱用户手册。这个列表告诉你Matlab如何处理Parfor并行计算程序段中的各种变量。所以写代码时要注意不少问题,否则写出的并行代码可能还不如非并行的代码快。


    这里我推荐大家用MatlabMonte Carlo并行代码时按照以下注意事项来写:

    1.Monte Carlo模拟过程中不会改变的参数都写在Parfor循环块外面

    2.生成随机数、计算f(x)等过程都写在Parfor里面

    3.不要将V0结果传递出Parfor,而是直接计算出V0的均值、方差传递出parfor

    4.最后用数学公式将传递出ParforV0的均值方差组合计算成最终结果

    这些事项如何体现到程序中请参照示例代码文件并结合视频教程学习。这样的并行办法简单易行,对原始程序没有太大的改动,同时传递变量耗费时间也较少,效率比较高。

    另外一个问题就是并行代码做模拟的次数问题。我们要达到用非并行的代码做N此模拟所能得到结果的精确程度,在核心为CoreNum并行代码中,Parfor语句段中只要做N/CoreNum次即可达到。

    二十九、将例子改写为并行代码

    附件中的pareg1.m,……,pareg5.m五个文件分别是前一章五个例子的并行代码。这里需要提到的是,这五个代码文件都是用向量化的代码编写。原因在于,在前一章大家都看到了,向量化的代码比循环语句代码一般快几十甚至上千倍,所以要提高速度,向量化代码是最重要的优化方法,并行计算倒是其次。

     

    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

    由于要搜索多核运行,找到这个帖子里来了

    刚才试了一下,我使用的MATLAB2010可以多核运行的。需要多核多线程跑的算法,在之前要让matlab在本地建立4个“实验室”(我的机器是4核,所以是4个)
    >> matlabpool local 4
    Starting matlabpool using the 'local' configuration ... connected to 4 labs.
    显示正在进行多核配置,一会说,连接到4个“实验室”。我理解就是在本地虚拟出4台可以运行matlab的工作站,这样用分布式计算工具箱可以进行并行计算(matlabpool这个命令好像是在并行计算工具箱里的)。观察windows任务管理器,可以发现一共有5个MATLAB.exe进程。其中一个占内存较多的,我理解是主控的,他基本不干活,只负责分配,进行计算时他的cpu占用率只有1~2%,剩下四个进程专门用来计算的,跑起来各占cpu 25%左右。看上去还是每个matlab进程单核运算,但是一下开4个进程,所以能把cpu用满。
    如果后续还需要多核运算,就直接用parfor好了,不用每次都用matlabpool命令。那个配置一次就好。
    算完了,不再跑了,临退出时关闭配置就行。
    >> matlabpool close
    Sending a stop signal to all the labs ... stopped.

    下面是我一个M文件的程序,测测4核并行计算和单核计算的差距,很简单。
    function testtime

    runtimes = 1e9;
    dummy1   = 0;
    dummy2   = 0;

    %matlabpool local 4

    tic
    %for x= 1:runtimes;
    parfor x= 1:runtimes;
        dummy1 = dummy1 + x;
        dummy2 = 2 * x + 1;
    end
    toc

    plot([1 2], [dummy1, dummy2]);

    第一次用普通for语句,单核跑,6.09秒
    >> testtime
    Elapsed time is 6.094267 seconds.

    第二次用parfor语句,4核跑,1.63秒
    >> matlabpool local 4
    Starting matlabpool using the 'local' configuration ... connected to 4 labs.
    >> testtime
    Elapsed time is 1.631350 seconds.
    >> matlabpool close

    加速比 6.09 / 1.63 = 3.736,将近4倍(还有开销吧),还比较可观。
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
     
    然后说一下要注意的几个问题:
    1、parfor效果好,但是用起来要注意程序的细节。很多地方都会报错。比如下标必须为连续的整数!否则会报下面这个错误“The variable xxx in a parfor cannot be classified.”具体可以看parfor帮助文件里面的sliced variables这一节,帮助建议仔细全部看过最好。
    2、用了parfor之后,输出参数用nargout确定,会出错。不知道为什么。
    3、变量在parfor内外的传进传出要非常小心,因为并行的关系,依赖循环下标的变量都要仔细考虑。
     
    在我的程序里面,用profile监测,
    不用并行计算的时候,CPU时间为 84.742 S,
    用了并行计算的时候,CPU时间为 15.231 S
    加速比达到了5.6!!!!!!
     
    Oh my lady gaga!!!!!!
     
    双核E6400,不知道为什么加速比这么恐怖.
     
    明天在xeon 5310上面去试试,双CPU,一共8核,不知道会是什么样子,估计最多1S。。。。


    其实并行计算我感觉就是多线程,因此在设计程序的时候还应该注意。。

    转载于:https://www.cnblogs.com/cl1024cl/p/6205066.html

    展开全文
  • 当然,并行读取的最终目的是提高程序的运算效率。在FunDA中具体的实现方式是对多个独立的数据流进行并行读取形成一个统一综合的数据流。我们还是用上次示范所产生的表AQMRPT作为样板数据。在这次示范里我们需...

       FunDA的并行数据库读取功能是指在多个线程中同时对多个独立的数据源进行读取。这些独立的数据源可以是在不同服务器上的数据库表,又或者把一个数据库表分成几个独立部分形成的独立数据源。当然,并行读取的最终目的是提高程序的运算效率。在FunDA中具体的实现方式是对多个独立的数据流进行并行读取形成一个统一综合的数据流。我们还是用上次示范所产生的表AQMRPT作为样板数据。在这次示范里我们需要把AQMRPT表中的STATENAME,COUNTYNAME字段抽取出来形成两个独立的表STATE和COUNTY。这两个表结构如下:

      case class StateModel(id: Int, name: String) extends FDAROW
      class StateTable(tag: Tag) extends Table[StateModel](tag,"STATE") {
        def id = column[Int]("ID",O.AutoInc,O.PrimaryKey)
        def name = column[String]("NAME",O.Length(32))
        def * = (id,name)<>(StateModel.tupled,StateModel.unapply)
      }
      val StateQuery = TableQuery[StateTable]
    
      case class CountyModel(id: Int, name: String) extends FDAROW
      case class CountyTable(tag: Tag) extends Table[CountyModel](tag,"COUNTY") {
        def id = column[Int]("ID",O.AutoInc,O.PrimaryKey)
        def name = column[String]("NAME",O.Length(64))
        def * = (id,name)<>(CountyModel.tupled,CountyModel.unapply)
      }
      val CountyQuery = TableQuery[CountyTable]

    首先我们用一些铺垫代码把这两个表结构创建出来:

      //assume two distinct db objects
      val db_a = Database.forConfig("h2db")
      //another db object
      val db_b = Database.forConfig("h2db")
    
    
      //create STATE table
      val actionCreateState = Models.StateQuery.schema.create
      val futCreateState = db_a.run(actionCreateState).andThen {
        case Success(_) => println("State Table created successfully!")
        case Failure(e) => println(s"State Table may exist already! Error: ${e.getMessage}")
      }
      //would carry on even fail to create table
      Await.ready(futCreateState,Duration.Inf)
    
      //create COUNTY table
      val actionCreateCounty = Models.CountyQuery.schema.create
      val futCreateCounty = db_a.run(actionCreateCounty).andThen {
        case Success(_) => println("County Table created successfully!")
        case Failure(e) => println(s"County Table may exist already! Error: ${e.getMessage}")
      }
      //would carry on even fail to create table
      Await.ready(futCreateCounty,Duration.Inf)

    下一步我们把STATENAME从AQMRPT表里抽取出来形成一个数据源(data-source):

      //define query for extracting State names from AQMRPT
      val qryStates = AQMRPTQuery.map(_.state).distinct.sorted  //     .distinctOn(r => r)
      case class States(name: String) extends FDAROW
      implicit def toStates(row: String) = States(row)
      val stateLoader = FDAStreamLoader(slick.jdbc.H2Profile)(toStates _)
      val statesStream = stateLoader.fda_typedStream(qryStates.result)(db_a)(64,64)()

    由于COUNTYNAME比较多,我们可以把AQMRPT表按STATENAME拆成三部分A-K、K-P、P-Z。然后把这三部分构建成三个独立的数据源:

      //define query for extracting County names from AQMRPT in separate chunks
      //query with state name >A and <K
      val qryCountiesA_K = AQMRPTQuery.filter(r => (r.state.toUpperCase > "A" &&
        r.state.toUpperCase < "K")).map(r => (r.state,r.county))
        .distinctOn(r => (r._1,r._2))
        .sortBy(r => (r._1,r._2))
    
      //query with state name >K and <P
      val qryCountiesK_P = AQMRPTQuery.filter(r => (r.state.toUpperCase > "K" &&
        r.state.toUpperCase < "P")).map(r => (r.state,r.county))
        .distinctOn(r => (r._1,r._2))
        .sortBy(r => (r._1,r._2))
    
      //query with state name >P
      val qryCountiesP_Z = AQMRPTQuery.filter(r => r.state.toUpperCase > "P")
        .map(r => (r.state,r.county))
        .distinctOn(r => (r._1,r._2))
        .sortBy(r => (r._1,r._2))
    
      case class Counties(state: String, name: String) extends FDAROW
      implicit def toCounties(row: (String,String)) = Counties(row._1,row._2)
      val countyLoader = FDAStreamLoader(slick.jdbc.H2Profile)(toCounties _)
      //3 separate streams to extract county names from the same database table AQMRPT
      val countiesA_KStream = countyLoader.fda_typedStream(qryCountiesA_K.result)(db_b)(64,64)()
      val countiesK_PStream = countyLoader.fda_typedStream(qryCountiesK_P.result)(db_b)(64,64)()
      val countiesP_ZStream = countyLoader.fda_typedStream(qryCountiesP_Z.result)(db_b)(64,64)()

    然后对这四个数据源进行并行读取:

      //obtain a combined stream with parallel loading with max of 4 open computation
      val combinedStream = fda_par_load(statesStream,countiesA_KStream,countiesK_PStream,countiesP_ZStream)(4)

    现在这个组合的数据流里最少有两种不同的数据元素,分别是:case class States和case class Counties。我们可以在combinedStream上连接两个用户自定义函数(user-defined-task)分别截取States和Counties数据行并且把它们转化成各自的插入数据指令行(ActionRow):

      //define separate rows for different actions
      case class StateActionRow(action: FDAAction) extends FDAROW
      case class CountyActionRow(action: FDAAction) extends FDAROW
      val actionRunner = FDAActionRunner(slick.jdbc.H2Profile)
    
      //user-task to catch rows of States type and transform them into db insert actions
      def processStates: FDAUserTask[FDAROW] = row => {
        row match {
            //catch states row and transform it into insert action
          case States(stateName) =>  //target row type
            println(s"State name: ${stateName}")
            val action = StateQuery += StateModel(0,stateName)
            fda_next(StateActionRow(action))
          case others@ _ => //pass other types to next user-defined-tasks
            fda_next(others)
        }
      }
      //user-task to catch rows of Counties type and transform them into db insert actions
      def processCounties: FDAUserTask[FDAROW] = row => {
        row match {
          //catch counties row and transform it into insert action
          case Counties(stateName,countyName) =>  //target row type
            println(s"County ${countyName} of ${stateName}")
            val action = CountyQuery += CountyModel(0,countyName+ " of "+stateName)
            fda_next(CountyActionRow(action))
          case others@ _ => //pass other types to next user-defined-tasks
            fda_next(others)
        }
      }

    经过processStates和processCounties两个自定义函数处理后combinedStream里又多了两种不同的元素:StateActionRow和CountyActionRow。同样,我们可以用两个自定义函数来运算这两种动作行:

      //user-task to catch States insert action rows and run them
      def runStateAction: FDAUserTask[FDAROW] = row  => {
        row match {
          case StateActionRow(action) => //this is a state action row type
            println(s"runstate: ${action}")
            actionRunner.fda_execAction(action)(db_a)  //run this query with db_a context
            fda_skip
          case others@ _ => //otherwise pass alone to next user-defined-tasks
            fda_next(others)
        }
      }
    
      //user-task to catch Counties insert action rows and run them
      def runCountyAction: FDAUserTask[FDAROW] = row  => {
        row match {
          case CountyActionRow(action) => //this is a county action row type
            actionRunner.fda_execAction(action)(db_b)  //run this query with db_b context
            fda_skip
          case others@ _ => //otherwise pass alone to next user-defined-tasks
            fda_next(others)
        }
      }

    好了,现在我们可以把这四个自定义函数在combinedStream上组合起来成为一个完整功能的程序:

      combinedStream.appendTask(processStates)
        .appendTask(processCounties)
        .appendTask(runStateAction)
        .appendTask(runCountyAction)
        .startRun

    然后用startRun来正式运算这个程序。

    下面就是本次示范的源代码:

    import com.bayakala.funda._
    import api._
    import scala.language.implicitConversions
    import slick.jdbc.H2Profile.api._
    import scala.concurrent.duration._
    import scala.concurrent.{Await, Future}
    import scala.util.{Failure, Success}
    import Models._
    import scala.concurrent.ExecutionContext.Implicits.global
    
    object ParallelLoading extends App {
    
      //assume two distinct db objects
      val db_a = Database.forConfig("h2db")
      //another db object
      val db_b = Database.forConfig("h2db")
    
    
      //create STATE table
      val actionCreateState = Models.StateQuery.schema.create
      val futCreateState = db_a.run(actionCreateState).andThen {
        case Success(_) => println("State Table created successfully!")
        case Failure(e) => println(s"State Table may exist already! Error: ${e.getMessage}")
      }
      //would carry on even fail to create table
      Await.ready(futCreateState,Duration.Inf)
    
      //create COUNTY table
      val actionCreateCounty = Models.CountyQuery.schema.create
      val futCreateCounty = db_a.run(actionCreateCounty).andThen {
        case Success(_) => println("County Table created successfully!")
        case Failure(e) => println(s"County Table may exist already! Error: ${e.getMessage}")
      }
      //would carry on even fail to create table
      Await.ready(futCreateCounty,Duration.Inf)
    
      //define query for extracting State names from AQMRPT
      val qryStates = AQMRPTQuery.map(_.state).distinct.sorted  //     .distinctOn(r => r)
      case class States(name: String) extends FDAROW
      implicit def toStates(row: String) = States(row)
      val stateLoader = FDAStreamLoader(slick.jdbc.H2Profile)(toStates _)
      val statesStream = stateLoader.fda_typedStream(qryStates.result)(db_a)(64,64)()
    
    
      //define query for extracting County names from AQMRPT in separate chunks
      //query with state name >A and <K
      val qryCountiesA_K = AQMRPTQuery.filter(r => (r.state.toUpperCase > "A" &&
        r.state.toUpperCase < "K")).map(r => (r.state,r.county))
        .distinctOn(r => (r._1,r._2))
        .sortBy(r => (r._1,r._2))
    
      //query with state name >K and <P
      val qryCountiesK_P = AQMRPTQuery.filter(r => (r.state.toUpperCase > "K" &&
        r.state.toUpperCase < "P")).map(r => (r.state,r.county))
        .distinctOn(r => (r._1,r._2))
        .sortBy(r => (r._1,r._2))
    
      //query with state name >P
      val qryCountiesP_Z = AQMRPTQuery.filter(r => r.state.toUpperCase > "P")
        .map(r => (r.state,r.county))
        .distinctOn(r => (r._1,r._2))
        .sortBy(r => (r._1,r._2))
    
      case class Counties(state: String, name: String) extends FDAROW
      implicit def toCounties(row: (String,String)) = Counties(row._1,row._2)
      val countyLoader = FDAStreamLoader(slick.jdbc.H2Profile)(toCounties _)
      //3 separate streams to extract county names from the same database table AQMRPT
      val countiesA_KStream = countyLoader.fda_typedStream(qryCountiesA_K.result)(db_b)(64,64)()
      val countiesK_PStream = countyLoader.fda_typedStream(qryCountiesK_P.result)(db_b)(64,64)()
      val countiesP_ZStream = countyLoader.fda_typedStream(qryCountiesP_Z.result)(db_b)(64,64)()
    
      //obtain a combined stream with parallel loading with max of 4 open computation
      val combinedStream = fda_par_load(statesStream,countiesA_KStream,countiesK_PStream,countiesP_ZStream)(4)
    
    
      //define separate rows for different actions
      case class StateActionRow(action: FDAAction) extends FDAROW
      case class CountyActionRow(action: FDAAction) extends FDAROW
      val actionRunner = FDAActionRunner(slick.jdbc.H2Profile)
    
      //user-task to catch rows of States type and transform them into db insert actions
      def processStates: FDAUserTask[FDAROW] = row => {
        row match {
            //catch states row and transform it into insert action
          case States(stateName) =>  //target row type
            println(s"State name: ${stateName}")
            val action = StateQuery += StateModel(0,stateName)
            fda_next(StateActionRow(action))
          case others@ _ => //pass other types to next user-defined-tasks
            fda_next(others)
        }
      }
      //user-task to catch rows of Counties type and transform them into db insert actions
      def processCounties: FDAUserTask[FDAROW] = row => {
        row match {
          //catch counties row and transform it into insert action
          case Counties(stateName,countyName) =>  //target row type
            println(s"County ${countyName} of ${stateName}")
            val action = CountyQuery += CountyModel(0,countyName+ " of "+stateName)
            fda_next(CountyActionRow(action))
          case others@ _ => //pass other types to next user-defined-tasks
            fda_next(others)
        }
      }
    
      //user-task to catch States insert action rows and run them
      def runStateAction: FDAUserTask[FDAROW] = row  => {
        row match {
          case StateActionRow(action) => //this is a state action row type
            println(s"runstate: ${action}")
            actionRunner.fda_execAction(action)(db_a)  //run this query with db_a context
            fda_skip
          case others@ _ => //otherwise pass alone to next user-defined-tasks
            fda_next(others)
        }
      }
    
      //user-task to catch Counties insert action rows and run them
      def runCountyAction: FDAUserTask[FDAROW] = row  => {
        row match {
          case CountyActionRow(action) => //this is a county action row type
            actionRunner.fda_execAction(action)(db_b)  //run this query with db_b context
            fda_skip
          case others@ _ => //otherwise pass alone to next user-defined-tasks
            fda_next(others)
        }
      }
    
    
    
      def showRows: FDAUserTask[FDAROW] = row => {
        row match {
          case States(nm) =>
            println("")
            println(s"State: $nm")
            println("************")
            fda_skip
          case Counties(s,c) =>
            println("")
            println(s"County: $c")
            println(s"state of $s")
            println("------------")
            fda_skip
          case _ => fda_skip
        }
      }
    
      combinedStream.appendTask(processStates)
        .appendTask(processCounties)
        .appendTask(runStateAction)
        .appendTask(runCountyAction)
        .startRun
    
    }
    
     

     

     

     

     

     

     

     

     

     

     

     

     

     

    转载于:https://www.cnblogs.com/tiger-xc/p/6623158.html

    展开全文
  • 最近在服务器上应用Pharmdock软件进行运算时,只能利用一个cpu,考虑到cpu浪费太多,于是考虑到了多线程 import os from multiprocessing import Pool def get_mol_paths(folder): return (os.path.join(folder,f)...
  • 资源的可扩展管理是集群式密码服务器设计中的关键问题。本文通过分析密码运算的特点,设置算法线程代理密码芯片的运算资源,...该方法实现了系统资源的可扩展管理,并支持集群系统内多密码芯片并行运算资源的调度管理。
  • 这是用corba 编的 客户端和服务器 并行运算的PRIM的最小生成树
  • matlab_集群搭建及使用.pdf MATLAB并行计算简介(是几个机子并行的).ppt MATLAB并行运算和分布式运算的基本操作-图解.pdf 家庭云服务器高阶应用:通过Matlab分布式计算....DIYPCs.pdf
  • 并发与并行

    2017-10-12 23:48:31
    并行运算 并发与并行的区别: “一个并发程序是指能同时执行通常不相关的各种任务。以一个游戏服务器为例子:它通常是有各种组件组成,每种组件都跟外部世界进行着复杂的信息交互。一个组件有可能要处理多个用户聊...
  • pg9.6并行优化配置

    2020-03-23 14:28:03
    9.6 版本现支持一些并行查询操作,因而能够利用服务器上的几个或所有的 CPU 内核来进行运算,这样返回查询结果更快。 此版本的并行功能包括并行顺序表扫描、聚合和联接。根据详细信息和可用内核,并行性可以加快...
  • 服务器部署逻辑

    2019-10-05 17:31:55
    服务器部署逻辑 ...服务器选择: 物理服务器: CPU、核心数,主频、服务器可以支持多CPU并行运算, 内存、容量、频率 硬盘、包括本地存储,磁盘阵列等。机械硬盘:容量、转速、缓存大小。固态硬盘 ...
  • IBM GPFS并行文件系统解决方案

    千次阅读 2015-07-07 11:01:54
    吸取了SP 大规模并行机的诸多优势,IBM的通用并行文件系统GPFS 等和Linux 集群系统的竭诚不仅能在并行运算方面的性能得到保障,增强了集群系统的可管理性,而且采用具有高可用性的IBM xSeries 服务器,可以大大降低...
  • 吸取了SP 大规模并行机的诸多优势,IBM的通用并行文件系统GPFS 等和Linux 集群系统的竭诚不仅能在并行运算方面的性能得到保障,增强了集群系统的可管理性,而且采用具有高可用性的IBM xSeries服务器,可以大大降低...
  • 并行计算性能测试

    千次阅读 2011-11-26 10:24:51
    现在为提高整体计算的效率,采用并行计算,如果要计算总分,就把A/B/C的计算需求由主机同时分发给三台服务器,待三台服务器运算出结果后返回给主机,然后主机根据三台服务器的返回结果算出部分,此时的计算耗
  • 服务器cpu架构介绍

    千次阅读 2014-03-31 16:54:13
    处理器的指令执行方式,如RISC(精简指令运算集 )、CISC(复杂指令运算集 )、VLIW(显式并行指令运算集 )、EPIC(超长指令集架构 )。 1.x86架构服务器   IA-32、x86-32和x86-64都属于x86,即Intel的32位x86...
  • 服务器硬件

    2019-11-25 16:12:26
    cpu核数:服务器并行处理任务的能力 磁盘 作用:存储数据信息(永久) 容量:决定存储数据的容量 (最小的存储单位为字节) 接口:sat scsi sas 种类:决定数据读取效率 机械硬盘 固态硬盘 转速:存储书法据...
  • rac中控制节点间并行

    2011-03-17 15:08:22
    rac中控制节点间并行 ------------------- ...数据库服务器的cpu数量越来越多为充分提高性能,很多时候都会使用并行处理来提高运算速度并行处理虽然可以在多个cpu上进行一个事务的处理,提高运算能力但同时...
  • 服务器硬件的组成

    2019-12-01 18:27:02
    服务器的基本硬件知识服务器...核数 —— 服务器并行处理任务的能力 2.磁盘 存储数据信息(永久) 容量 —— 决定存储数据容量(最小存储数据单位Byte(字节)) 单位换算 1KB = 1024字节 1MB = 1024 KB 1GB = 1024 ...
  • 区块链技术主要特点

    2021-01-27 08:42:24
    区块链是一种由多方共同维护,使用加密技术保证信息传输和 访问安全,按照时间序列存储的分布链式结构数据库。...传统分布式计算是将海量数据切分为成百上千的碎片,交给多台服务器并行运算,实现海量
  • 为提高分子动力学模拟在多核共享内存式服务器上的运算速度, 在现有的分子动力学并行算法基础上提出了Multi-Critical算法。该算法使用手动划分力矩阵的方法, 使多个线程进入不同名的临界区, 并使用分块叠加的方法优化...
  • 数据库服务器的cpu数量...为充分提高性能,很多时候都会使用并行处理来提高运算速度 并行处理虽然可以在多个cpu上进行一个事务的处理,提高运算能力 但同时也有合并数据以及其他方面的开销 对于rac来说,如果一...
  • Tensorflow并行GPU计算

    千次阅读 2018-09-19 11:22:04
    Tensorflow程序可以通过tf.device函数来指定运行每一个操作的设备,这个设备可以是本地CPU或GPU,也可以是某一台远程服务器。 tf.device函数可以通过设备的名称来指定执行运算的设备。 如CPU在tensorflow中的名称为...
  • golang--多核并行

    2019-07-29 14:31:03
    go语言具有支持高并发的特性,可以很方便地实现多线程运算,充分利用多个cpu的性能。 众所周知服务器的处理器大都是单核频率较低而核心数较多,对于支持高并发的程序语言,可以充分利用服务器的多核优势,从而降低...
  • 浪潮英信NF510D服务器支持双核英特尔至强处理器7100系列,提供更出色的并行运算处理能力和更高的能效比;内存热插拔、内存镜像与热备、内存RAID等高级内存容错功能有效规避宕机风险;高级光路诊断与智能管理系统...
  • 为了满足社会对无线通信不断增长的需求,METIS组织提出了5G通信的目标、场景和可能的技术方案,面临的需求越来越苛刻,...基于Matlab提供的分布式并行计算服务器设计一种用于评估未来5G无线通信技术和性能的仿真平台。

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 329
精华内容 131
关键字:

服务器并行运算