我有一个应用程序，我必须在多线程方法中增加一些统计计数器。递增必须是线程安全的，所以我决定使用gcc atomic builtins __sync_add_and_fetch()函数。为了了解它们的影响，我做了一些简单的性能测试，发现这些函数比简单的前/后递增慢得多。
这是我创建的测试程序：
#include <iostream>
#include <pthread.h>
#include <time.h>
using namespace std;
uint64_t diffTimes(struct timespec &start, struct timespec &end)
{
if(start.tv_sec == end.tv_sec)
{
return end.tv_nsec - start.tv_nsec;
}
else if(start.tv_sec < end.tv_sec)
{
uint64_t nsecs = (end.tv_sec - start.tv_sec) * 1000000000;
return nsecs + end.tv_nsec - start.tv_nsec;
}
else
{
// this is actually an error
return 0;
}
}
void outputResult(const char *msg, struct timespec &start, struct timespec &end, uint32_t numIterations, uint64_t val)
{
uint64_t diff = diffTimes(start, end);
cout << msg << ": "
<< "\n\t iterations: " << numIterations
<< ", result: " << val
<< "\n\t times [start, end] = [" << start.tv_sec << ", " << start.tv_nsec << "]"
<< "\n\t [" << end.tv_sec << ", " << end.tv_nsec << "]"
<< "\n\t [total, avg] = [" << diff
<< ", " << (diff/numIterations) << "] nano seconds"
<< endl;
}
int main(int argc, char **argv)
{
struct timespec start, end;
uint64_t val = 0;
uint32_t numIterations = 1000000;
//
// NON ATOMIC pre increment
//
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
for(uint32_t i = 0; i < numIterations; ++i)
{
++val;
}
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
outputResult("Non-Atomic pre-increment", start, end, numIterations, val);
val = 0;
//
// NON ATOMIC post increment
//
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
for(uint32_t i = 0; i < numIterations; ++i)
{
val++;
}
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
outputResult("Non-Atomic post-increment", start, end, numIterations, val);
val = 0;
//
// ATOMIC add and fetch
//
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
for(uint32_t i = 0; i < numIterations; ++i)
{
__sync_add_and_fetch(&val, 1);
}
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
outputResult("Atomic add and fetch", start, end, numIterations, val);
val = 0;
//
// ATOMIC fetch and add
//
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
for(uint32_t i = 0; i < numIterations; ++i)
{
__sync_fetch_and_add(&val, 1);
}
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
outputResult("Atomic fetch and add", start, end, numIterations, val);
val = 0;
//
// Mutex protected post-increment
//
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
for(uint32_t i = 0; i < numIterations; ++i)
{
pthread_mutex_lock(&mutex);
val++;
pthread_mutex_unlock(&mutex);
}
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
outputResult("Mutex post-increment", start, end, numIterations, val);
val = 0;
//
// RWlock protected post-increment
//
pthread_rwlock_t rwlock;
pthread_rwlock_init(&rwlock, NULL);
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
for(uint32_t i = 0; i < numIterations; ++i)
{
pthread_rwlock_wrlock(&rwlock);
val++;
pthread_rwlock_unlock(&rwlock);
}
clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end);
outputResult("RWlock post-increment", start, end, numIterations, val);
val = 0;
return 0;
}
以下是结果：
# ./atomicVsNonAtomic
Non-Atomic pre-increment:
iterations: 1000000, result: 1000000
times [start, end] = [0, 1585375]
[0, 1586185]
[total, avg] = [810, 0] nano seconds
Non-Atomic post-increment:
iterations: 1000000, result: 1000000
times [start, end] = [0, 1667489]
[0, 1667920]
[total, avg] = [431, 0] nano seconds
Atomic add and fetch:
iterations: 1000000, result: 1000000
times [start, end] = [0, 1682037]
[0, 16595016]
[total, avg] = [14912979, 14] nano seconds
Atomic fetch and add:
iterations: 1000000, result: 1000000
times [start, end] = [0, 16617178]
[0, 31499571]
[total, avg] = [14882393, 14] nano seconds
Mutex post-increment:
iterations: 1000000, result: 1000000
times [start, end] = [0, 31526810]
[0, 68515763]
[total, avg] = [36988953, 36] nano seconds
RWlock post-increment:
iterations: 1000000, result: 1000000
times [start, end] = [0, 68547649]
[0, 110877351]
[total, avg] = [42329702, 42] nano seconds
这是gcc编译：
g++ -o atomicVsNonAtomic.o -c -march=i686 -O2 -I. atomicVsNonAtomic.cc
g++ -o atomicVsNonAtomic atomicVsNonAtomic.o -lrt -lpthread
相关信息和版本：
# gcc --version
gcc (GCC) 4.3.2
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
# uname -a
Linux gtcba2v1 2.6.32.12-0.7-default #1 SMP 2010-05-20 11:14:20 +0200 i686 i686 i386 GNU/Linux
现在对于实际问题:)原子操作速度慢得多是正常的吗？
一百万次迭代的差异是：
当然我理解原子操作应该更昂贵，但这似乎有点夸张。为了完整起见，我还检查了一个pthread互斥锁和rwlock。至少原子操作比pthread操作快，但我仍然想知道我是否做错了什么。我无法在没有指定-march=i686选项的情况下进行链接，这可能会产生影响吗？
的更新： 的
我取出了-O2编译器优化，并且能够获得更一致的结果，如下所示：
# ./atomicVsNonAtomic
Non-Atomic pre-increment:
iterations: 1000000, result: 1000000
times [start, end] = [0, 1647303]
[0, 4171164]
[total, avg] = [2523861, 2] nano seconds
Non-Atomic post-increment:
iterations: 1000000, result: 1000000
times [start, end] = [0, 4310230]
[0, 7262704]
[total, avg] = [2952474, 2] nano seconds
Atomic add and fetch:
iterations: 1000000, result: 1000000
times [start, end] = [0, 7285996]
[0, 25919067]
[total, avg] = [18633071, 18] nano seconds
Atomic fetch and add:
iterations: 1000000, result: 1000000
times [start, end] = [0, 25941677]
[0, 44544234]
[total, avg] = [18602557, 18] nano seconds
Mutex post-increment:
iterations: 1000000, result: 1000000
times [start, end] = [0, 44573933]
[0, 82318615]
[total, avg] = [37744682, 37] nano seconds
RWlock post-increment:
iterations: 1000000, result: 1000000
times [start, end] = [0, 82344866]
[0, 125124498]
[total, avg] = [42779632, 42] nano seconds
答案 0 :(得分：19)
答案是GCC优化你的非原子增量。当它看到如下的循环时：
for (int i=0; i<N; i++) x++;
它取代它：
x += N;
这可以在生成的程序集中看到，其中包含：
call clock_gettime
leal -32(%ebp), %edx
addl $1000000, -40(%ebp) <- increment by 1000000
adcl $0, -36(%ebp)
movl %edx, 4(%esp)
movl $2, (%esp)
call clock_gettime
所以你没有衡量你的想法。
您可以设置变量volatile以阻止此优化。在我的计算机上，执行此操作后，非原子访问速度大约是原子访问速度的8倍。当使用32位变量而不是64位（我正在编译为32位）时，差异将下降到大约3倍。
答案 1 :(得分：6)
我猜测gcc正在优化你的非原子增量操作，如
val += numIterations;
你说10 ^ 6增量需要431纳秒，每循环迭代可以达到0.000431 ns。在4 GHz处理器上，时钟周期为0.25 ns，因此非常明显地将环路优化掉了。这解释了您所看到的巨大性能差异。
编辑：您测量的原子操作耗时14 ns - 假设再次使用4 GHz处理器，可以达到56个周期，这非常不错！
答案 2 :(得分：1)
任何同步机制的缓慢都无法通过单个线程来测量。像POSIX互斥锁/ Windows关键部分这样的单进程同步对象只有在竞争时才真正花费时间。
您必须引入几个线程 - 执行其他工作，这些工作反映了您的实际应用程序的时间 - 使同步方法能够真正了解所需的时间。