关于x86_64架构下atomic、mutex、rwlock的性能对比

1170阅读　0评论2014-09-23　embeddedlwp
分类：LINUX

这里以多线程操作long类型变量，进行加法运算1亿次的时间作为性能对比的标准。

测试使用SLES 11SP2操作系统，3.0.80内核，CPU使用Xeon 5506（2 socket, 4 cores, 1thread）

由于针对64位类型的atomic glibc没有提供相应的库，将内核实现代码移植到应用层
atomic64.h

点击(此处)折叠或打开

  1. #ifndef __HI_ATOMIC64_H__
  2. #define __HI_ATOMIC64_H__
  3. #include <stdio.h>
  4. #include <getopt.h>
  5. #include <limits.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <unistd.h>
  9. #include <pthread.h>
  10. #include <sys/time.h>
  11. #include <arpa/inet.h>
  12. #include <fcntl.h>
  13. #include <signal.h>
  14. #include <errno.h>
  15. #include <sys/time.h>



  19. /* Learn from kernel */
  20. #ifdef __x86_64__

  22. #define LOCK_PREFIX "lock ;"
  23. typedef struct {
  24.         long long counter;
  25. } atomic64_t;

  27. /**
  28.  * atomic64_read - read atomic64 variable
  29.  * @v: pointer of type atomic64_t
  30.  *
  31.  * Atomically reads the value of @v.
  32.  * Doesn't imply a read memory barrier.
  33.  */
  34. static inline long atomic64_read(const atomic64_t *v)
  35. {
  36.         return (*(volatile long *)&(v)->counter);
  37. }

  39. /**
  40.  * atomic64_set - set atomic64 variable
  41.  * @v: pointer to type atomic64_t
  42.  * @i: required value
  43.  *
  44.  * Atomically sets the value of @v to @i.
  45.  */
  46. static inline void atomic64_set(atomic64_t *v, long i)
  47. {
  48.         v->counter = i;
  49. }

  51. /**
  52.  * atomic64_add - add integer to atomic64 variable
  53.  * @i: integer value to add
  54.  * @v: pointer to type atomic64_t
  55.  *
  56.  * Atomically adds @i to @v.
  57.  */
  58. static inline void atomic64_add(long i, atomic64_t *v)
  59. {
  60.         asm volatile(LOCK_PREFIX "addq %1,%0"
  61.                      : "=m" (v->counter)
  62.                      : "er" (i), "m" (v->counter));
  63. }

  65. /**
  66.  * atomic64_sub - subtract the atomic64 variable
  67.  * @i: integer value to subtract
  68.  * @v: pointer to type atomic64_t
  69.  *
  70.  * Atomically subtracts @i from @v.
  71.  */
  72. static inline void atomic64_sub(long i, atomic64_t *v)
  73. {
  74.         asm volatile(LOCK_PREFIX "subq %1,%0"
  75.                      : "=m" (v->counter)
  76.                      : "er" (i), "m" (v->counter));
  77. }
  78. #else /* __x86_64__ */
  79. /*FIXME:
  80.  * This program will run on x86_64 machine in the expected future, we
  81.  * do _not_ need to care other cpu architecture.
  82.  */
  83. #endif

  85. #endif
测试代码performance.c

