文章目录
目的
一直想了解下mutex是怎么实现的，锁的语义是如何支持的，所以就查了查相关的资料和代码。
渐进知识点
Glibc
首先就是要看看gblic里面对于pthread_mutex_lock这个函数的实现，因为在认知里面关于锁的操作都是起始于这个系统调用：
glibc/nptl/pthread_mutex_lock.c
#ifndef LLL_MUTEX_LOCK
# define LLL_MUTEX_LOCK(mutex) \
lll_lock ((mutex)->__data.__lock, PTHREAD_MUTEX_PSHARED (mutex))
#endif
int
__pthread_mutex_lock (pthread_mutex_t *mutex)
{
unsigned int type = PTHREAD_MUTEX_TYPE_ELISION (mutex);
if (__glibc_likely (type == PTHREAD_MUTEX_TIMED_NP))
{
/* Normal mutex. */
LLL_MUTEX_LOCK (mutex);
assert (mutex->__data.__owner == 0);
}
}
源码里面有些东西我删掉了，主要的代码就是上面的。对于PTHREAD_MUTEX_TIMED_NP这个mutex类型来说，就是相当于处理普通的锁。PTHREAD_MUTEX_TIMED_NP类型在头文件里面也能看到定义：
glibc/sysdeps/nptl/pthread.h
/* Mutex types. */
enum
{
PTHREAD_MUTEX_TIMED_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_ADAPTIVE_NP
};
好，主要就是LLL_MUTEX_LOCK 这个宏了，看到最开始的地方有#ifndef LLL_MUTEX_LOCK ，所以应该是有两个实现：lll_lock 和 lll_cond_lock(这个宏定义在glibc/nptl/pthread_mutex_cond_lock.c文件里面)
这两个函数具体的实现在glibc/sysdeps/unix/sysv/linux/x86_64/lowlevellock.h里面，这两段汇编主要是看这两个指令：
__lll_lock_asm_start
LOCK_INSTR
在同一个头文件glibc/sysdeps/unix/sysv/linux/x86_64/lowlevellock.h里面，可以找到相关的定义，__lll_lock_asm_start一种实现是用cmpxchg指令实现的，另外一种也使用到LOCK_INSTR：
define LOCK_INSTR "lock;"
到这里，就是最关键的指令了，lock;
lock汇编指令前缀
lock应该说是一个前缀，
这篇博客很好地说明了在Intel系列的处理器上面，lock是个什么意思，自己也找了找amd的手册看了看，大致跟Intel上面的差不多（https://www.amd.com/system/files/TechDocs/24594.pdf）。
从博客里面看到在早期的时候是通过锁总线（bus）来实现的，直接不让其他核心获取总线控制权。后面使用的是锁缓存+缓存一致性协议来实现。
Intel 手册LOCKED ATOMIC OPERATIONS章节
这些从Intel手册截取。
CPU使用三种相互依赖的机制来实行原子操作：
- CPU原子操作的保证
- 锁总线
- 在缓存行上面的缓存一致性协议（锁缓存）
首先是基本的内存操作（从内存读写字节）的原子性保证：处理器保证在读取或者写入的过程中，其他的处理器或者总线不会访问这个内存。
从这里可以看到，升级之后的处理器系列都会额外加入一些原子的保证。P6以后的处理器提供了锁缓存。
第二是锁总线
也是从P6处理器是一个分水岭。
最后是锁缓存
大致意思是如果那块被锁的内存是在CPU的高速缓存里面的话，那么就会用缓存一致性协议来保证原子性。缓存一致性机制会阻止两个以上的CPU同时缓存一块被修改过的内存。
锁缓存+缓存一致性协议
MESI protocol guarantees that if a line is held exclusively by a certain core , no one else has it
缓存行：CPU缓存和主存之间交互使用的固定大小的数据块
Data flows among the CPUs’ caches and memory in fixed-length blocks called “cache lines”
MESI协议保证缓存行只会被唯一的一个核心占有（共享缓存行除外）。缓存行的状态是通过总线+主存控制器来传递的。如果一个缓存行被一个核心修改，那么其他核心缓存中的该行的状态就会被置为invaild（unused）（应该翻译成：不能使用的？）
这篇博文 很好地解释了MESI协议。
这篇翻译也很好地解释了MESI、Store Buffer、Invalied Queue等概念。
MESI 是一个总线事务，发送一个Invaild给所有的核心，等他们确认。MESI会有性能问题（因为他要等所有的核心确认这个Invaild），所以后面引入了Store Buffer 和 Invaild Queue（自己感觉就是像缓存消息，后面空了再处理这些Invaild）
使用LOCK前缀指令能做什么
实现自己的atmoic类型
在C代码里面我们可以使用内嵌的汇编来实现atomic。Gcc Manual – How to Use Inline Assembly Language in C Code这个章节是内嵌汇编代码的教程，看一遍就会写了。
在接触这些之前，对于普通类型的变量（int, char,bool）在线程之间的同步，都是用的mutex，也没有一个效率的概念。这次就弄一个不带锁的普通变量累加试试。
atomic int
使用mutex版本
#include <stdio.h>
#include <stdatomic.h>
#include <pthread.h>
#include <sys/time.h>
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
int a = 0;
void* pthread_add(void* args) {
for (int i = 0; i < 100000000; ++i) {
pthread_mutex_lock(&mutex);
a++;
pthread_mutex_unlock(&mutex);
}
}
int main(int argc, char** argv) {
pthread_t t1, t2;
struct timeval start, stop;
gettimeofday(&start, NULL);
pthread_create(&t1, NULL, pthread_add, NULL);
pthread_create(&t2, NULL, pthread_add, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
printf("===========\n");
printf("%d %d \n", a, b);
printf("===========\n");
gettimeofday(&stop, NULL);
printf("took %lu ms\n", (stop.tv_sec - start.tv_sec) * 1000 + (stop.tv_usec - start.tv_usec) / 1000);
return 0;
}
开了两个线程对a变量分别累加1亿次。可以看到
花了13s多，我猜应该大部分时间都在花在锁跟调度上面。
schedule还没花多少时间，大部分都是在等锁上面。
使用内嵌汇编 && LOCK前缀
现在把pthread_add函数改成这样：
void lock_add_val(int* target, int add) {
__asm__ __volatile__(
"lock;\n"
"addl %1, %0"
: "=m" (*target)
: "r" (add)
);
}
void* pthread_add(void* args) {
for (int i = 0; i < 100000000; ++i) {
lock_add_val(&a, 1);
}
}
其中a变量的递增使用内嵌汇编来实现，并且使用LOCK前缀。
这次来看下效果怎样：
这次有差不多5-6倍性能的提升。看样子mutex还是会花很多的时间。
使用Atomic
_Atomic int b = 0;
void* pthread_add(void* args) {
for (int i = 0; i < 100000000; ++i) {
b++;
}
}
我猜几百毫秒的差异应该是函数调用的开销，把lock_add_val函数定义成static inline，又能少一点时间花费。
实现自己的SpinLock
struct SpinLock {
volatile int lock;
};
int cas1(struct SpinLock* lock, int old_value, int new_value) {
int ret = old_value;
__asm__ __volatile__(
"lock;\n"
"cmpxchgl %2, %1"
: "=a" (ret), "+m" (lock->lock)
: "r" (new_value), "0" (ret)
: "memory"
);
return ret;
}
int cas2(struct SpinLock* lock, int old_value, int new_value) {
int ret = old_value;
__asm__ __volatile__(
"lock;\n"
"cmpxchgl %2, %1"
: "+a" (ret), "+m" (lock->lock)
: "r" (new_value)
: "memory"
);
return ret;
}
上面两个函数最主要的差别是在 “=a” 和 “+a” 上面（函数效果是一样的），之所以把这两个函数放在这里做比较，是因为最开始在cas2函数里面，是 “=a”，但是得到的值老是不正确的，改成"="之后就能正常工作了。原因是：
Output constraints must begin with either ‘=’ (a variable overwriting an existing value) or ‘+’ (when reading and writing). When using ‘=’, do not assume the location contains the existing value on entry to the asm, except when the operand is tied to an input; see Input Operands.
当在使用"=“的时候，不能假设寄存器加载了对应的值，除非这个操作数也跟输入绑定。所以，如果想要用”=“的话，那么就要在输入参数里面也添加上（cas1），要不然就要使用”+"（cas2）
有了cas，我们可以实现自己的SpinLock，和对应的lock、unlock操作：
struct SpinLock lock = {0};
void my_lock(struct SpinLock* lock) {
while (__cas(lock, 0, 1)) {
cpu_relax()
}
}
void my_unlock(struct SpinLock* lock) {
barrier()
lock->lock = 0;
}
有了自己的SpinLock之后就能替换之前的mutex：
struct SpinLock lock = {0};
void* pthread_add(void* args) {
for (int i = 0; i < 100000000; ++i) {
my_lock(&lock);
a++;
my_unlock(&lock);
}
}
这个替换是能正确工作的，能得到正确的结果。
完整的自己实现的SpinLock代码
#include <stdio.h>
#include <stdatomic.h>
#include <pthread.h>
#include <sys/time.h>
int a = 0;
struct SpinLock {
volatile int lock;
};
struct SpinLock lock = {0};
#define barrier() __asm__ __volatile__("": : : "memory");
#define cpu_relax() __asm__ __volatile__("pause\n": : : "memory");
int __cas(struct SpinLock* lock, int old_value, int new_value) {
int ret = old_value;
__asm__ __volatile__(
"lock;\n"
"cmpxchgl %2, %1"
: "=a" (ret), "+m" (lock->lock)
: "r" (new_value), "0" (ret)
: "memory"
);
return ret;
}
void my_lock(struct SpinLock* lock) {
while (__cas(lock, 0, 1)) {
cpu_relax()
}
}
void my_unlock(struct SpinLock* lock) {
barrier()
lock->lock = 0;
}
void* pthread_add(void* args) {
for (int i = 0; i < 10000000; ++i) {
my_lock(&lock);
a++;
my_unlock(&lock);
}
}
void run_thread() {
pthread_t t1, t2;
struct timeval start, stop;
gettimeofday(&start, NULL);
pthread_create(&t1, NULL, pthread_add, NULL);
pthread_create(&t2, NULL, pthread_add, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
printf("===========\n");
printf("%d\n", a);
printf("===========\n");
gettimeofday(&stop, NULL);
printf("took %lu ms\n", (stop.tv_sec - start.tv_sec) * 1000 + (stop.tv_usec - start.tv_usec) / 1000);
}
int main(int argc, char** argv) {
run_thread();
return 0;
}
总结
走一遍流程下来，能发现锁其实也是要使用CPU提供的LOCK;前缀来在硬件层面上保证atomic，再在操作系统层面来实现对应的逻辑。
自己实现了一个spin lock，对于lock前缀的理解和C代码里面嵌入汇编有了更深入的认识。其实spin lock还有其他很多的实现方式，cmpxchg只是其中一种。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
