OpenMP创建线程中的锁及原子操作性能比较

开发 前端
在多核CPU中锁竞争到底会造成性能怎样的下降呢?相信这是许多人想了解的,因此特地写了一个测试程序来测试原子操作,windows CriticalSection, OpenMP的锁操作函数在多核CPU中的性能。

在多核CPU中锁竞争到底会造成性能怎样的下降呢?相信这是许多人想了解的,因此特地写了一个测试程序来测试原子操作,windows CriticalSection, OpenMP的锁操作函数在多核CPU中的性能。

原子操作选用InterlockedIncrement来进行测试,

对每种锁和原子操作,都测试在单任务执行和多任务执行2000000次加锁解锁操作所消耗的时间。

测试的详细代码见后面。

测试机器环境: Intel 2.66G 双核CPU 机器一台

测试运行结果如下:

SingleThread, InterlockedIncrement 2,000,000: a = 2000000, time = 78

MultiThread, InterlockedIncrement 2,000,000: a = 2000000, time = 156

SingleThread, Critical_Section 2,000,000:a = 2000000, time = 172

MultiThread, Critical_Section, 2,000,000:a = 2000000, time = 3156

SingleThread,omp_lock 2,000,000:a = 2000000, time = 250

MultiThread,omp_lock 2,000,000:a = 2000000, time = 1063

在单任务运行情况下,所消耗的时间如下:

原子操作                 78ms

Windows CriticalSection 172ms

OpenMP 的lock操作        250ms

因此从单任务情况来看,原子操作最快,Windows CriticalSection次之,OpenMP库带的锁最慢,但这几种操作的时间差距不是很大,用锁操作比原子操作慢了2~3倍左右。

在多个任务运行的情况下,所消耗的时间如下:

原子操作                 156ms

Windows CriticalSection 3156ms

OpenMP 的lock操作        1063ms

在多任务运行情况下,情况发生了意想不到的变化,原子操作时间比单任务操作时慢了一倍,在两个CPU上运行比在单个CPU上运行还慢一倍,真是难以想象,估计是任务切换开销造成的。

Windows CriticalSection则更离谱了,居然花了3156ms,是单任务运行时的18倍多的时间,慢得简直无法想象。

OpenMP的lock操作比Windows CriticalSection稍微好一些,但也花了1063ms,是单任务时的7倍左右。

由此可以知道,在多核CPU的多任务环境中,原子操作是最快的,而OpenMP次之,Windows CriticalSection则最慢。

同时从这些锁在单任务和多任务下的性能差距可以看出,,多核CPU上的编程和以往的单核多任务编程会有很大的区别。

需要说明的是,本测试是一种极端情况下的测试,锁住的操作只是一个简单的加1操作,并且锁竞争次数达200万次之多,在实际情况中,一由于任务中还有很多不需要加锁的代码在运行,实际情况中的性能会比本测试的性能好很多。