点击(此处)折叠或打开

  1. /*******************************************************************************

  3.   Copyright(c) 2008-2014

  5.   This program is free software; you can redistribute it and/or modify it
  6.   under the terms and conditions of the GNU General Public License,
  7.   version 2, as published by the Free Software Foundation.

  9.   This program is distributed in the hope it will be useful, but WITHOUT
  10.   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11.   FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  12.   more details.

  14.   You should have received a copy of the GNU General Public License along with
  15.   this program; if not, write to the Free Software Foundation, Inc.,
  16.   51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.

  18.   The full GNU General Public License is included in this distribution in
  19.   the file called "COPYING".


  22.   Date: 2014-04-15 21:27:57 CST

  24.   Contact Information:
  25.   Tony <tingw.liu@gmail.com>
  26.   Home, Qingdao, China.
  27. *******************************************************************************/



  31. #include "atomic64.h"

  33. atomic64_t num;
  34. long mutexnum = 0;
  35. long maxnum;

  37. struct timeval tv;
  38. long starttime;

  40. //FIXME: gettimeofday is a non-thread safe sysycall
  41. static pthread_mutex_t timelock = PTHREAD_MUTEX_INITIALIZER;
  42. #define TIME_LOCK() pthread_mutex_lock(&timelock)
  43. #define TIME_UNLOCK() pthread_mutex_unlock(&timelock)

  45. static pthread_mutex_t numlock = PTHREAD_MUTEX_INITIALIZER;
  46. #define MUTEX_LOCK() pthread_mutex_lock(&numlock)
  47. #define MUTEX_UNLOCK() pthread_mutex_unlock(&numlock)

  49. static pthread_rwlock_t rwnumlock = PTHREAD_RWLOCK_INITIALIZER;
  50. #define RW_LOCK() pthread_rwlock_wrlock(&rwnumlock)
  51. #define RW_UNLOCK() pthread_rwlock_unlock(&rwnumlock);

  53. static void * add_func(void *arg)
  54. {
  55.         long stoptime;
  56.         while(1) {
  57.                 atomic64_add(1, &num);
  58.                 if (atomic64_read(&num) > maxnum) {
  59.                         TIME_LOCK();
  60.                         gettimeofday(&tv, 0);
  61.                         TIME_UNLOCK();
  62.                         stoptime= (long)tv.tv_sec * (long)1000000 +
  63.                                 (long)tv.tv_usec;
  64.                         printf("Used %ld microseconds\n", stoptime - starttime);
  65.                         break;
  66.                 }
  67.         }
  68. }


  71. static void *add_func_rwlock(void *arg)
  72. {
  73.         long stoptime;
  74.         while(1) {

  76.                 RW_LOCK();
  77.                 ++mutexnum;
  78.                 if (mutexnum > maxnum) {
  79.                         RW_UNLOCK();
  80.                         TIME_LOCK();
  81.                         gettimeofday(&tv, 0);
  82.                         TIME_UNLOCK();
  83.                         stoptime= (long)tv.tv_sec * (long)1000000 +
  84.                                 (long)tv.tv_usec;
  85.                         printf("Used %ld microseconds\n", stoptime - starttime);
  86.                         break;
  87.                 }
  88.                 RW_UNLOCK();
  89.         }
  90. }

  92. static void *add_func_mutex(void *arg)
  93. {
  94.         long stoptime;
  95.         while(1) {

  97.                 MUTEX_LOCK();
  98.                 ++mutexnum;
  99.                 if (mutexnum > maxnum) {
  100.                         MUTEX_UNLOCK();
  101.                         TIME_LOCK();
  102.                         gettimeofday(&tv, 0);
  103.                         TIME_UNLOCK();
  104.                         stoptime= (long)tv.tv_sec * (long)1000000 +
  105.                                 (long)tv.tv_usec;
  106.                         printf("Used %ld microseconds\n", stoptime - starttime);
  107.                         break;
  108.                 }
  109.                 MUTEX_UNLOCK();
  110.         }
  111. }

  113. #define ATOMIC_TYPE 0
  114. #define MUTEX_TYPE 1
  115. #define RW_TYPE 2
  116. int main(int argc, char **argv)
  117. {
  118.         pthread_t thread;
  119.         pthread_attr_t thread_attr;
  120.         int threadnum, i, type;
  121.         if (argc != 4) {
  122.                 printf("Usage: %s threadnum maxnum type[0-atomic, 1-mutex, 2-rwlock]\n",
  123.                                 argv[0]);
  124.                 exit(0);
  125.         }
  126.         threadnum = atoi(argv[1]);
  127.         maxnum = atoll(argv[2]);
  128.         type = atoi(argv[3]);
  129.         printf("Use %d threads add num from 0 to %ld\n", threadnum, maxnum);
  130.         gettimeofday(&tv, 0);
  131.         starttime= (long)tv.tv_sec * (long)1000000 + (long)tv.tv_usec;

  133.         atomic64_set(&num, 0);
  134.         pthread_attr_init(&thread_attr);
  135.         //pthread_attr_setdetachstate(&thread_attr, PTHREAD_CREATE_DETACHED);
  136.         for (i = 0; i < threadnum; i++) {
  137.                 if (type == ATOMIC_TYPE)
  138.                         pthread_create(&thread, &thread_attr, add_func, 0);
  139.                 else if (type == MUTEX_TYPE)
  140.                         pthread_create(&thread, &thread_attr, add_func_mutex, 0);
  141.                 else if (type == RW_TYPE)
  142.                         pthread_create(&thread, &thread_attr, add_func_rwlock, 0);
  143.         }
  144.         while(1)
  145.                 sleep(10);
  146. }
运行结果这里就不详细列出来了，可以直接看这个曲线图。

横坐标是线程数，纵坐标是运算1亿次耗费的微秒数。
从这个图中可以看出，对于频繁写操作的情况atomic > mutex > rwlock
对于同一种同步类型，并不是随着线程数的增加而一直增加，不过因为只有8个核心，所以没有测试更多线程的情况。

欢迎转载，转载请注明出处：http://forever.blog.chinaunix.net


上一篇：ubuntu 12.04下如何将物理网卡加入bridge连接外网
下一篇：F2FS文件系统架构与原理分析(一)——设计背景与功能