Lock-free 多核数据结构设计
lock-free思想背景
基本的多核数据结构设计是非常简单的：只需要在并发处理同一数据结构时，加上locks就可以了。这种思想在并发数不是很多的情况下工作的很好。因为这时的资源争用开销并不是很大。
随着多核机器逐渐的变大变多，例如成百上千的核，这种加lock机制对此应用的不是很好:如果你只有几个锁,锁的争夺成为巨大的;如果你有许多细粒度的锁,锁的开销开始增加。
所以对于大型多核机器来说，“Lock-free”的设计非常常见。以下这些策略基本覆盖了这种设计思想：
1、我们不每次都是用lock，但只有当我们真的需要它们的时候（例如只写不读）；
2、我们不是每秒都用lock，但是我们可以自己构建相同的东西（loop until free[不知翻译成什么好]）；
3、我们不使用lock，相反我们采用原子指令操作;
4、我们不使用lock，因为我们假设并发线程不同时访问同一数据；
5、我们不使用lock，因为我们可以证明多线程从来不在同一时间访问同一数据
一个非常严重而且非常复杂的因素就是机器的“内存一致性模型”：如何使一个线程正在写的数据同时允许另一个线程查看。如果你把数据先后写在内存的两个地方A，然后是B。一些线程开始从B处读取你的新数据，你可能期望它们也会那样在A进行相同的操作。不幸的是，你写在A内存块中的数据很有可能被放在了存储缓冲区中，所以导致B处写的数据要早于A出现。因此，所有的机器都要求设置“内存栅栏”操作来确保所有的写操作都对外可见。
Example：Lock-Free Hashtable 设计
这里有一个很好的例子on Dr. Cliff Click's lock-free hashtable（in Java,for "Azul" native Java 54-core/chip massive muticore hardware）。Dr Cliff Click思想很简单直接，他把内存一致性模型暴露给了用户。lock free的写操作时很复杂的，特别是重新调整hashtable的大小时。
以下是Dr. Lawlor采取Cliff的思想，但是去掉了最棘手的调整操作。这些代码只适合于小测试。
#include <omp.h>
/*
For performance debugging: count hashtable collisions
*/
int collisions = 0;
/*A lockness hashtable. Both reads and writes are lock-free.
Does not yet implement hashtable resize.*/
template <class KEY, class VALUE>
class LockFreeHashtable {
KEY missingk; // invalid key
VALUE missingv; // invalid key
long size;
struct KEY_VALUE{
KEY k;
VALUE v;
};
volatile KEY_VALUE *data;
void operator=(const LockFreeHashtable &){} // do not copy use
public:
LockFreeHashtable(long size_, KEY missingk=KEY(), VALUE missingv=VALUE())
:missingk(missingk_), missingv(missingv_), size(0), data(0) {
reinit(size_);
}
~LockFreeHashtable() {delete[] data;}
/* Reinitialize to be this new size*/
void reinit(long size_) {
delete[] data;
size = size_;
data = new KEY_VALUE[size];
for (int i = 0; i < size; ++i) {
data[i].k = missingk;
data[i].v = missingv;
}
}
/*read the VALUE for the KEY*/
volatile const VALUE &get(consts KEY &k) {
int idx = k;
while (true) { /*while we haven't found that key yet*/
idx &= size - 1; /*=== idx %= size; */
if (data[idx].k == k) { /*old key*/
return data[idx].v;
}
if (data[idx].k == missingk) { /*missing key*/
return missingv;
}
idx ++; /*move down: keep looking !*/
#pragma omp atomic
collisions ++;
}
}
/*Writes a copy of Value for this KEY*/
void put(const KEY &k, const VALUE &v) {
int idx = k;
while(true) {
idx &= size -1; /*=== idx %= size; */
check_key:
if (data[idx].k == k) {/*fast path:resue old key*/
data[idx].v = v;
return;
}
if (data[idx].k == missingk) { /*try to claim new key*/
data[idx].k = k; /*provisinal ownership*/
goto check_key; /*subtle: check ownership below *before* use */
}
idx ++; // move down: keep looking;
#pragma omp atomic
collisions ++;
}
}
/*Count number of valid values in table */
int count (void) {
int sum = 0;
for (int i = 0; i < size; ++i) {
if (data[i].k != missingk) sum ++;
}
return sum;
}
};
LockFreeHashtable<int, float> h(0, -1, -99.0);
enum {n = 100000}; /*total number of hashtable operations*/
inline int make_key(int i) {
i *= 8193; /*randomizing function*/
return i ^ (i >> 16);
}
int do_hashtable_writes(void) {
collisions = 0;
#pragma omp parallel for
for (int i = 0; i < n; ++i) {
h.put(make_key(i), i * 1.23456);
}
return 0;
}
int do_hashtable_reads(void) {
collisions = 0;
double sum = 0.0;
#pragma omp parallel for reduction(+:sum)
for (int i = 0; i < n; ++i) {
sum += h.get(make_key(i));
}
return sum;
}
int foo(void) {
for (int nthread = 1; nthread <= 4; nthread *=2) {
h.reinit(1024 * 512);
printf("%d threads : \n", nthread);
omp_set_num_threads(nthread);
double t = time_function(do_hashtable_writes);
printf(" writes: %.3f ns per (%.3f ms total)\n",t*1.0e9/n,t*1.0e3);
std::cout <<" collisions: "<< collisions <<"\n";
std::cout <<" total values: "<< h.count() <<"\n";
t = time_function(do_hashtable_reads);
printf(" reads: %.3f ns per (%.3f ms total)\n",t*1.0e9/n,t*1.0e3);
std::cout << " collisions: " << collisions << "\n";
}
return 0;
}
在collisions很少的情况下，可伸缩性还是很好的
上面的例子对于int类型和float类型是很安全的，但是对于动态分配的对象而言，“ABA问题”使回收很棘手——Java的解决方案就是垃圾收集，有一个较好的解决方案叫 Hazard Pointers