测试代码如下:

  1. // TestLock.cpp : OpenMP任务中的原子操作和锁性能测试程序。 
  2. // 
  3.   
  4. #include <windows.h> 
  5. #include <time.h> 
  6. #include <process.h> 
  7. #include <omp.h> 
  8. #include <stdio.h> 
  9.   
  10. void TestAtomic() 
  11.      clock_t t1,t2; 
  12.      int      i = 0; 
  13.      volatile LONG      a = 0; 
  14.   
  15.      t1 = clock(); 
  16.   
  17.      for( i = 0; i < 2000000; i++ ) 
  18.      { 
  19.          InterlockedIncrement( &a); 
  20.      } 
  21.      
  22.      t2 = clock(); 
  23.      printf("SingleThread, InterlockedIncrement 2,000,000: a = %ld, time = %ld/n", a, t2-t1); 
  24.   
  25.      t1 = clock(); 
  26.   
  27. #pragma omp parallel for 
  28.      for( i = 0; i < 2000000; i++ ) 
  29.      { 
  30.          InterlockedIncrement( &a); 
  31.      } 
  32.      
  33.      t2 = clock(); 
  34.      printf("MultiThread, InterlockedIncrement 2,000,000: a = %ld, time = %ld/n", a, t2-t1); 
  35.   
  36. void TestOmpLock() 
  37.      clock_t t1,t2; 
  38.      int i; 
  39.      int a = 0; 
  40.      omp_lock_t    mylock; 
  41.   
  42.      omp_init_lock(&mylock); 
  43.   
  44.      t1 = clock(); 
  45.   
  46.      for( i = 0; i < 2000000; i++ ) 
  47.      { 
  48.          omp_set_lock(&mylock); 
  49.          a+=1; 
  50.          omp_unset_lock(&mylock); 
  51.      } 
  52.      t2 = clock(); 
  53.      
  54.      printf("SingleThread,omp_lock 2,000,000:a = %ld, time = %ld/n", a, t2-t1); 
  55.   
  56.      t1 = clock(); 
  57.   
  58. #pragma omp parallel for 
  59.      for( i = 0; i < 2000000; i++ ) 
  60.      { 
  61.          omp_set_lock(&mylock); 
  62.          a+=1; 
  63.          omp_unset_lock(&mylock); 
  64.      } 
  65.      t2 = clock(); 
  66.      
  67.      printf("MultiThread,omp_lock 2,000,000:a = %ld, time = %ld/n", a, t2-t1); 
  68.   
  69.      omp_destroy_lock(&mylock); 
  70.   
  71.   
  72.   
  73. void TestCriticalSection() 
  74.      clock_t t1,t2; 
  75.      int i; 
  76.      int a = 0; 
  77.      CRITICAL_SECTION   cs; 
  78.   
  79.      InitializeCriticalSection(&cs); 
  80.   
  81.      t1 = clock(); 
  82.   
  83.      for( i = 0; i < 2000000; i++ ) 
  84.      { 
  85.          EnterCriticalSection(&cs); 
  86.          a+=1; 
  87.          LeaveCriticalSection(&cs); 
  88.      } 
  89.      t2 = clock(); 
  90.   
  91.      printf("SingleThread, Critical_Section 2,000,000:a = %ld, time = %ld/n", a, t2-t1); 
  92.   
  93.      t1 = clock(); 
  94.   
  95. #pragma omp parallel for 
  96.      for( i = 0; i < 2000000; i++ ) 
  97.      { 
  98.          EnterCriticalSection(&cs); 
  99.          a+=1; 
  100.          LeaveCriticalSection(&cs); 
  101.      } 
  102.      t2 = clock(); 
  103.   
  104.      printf("MultiThread, Critical_Section, 2,000,000:a = %ld, time = %ld/n", a, t2-t1); 
  105.   
  106.      DeleteCriticalSection(&cs); 
  107.   
  108.   
  109. int main(int argc, char* argv[]) 
  110.   
  111.      TestAtomic(); 
  112.      TestCriticalSection(); 
  113.      TestOmpLock(); 
  114.   
  115.      return 0; 

原文链接:http://blog.csdn.net/drzhouweiming/article/details/1689853

责任编辑:陈四芳 来源: blog.csdn.net
相关推荐

2017-12-14 10:16:01

CaddySSLDockerNginx

2016-12-07 10:42:57

排序算法实例

2013-12-16 10:20:48

MySQL数据库

2011-04-15 10:26:38

JavaMVC

2009-05-25 08:39:08

iPhone苹果移动OS

2012-12-03 10:26:51

Scala

2009-07-01 18:12:18

JSP的优势性能比较

2011-08-09 10:21:55

SQL Server存储过程分页

2011-05-18 14:52:04

XML

2020-10-23 07:43:37

Log配置性能

2023-11-20 10:34:09

语言

2015-02-05 09:25:51

HTTPSSPDYHTTP2

2010-03-10 16:35:23

Python编程语言

2011-07-06 14:18:40

Percona SerMySQL

2020-07-27 08:24:42

编程语言C语言Java

2009-12-16 14:10:12

路由技术性能比较

2009-12-04 19:28:25

FreeBSD 8.0Ubuntu 9.10性能比较

2010-12-27 16:01:45

jQuery选择器

2023-11-19 21:17:58

GoRust

2014-08-20 09:49:50

虚拟机Linux Conta
点赞
收藏

51CTO技术栈公众号