C#/C++/Fortran 在32位/64位下数学计算性能对比-程序员宅基地

测试平台

在我的上一篇博客中对比了VS2010中C#和C++在运算密集型程序中的性能。上一篇博客的链接：

http://www.cnblogs.com/ytyt2002ytyt/archive/2011/11/24/2261104.html

当时是在AMD 速龙9650 CPU(4核心)下的测试结果。

 

随着VS2012、Intel Parallel Studio XE 2013中新一代编译器的发布，再测试一下VC11编译器相对于VC10的提升，以及.net4.5 .net4.0对C#的性能区别。Fortran则使用了最新的 Intel Parallel Studio XE 2013。另外Fortran作为老牌的科学计算语言，也试图重点测试一下相对于现代主流编程语言C++和C#在性能上的差异。Fortran作为汇编后最早诞生的编程语言，其矩阵运算非常方便，几十年间长期占据了性能上的宝座。Fortran 90/95、Fortran2003/2008 又加入大量现代语言特性，在20年前就内置了并行化的支持。

 

测试平台：

CPU Intel Xeon E3 1230v2 3.5G 4核8线程

Win7 64bit

编译器：

C++          VC11(VS2012)

Fortran      Intel Parallel Studio XE 2013

C#           .net4.0 .net4.5

 

测试代码

不过为了公平起见，下列的测试中只使用了一个线程，没有并行化，也没有矩阵运算，均为默认参数编译。

C#和C++代码和之前的测试程序一样

C++代码：

#include <stdio.h> 
#include <stdlib.h> 
#include <time.h> 
#include <math.h> 

//为cin cout 提供
#include <iostream>
using namespace std;

#define INTEG_FUNC(x) fabs(sin(x)) //计算公式

double dclock(void); 

int main(void) 
{ 
	unsigned int i, j, N; 
	double step, x_i, sum; 
	double start, finish, duration, clock_t; 
	double interval_begin = 0.0; 
	double interval_end = 2.0 * 3.141592653589793238; 

	start = clock(); //初始时间

	printf(" \n"); 
	printf(" Number of中文 | Computed Integral | \n"); //Win7下中文显示正常
	printf(" Interior Points | | \n"); 

	for (j=2;j<27;j++) 
	{  
		N = 1 << j;

		step = (interval_end - interval_begin) / N; 
		sum = INTEG_FUNC(interval_begin) * step / 2.0; 

		for (i=1;i<N;i++) 
		{ 
			x_i = i * step; 
			sum += INTEG_FUNC(x_i) * step; 
		} 

		sum += INTEG_FUNC(interval_end) * step / 2.0; 

		//printf(" %10d | %14e | \n", N, sum); 
		printf(" %14e  \n", sum); 
	} 

	finish = clock(); //结束时间
	duration = (finish - start); 
	printf(" \n"); 
	printf(" time = %10e \n", duration); 
	printf(" \n"); 

	int tempA;
	cin>>tempA;

	return 0; 
}

C#代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            int time = System.Environment.TickCount;  //添加计时器

            #region
            int i, j, N;
            double step, x_i, sum;
            double start, finish, duration, clock_t;
            double interval_begin = 0.0;
            double interval_end = 2.0 * 3.141592653589793238;

            for (j = 2; j < 27; j++)
            {
                N = 1 << j;
                step = (interval_end - interval_begin) / N;
                sum = Math.Abs(Math.Sin(interval_begin)) * step / 2.0;

                for (i = 1; i < N; i++)
                {
                    x_i = i * step;
                    sum += Math.Abs(Math.Sin(x_i)) * step;
                }

                sum += Math.Abs(Math.Sin(interval_end)) * step / 2.0;
                Console.Write(sum.ToString() + "\r\n");
            }

            Console.Write((System.Environment.TickCount - time).ToString());
            Console.ReadLine();
            #endregion
        }
    }
}

 

Fortran代码：

 

program ForAllProgram
	implicit none
	real(8) :: time1,time2
	integer :: i,j,k,N
	real(8) :: step, x_i, s
	real(8) :: interval_begin = 0.0
	real(8) :: interval_end = 2.0 * 3.141592653589793238
	real, allocatable :: ArrySum(:)	!          
	
	call CPU_TIME(time1)
	do j = 2, 26
		N=2**j !N = 1 << j;  位操作用乘方操作代替
		step = (interval_end - interval_begin) / N;
        s = Abs(Sin(interval_begin)) * step / 2.0;
				
		do i = 1, N-1 !这里对应于C++的<N是N-1
			x_i = i * step;
            s =s+ Abs(Sin(x_i)) * step;
		end do
		s =s+ Abs(Sin(interval_end)) * step / 2.0;
		print *, s
	end do
	call CPU_TIME(time2)
	print *,time2-time1
	
end program

注意Fortran中用乘方代替了位操作，另外Do循环到N-1对应于C++中的<N

 

测试结果

 

时间单位：毫秒

时间单位：毫秒 越小越好

测试结论

C#在.net 4.5 和.net 4.0相比，性能只是在.net4.5的32bit中略有提升。奇怪的是.net4.5中，32bit的性能居然高于64bit的性能。

C++ 在VS2012比VS2010有了显著的提升，微软的C++CX 性能可能和Intel的C++性能相近了。64bit性能显著高于32bit性能。

Fortran在运算密集型的问题中，性能极其恐怖，甚至超常我原本的想象。未加任何优化，性能超过C++的3倍，是C#的5-6倍。数值计算的王者看了还是非Fortran莫属。如此高的性能可能是因为：默认即可充分利用到Simd向量化(本机的AVX指令集)。而C++即使启用了Intel的向量化编译(Intel默认是启用的)，因为复杂的语法也很难充分实现自动向量化。需要加入向量化编译指令，如#program simd 等，甚至需要手工编码向量化(如OpenCV中的优化实现)。这样程序优化的工作量和程序复杂度将会大为提升。

可见进行大规模科学计算，Fortran仍然是最适合的选择，再加上大量现存的数学计算类库都是由Fortran编写，语法也相对简单，确实是数值计算的绝配。

C++在与系统底层交互中则有先天的优势；C#适合表现层开发和整体架构设计，最为便捷优雅。

 

展望

下一篇将继续测试CPU并行化以及GPU加速的性能。根据以往的经验，GTX460级别的显卡在float类型的计算中，优化后能达到CPU单线程的10-20倍性能。但考虑到CPU多核心并行后，以及Fortran向量化恐怖的性能，估计最终GPU的优势不会那么大，可能只有2-3倍的优势吧。对于双精度计算，由于桌面级显卡的双精度只有单精度的1/8（tesla运算卡是1/2,但价格昂贵，最新的开普勒110架构tesla k20 和Titans则是1/3,理论双精度超过1T ），所以估计费米核心tesla双精度也只能达到8线程CPU并行的2-3被，开普勒或许能更高些。不过这些只是推测，待到下次测试后才能见分晓。

 

本文地址： 杨韬的学习备忘录 http://www.cnblogs.com/ytyt2002ytyt/archive/2013/04/02/2996718.html