精华内容
下载资源
问答
  • 本文出自:点击打开链接 计算从1~1E10的和 // paralle.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <omp.h> #include <stdio.h> #include &...

    本文出自:点击打开链接


    计算从1~1E10的和

    // paralle.cpp : 定义控制台应用程序的入口点。
    //
    
    
    #include "stdafx.h"
    #include <omp.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <windows.h>
    #include <time.h>
    
    #define NUM_THREADS 4
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	omp_set_num_threads(NUM_THREADS);
    
    	long long sum = 0;
    	long long sumtmp[NUM_THREADS];
    	clock_t t1 = clock();
    
    #pragma omp parallel 
    	{
    		long i;
    		long id = omp_get_thread_num();
    		long long temp = 0L;
    #pragma omp for
    		for(i = 1; i <= 1000000000; i++)
    		{
    			temp+=i;
    		}
    		sumtmp[id] = temp;
    	}
    
    	for(long i = 0; i < NUM_THREADS; i++)
    	{
    		sum += sumtmp[i];
    	}
    
    	clock_t t2 = clock();
    	printf("sum=%lld\n", sum);
    	printf("parallel time = %d\n", (t2-t1));
    
    	sum = 0;
    	t1 = clock();
    	for(long i = 1; i <= 1000000000; i++)
    		sum += i;
    
    	t2 = clock();
    	printf("sum=%lld\n", sum);
    	printf("serial time = %d\n", (t2-t1));
    
    	system("pause");
    	return 0;
    }


    转载于:https://my.oschina.net/u/1017188/blog/333515

    展开全文
  • 并行计算导论

    2016-06-18 20:01:19
    本书是并行计算,特别是分布式并行计算环境和消息传递并行编程的入门教材,目的是促进并行计算技术在我国的应用。书中介绍了并行计算的基础知识Linux/UNIX的基本使用、基于Linux机群的并行计算平台的 建立、并行...
  • .NET并行库测试实例

    千次阅读 2009-03-04 20:31:00
    .NET并行库测试实例并行库存应用场景: 并行计算首要目的是提高CPU的计算能力,简单说程序应该是以CPU密集型运算为主的,如果你的程序是IO(磁盘和网络)密集型运算,并行计算并不能对你的程序有多大的提高。...

    .NET并行库测试实例

    并行库存应用场景:
     并行计算首要目的是提高CPU的计算能力,简单说程序应该是以CPU密集型运算为主的,如果你的程序
    是IO(磁盘和网络)密集型运算,并行计算并不能对你的程序有多大的提高。有时反而会有影响。我们
    还是以事实来说话:


    namespace ParallelTest
    {
        static class Program
        {
            static void Compute(int i)
            {
                Thread.Sleep(20);
            }
            [STAThread]
            static void Main()
            {
                DateTime start = DateTime.Now;


                for(int i=0;i<100;i++){
                    Compute(i);
                }

                TimeSpan ts = DateTime.Now - start;
                System.Console.WriteLine("TotalMilliseconds is : {0}",ts.TotalMilliseconds);
            }
        }
    }

    我们用Thread.Sleep(20);来模拟一个CPU密集型运算,它只和CPU调度有关,不存在IO运算。这个传统的程序
    在我的Pentium D 300的机器上跑的时间是3125ms,理论上它应该是2000,但那上方法内运行的代码所占用的时间,
    方法帧的生成,CPU的调度都是额外的时间开销,所以这个程序跑了3125ms.这是我运行20次得到的相同的时间
    (当然也就是平均时间了)。

    现在我们用并行代码来运行这个程序:
               
    namespace ParallelTest
    {
        static class Program
        {
            static void Compute(int i)
            {
                Thread.Sleep(20);
            }
            [STAThread]
            static void Main()
            {
                DateTime start = DateTime.Now;
        
        
         Parallel.For(0, 100, delegate(int i) {  Compute(i); });

               
         TimeSpan ts = DateTime.Now - start;
                System.Console.WriteLine("TotalMilliseconds is : {0}",ts.TotalMilliseconds);
            }
        }
    }

    这些我运行20次,它们的时间大多数时候是相同的,有十多次是1093.75,同时还有1109.375,1140.625,
    1081.175之类的时间,总之它们的平均时间比3125少了几乎是两倍,也就是两个CPU运行方法中代码的时间应该
    为1000ms,而方法帧生成,CPU调度只占用实际代执行的1/10左右。

    更强的是当我把Sleep(20)改成Sleep(50)时,我们知道两个CPU执行100次应该至少2500ms,但实际上这个平均值是
    2063.75ms,说明并代码并不只是两个CPU的两个线程在运行,一定还利用超线程/纤程等技术。而非并行代码运行
    的时间是6250ms,没有任何让人惊喜的地方。


    下面我们再来来看一下本地IO的例子。

    我把我的一个目录从E分区复制到D分区,目录是一个图片库存,两级子目录,其中都是平时用到的图片和一些不可
    告人(别揭发我啊)的图片按类型分类的。

    我们先用传统的编程方式来实现:
     
    namespace ParallelTest
    {

        static class Program
        {

            static void CopyDir(DirectoryInfo s, DirectoryInfo d)
            {
                if (!d.Exists)
                    d.Create();
                foreach (DirectoryInfo sd in s.GetDirectories()) {
                    CopyDir(sd, new DirectoryInfo(Path.Combine(d.FullName,sd.Name)));
                }
                foreach (FileInfo f in s.GetFiles()) {
                    f.CopyTo(new FileInfo(Path.Combine(d.FullName,f.Name)).FullName);
                }
               
            }

            [STAThread]
            static void Main()
            {
                DateTime start = DateTime.Now;

                CopyDir(new DirectoryInfo("E://BigTools//lspic"),new DirectoryInfo("d://"));

                TimeSpan ts = DateTime.Now - start;
                System.Console.WriteLine("times is : {0}",ts.TotalMilliseconds);
               
            }
        }
    }
    这段代码打印的时间是 75187.5ms.
    改用并行代码:

    namespace ParallelTest
    {

        static class Program
        {

            private static void CopyDir(DirectoryInfo s, DirectoryInfo d)
            {
                if (!d.Exists)
                    d.Create();
                Parallel.Invoke(
                    () =>
                    {
                        Parallel.ForEach(s.GetFiles(), f =>
                        {
                            var t = new FileInfo(Path.Combine(d.FullName, f.Name));
                            f.CopyTo(t.FullName);

                        });
                    },
                    () =>
                    {
                        Parallel.ForEach(s.GetDirectories(), subs =>
                        {
                            var subd = new DirectoryInfo(Path.Combine(d.FullName, subs.Name));
                            CopyDir(subs, subd);
                        });
                    });
            }

            [STAThread]
            static void Main()
            {
                DateTime start = DateTime.Now;

                CopyDir(new DirectoryInfo("E://BigTools//lspic"),new DirectoryInfo("d://"));

                TimeSpan ts = DateTime.Now - start;
                System.Console.WriteLine("times is : {0}",ts.TotalMilliseconds);
               
            }
        }
    }


    结果时间只用了33187.5ms,我们看这段程序的两个分支都在并行执行,首先把当前目录中文件和子目录的处理
    作为两个匿名方法分配给Parallel.Invoke()方法来并行处理,然后在其中的循环又分别使用并行代码来执行。
    时间节省了一倍多。


    但是,这并不是真正的IO密集型运算。因为图片文件都在几十k左右,生成C#的目录对象和文件对象本身花的时间
    和真正的IO读写的时间比例没有拉开。也就是IO操作还没到饱和。所以并行代码不仅充分利用了CPU,也大大利用
    了IO性能。

    但当我在另一个目录中放入6个600M左右(Myeclipse7.2的安装文件改名后复制)的文件时,结果就明显了:
    非并行代码:231453.125ms,并行代码:573453.125ms.
    令人吃惊的是并行代码不但不能提高程序的性能,反而极大地影响性能。无论人多少CPU在工作,磁盘IO的吞吐量是
    有限的。而过多的并行操作反而增加了切换的频度,使IO操作本身增加了大量的OverHead.

    当并行代码的程序正在运行的时候,我看了一下目标盘同时生成了四个文件,证明了我上面使用超线程或纤程的
    猜想,但我的CPU在系统属性中无法看出支持超线程。

    如果你亲手试一下这个例子,6个文件正好说明问题。当运行并行代码时,同时有四个线程(或纤程)在运行,因为
    刚开运行时目录盘下立即产生四个文件,然后磁盘不停地嘎嘎嘎嘎响,但时间比四个文件单线程执行要多好久。大约在
    450000ms才执行完成,然后余下的两个文件同样在并行代码下COPY,时间不很短。说明并行代码在多并发情况下,对密
    集型IO操作不但不能提高性能,还大量浪费环境切换的开销。而实际有多少个并发,目前的并行库还不能控制。
    即使只有两个文件,非并行代码和并行代码执行的时间分别为73890.625ms,168343.75ms。并行代码多花了一倍多的时间。


    真正的本地IO操作C#代码下运行不可能很快,因为它没有DMA通道的支持,从托管代码到系统调用,每一次COPY一定数量的
    字节都必须经过5次内核模式/用户模式的上下文切换和3次读缓冲/应用程序内存/写缓冲的复制。解决密集型IO的方案应该
    是IO的并行吞吐能力和ZeorCopy之类的DMA通道才是首选,如java的FileChannel可以直接transferTo到一个输出流,比如
    网络IO这样在文件和网络IO之间直接建立DMA通道而不需要反复切换和COPY。

    所以,任何技术都有它的合适应用场景,比如在一个CPU的机器上单线程无IO操作运算肯定要比多线程还要快,因为无论如何
    同时只有一个线程运行,如果没有IO阻塞,多线程反而增加线程调度的开销。并行编程也同样,主要看我们具体的执行逻辑,
    根据具体的情况选择适当的技术。

     

    展开全文
  • 并行计算导论 pdf

    热门讨论 2011-01-11 13:00:55
    编程的入门教材,目的是促进并行计算技术在我国的应用。书中介 绍了并行计算的基础知识、Linux/UNIX 的基本使用、基于Linux 机 群的并行计算平台的建立、并行算法的设计和MPI 消息传递并行编 程的基本概念与方法。书...
  • 分析了将 GPU 并行计算技术用于通用计算的可行性 , 简要介绍 CUDA 架构编程 , 并以一个应用实例对 GPU 并行计算的性能进行了验证 , 测试表明 GPU 加速通用计算的优良性能 , 最后总结了 GPU 并行计算技术的运用模式。
  • 根据交通网络仿真的并行特征采用域分解方法设计交通并行仿真系统的框架,把交通网络...同时,在基于MPI 的并行计算平台上实现设计的并行仿真系统。通过实例表明,提出的并行算法能大大提高交通网络仿真的速度和效率。
  • https://msdn.microsoft.com/zh-cn/ff652648.aspx 图像处理——并行计算应用实例 http://blog.csdn.net/bitfan/article/details/4713872 http://www.cnblogs.com/xiangism/category/375725.html
    展开全文
  • 在注射成形模拟研究过程中,涉及材料的牛顿和非牛顿黏性流动模拟和注射成形后期的冷却过程模拟,以及随时间...重点阐述如何构建一个用于并行计算的PC集群系统,结合实例阐明MPI的实现方法,以及对PC集群系统进行了性
  • 前言:现在的电脑普遍进入多核时代,当我们需要做一些计算密集型任务时,运用并行计算能够发挥CPU的性能,也够大大的节省我们的时间。在现在的数据挖掘中,Python是一门非常强大的语言,语法直接明了,易于上手。...

    前言:

    现在的电脑普遍进入多核时代,当我们需要做一些计算密集型任务时,运用并行计算能够发挥CPU的性能,也够大大的节省我们的时间。在现在的数据挖掘中,Python是一门非常强大的语言,语法直接明了,易于上手。今天我们就用Python的Multiprocessing库来做个简单的应用实例分析。

    1. 简单的背景介绍

    1.1 数据处理目标

    首先笔者有很多的图像数据需要处理,例如Fig.1 所示。数据处理目标是获取背景面板上水位数据,采用的方法是OpenCV的。篇幅有限(笔者太懒),本文就不介绍具体的实现过程,在代码中封装为img_processing 函数,输入参数为文件名,输出为水位及相关的时间戳等数据。

    Fig. 1 原始图片实例

    1.2 Multiprocessing的实现方法

    由于笔者有较多的数据,约32000张图片,数据处理时间较长。同时鉴于笔者的工作电脑CPU为8核,内存为32GB,笔者计划采用多进程的方法来加速计算。在本文中主要用到了Multiprocessing的Pool方法,具体的介绍可见多进程-廖雪峰的官方网站。

    另外,为了测试与比较不同CPU核数的工作效率,笔者将多进程方法封装为multiProcessingTest函数,输入参数为CPU核数与图片文件数量,输出为对应的代码工作时间。详细代码如下所示:

    def multiProcessingTest(coreNum,filenameList):

    # 测试不同CPU核数和图片数量下的消耗时间。

    # cores from 1 to 8

    # 图片数量: selected numbers range from 1 to 30000. start_time = time.time()

    p = Pool(coreNum) # cores from 1 to 8

    results = p.map(img_processing, filenameList)

    p.close()

    p.join()

    callapsTime = time.time() - start_time

    return callapsTime

    2. 结果与分析

    Fig. 2 展示了不同图片文件数量下,不同CPU核数的计算消耗时间。由图可见,随着文件数量的增加,单核(即Core 1)消耗的时间剧烈增加:1000图片时,消耗时间在10s以内;到50,000图片时,时间增加到187s;300,000图片时,消耗时间长达5300.2s,约1.47小时。

    Fig. 2 Collapsed time at different cores and file sizes

    如果我们采用多核并行计算,消耗时间大大减少。Fig. 1 可以看出多核计算时面积明显小于单核计算的面积,并且CPU核数越多,消耗的时间越少。例如,当我们有100,000图片文件时,单核计算需要403.4s,双核需要268.7s,4核需要158.4s,而8核仅需100.8s。

    通过计算8核消耗时间与单核时间的百分比,见图3, 我们发现一个有趣的现象。大量数据时,例如30,000个文件,8核消耗的时间仅占单核的5.2%,即8核能够节省至少94%的计算时间。但是,当文件数量较少时,例如1000个图片文件,8核反而消耗了更多的时间。这个是因为系统将任务分配也需要一定的资源,当文件数量较少时,分配任务的时间占比重较大,反而真正计算的时间相对较少,所以CPU核数多消耗的时间更多。因此,我们也能得出结论,并不是CPU越多效率越高。

    Fig. 3 Percentile of collpased time of 8 cores over 1 core at different image file sizes

    如果并不是CPU核数越多效率越高,那么在大量图片文件时,多少CPU的效率最高呢?我们同样可以计算, 在300,000个文件下,平均每个CPU核数的速度(file processing per second per core),如Fig.4 所示。我们可以看出在双核时单个CPU的效率最高,随着CPU核数的增多,速度稍有降低。个人猜测,由于系统分配任务消耗的资源随CPU核数的增加而增加,当核数较多时,分配任务消耗的资源更大,某种程度上拖慢了CPU的工作效率。但是,需要注意的是,核数较多时,整体速度还是更快的,消耗的资源也更多。如何取舍效率与速度,需要读者朋友们自己斟酌了。

    Fig. 4 Image processing speed per CPU core

    3. Take-home pointsPython 可以用简单的代码引入多进程计算,大大降低计算密集型算法消耗的时间;

    核数越多并不代表速度越快,数据量的大小是重要的参考因素;

    在大量数据背景下,双核效率最高,核数越多速度越快,效率与速度的抉择需要读者自己取舍。

    Thanks for reading.

    PS:笔者为Python爱好者,对Python了解并没有特别深入,如有不足之处,欢迎指出,敬请谅解。

    展开全文
  • 针对这一问题,提出了一种新的基于MPI的伪谱法大涡模拟的并行计算方法。通过实例验证,该方法准确、易行、稳健,并且可以大幅提高计算速度,节省计算时间,这对大涡模拟在工程中的广泛应用具有重要意义。
  • 《云计算的关键技术与应用实例》从并行计算切入,以全新的视角全面讲述了云计算技术,主要内容包括并行计算技术、云计算的关键技术、架构及实例、云计算与智能、云计算技术的竞争性分析等内容。书中针对云计算中的...
  • 将二级模型与思维进化机器学习以及空间分解技术相结合(思维进化与空间分解并行演化计算-PMEBML-SP),采用多种通信模型实现处理器间负载均衡、支持网格动态资源分配等功能,最后在上海高校网格E网格计算应用平台上...
  • 腾讯云服务器异构计算实例规格包AMD...异构计算实例搭载 GPU、FPGA 等异构硬件,具有实时高速的并行计算和浮点计算能力,适合于深度学习、科学计算、视频编解码和图形工作站等高性能应用。 说白了这款机型比较特殊,...
  • 本书系统介绍涉及并行计算的体系结构、编程范例、算法与应用和标准等。覆盖了并行计算领域的传统问题,并且尽可能地采用与底层平台无关的体系结构和针对抽象模型来设计算法。书中选择MPI(Message Passing Interface)...
  • 《云计算的关键技术与应用实例》从并行计算切入,以全新的视角全面讲述了云计算技术,主要内容包括并行计算技术、云计算的关键技术、架构及实例、云计算与智能、云计算技术的竞争性分析等内容。《云计算的关键技术与...
  • 作者: digoal日期: 2016-10-02标签: PostgreSQL , 9.6 , 并行计算 , 多核计算 , xfs , ext4背景ext4在红帽5,6的版本中作为主流的文件系统,有非常多的用户群体,也能满足大多数的应用场景需求。XFS经过几年的发展,...
  • 进程是操作系统中正在执行的不同应用程序的一个实例 线程是进程中的一个实体,是被操作系统独立调度和分派处理器时间的基本单位 线程的优缺点 并发处理,因而特别适合需要同时执行多个操作的场合 解决用户响应性能和...
  • 腾讯云服务器异构计算实例规格包AMD...异构计算实例搭载 GPU、FPGA 等异构硬件,具有实时高速的并行计算和浮点计算能力,适合于深度学习、科学计算、视频编解码和图形工作站等高性能应用。 说白了这款机型比较特殊,...
  • 云计算的关键技术与应用实例/王鹏著. 本书从并行计算切入,以全新的视角全面讲述了云计算技术,主要内容包括并行计算技术、云计算的关键技术、架构及实例、云计算与智能、云计算技术的竞争性分析等内容。 北京:人民...
  • 云计算的关键技术与应用实例/王鹏著.—北京:人民邮电出版社,2010  235页;24cm+光盘1片  附光盘:ISBN 978-7-89479-797-1 本书从并行计算切入,以全新的视角全面讲述了云计算技术,主要内容包括并行计算技术、...
  • 云计算的关键技术与应用实例/王鹏著.—北京:人民邮电出版社,2010  235页;24cm+光盘1片    附光盘:ISBN 978-7-89479-797-1  本书从并行计算切入,以全新的视角全面讲述了云计算技术,主要内容包括并行计算技术...

空空如也

空空如也

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

并行计算应用实例