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

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

创新互联建站专注于企业网络营销推广、网站重做改版、巢湖网站定制设计、自适应品牌网站建设、H5开发、商城网站建设、集团公司官网建设、外贸营销网站建设、高端网站制作、响应式网页设计等建站业务，价格优惠性价比高，为巢湖等各大城市提供网站开发制作服务。

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

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

新闻名称：OpenMP创建线程中的锁及原子操作性能比较
网页网址：http://www.csdahua.cn/qtweb/news5/491755.html

网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 快上网

成都快上网为您推荐相关内容

搜索引擎优化知识

同城分类信息

新都网站建设　　 　南部网站建设　　 　南充网站制作　　 　成都网站设计　　 　域名申请　　 　江油做网站　　 　全网营销　　 　郫县明安消防器材　　 　遂宁做网站　　 　温江网站设计　　 　景区导示设计制作　　 　绵阳服务器托管　　 　网站域名　　 　广汉锦华　　 　贵阳托管服务器　　 　成都免费做网站公司　　 　不锈钢防护栏　　 　重庆服务器托管　　 　帝美豪门窗　　 　卡多尼人工智