Skynet专题之：原子操作

// 特别说明：网页显示问题，以下代码的 预处理语句 都省略了 #
// 文件位于：atomic.h
ifndef SKYNET_ATOMIC_H // 如果没有定义SKYNET_ATOMIC_H，则开始定义SKYNET_ATOMIC_H
		define SKYNET_ATOMIC_H
		include <stddef.h>
		include <stdint.h>

		// __STDC_NO_ATOMICS__ 是一个预定义宏，用于指示编译器是否支持 C11 中的 <stdatomic.h> 头文件中定义的原子操作
		// 如果__STDC_NO_ATOMICS__ 没有被定义，编译器支持 C11 的原子操作，
		// 如果__STDC_NO_ATOMICS__ 被定义，则表示编译器不支持 C11 的原子操作
		// 因此，可以使用 #ifdef __STDC_NO_ATOMICS__ 来判断编译器是否支持 C11 中的原子操作
		// 如果支持，则可以使用 <stdatomic.h> 中定义的原子操作，否则可能需要使用其他方式来实现原子操作
		ifdef __STDC_NO_ATOMICS__ 
				// 这里表示编译器不支持 C11 的原子操作，因此需要下面的方式来实现原子操作
				// 即：使用GCC编译器内置的函数来代替POSIX标准中定义的原子操作函数

				// 使用 volatile 关键字可以告诉编译器不要对变量进行优化
				// 以确保每次访问变量时都从内存中读取最新的值，而不是使用之前缓存的值
				// 这对于需要与并发操作或外部事件进行交互的代码非常重要，以确保数据的一致性和可靠性
				
				define ATOM_INT volatile int // 表示 int 类型的变量
				define ATOM_POINTER volatile uintptr_t // 表示 uintptr_t 类型的变量
				define ATOM_SIZET volatile size_t // 表示 size_t 类型的变量
				define ATOM_ULONG volatile unsigned long // 表示 unsigned long 类型的变量
				define ATOM_INIT(ptr, v) (*(ptr) = v) // 初始化原子类型的对象
				define ATOM_LOAD(ptr) (*(ptr)) // 从原子变量中加载值
				define ATOM_STORE(ptr, v) (*(ptr) = v) // 将值存储到原子变量中
				
				// GCC 内置函数，实现原子的比较和交换操作，适用于对 int 类型的变量 进行原子的比较和交换操作
				define ATOM_CAS(ptr, oval, nval) __sync_bool_compare_and_swap(ptr, oval, nval)
				
				// GCC 内置函数，实现原子的比较和交换操作，适用于对 unsigned long 类型的变量 进行原子的比较和交换操作
				define ATOM_CAS_ULONG(ptr, oval, nval) __sync_bool_compare_and_swap(ptr, oval, nval)
				
				// GCC 内置函数，实现原子的比较和交换操作，适用于对 size 类型的变量 进行原子的比较和交换操作
				define ATOM_CAS_SIZET(ptr, oval, nval) __sync_bool_compare_and_swap(ptr, oval, nval)
				
				// GCC 内置函数，实现原子的比较和交换操作，适用于对 指向指针的指针 进行原子的比较和交换操作
				define ATOM_CAS_POINTER(ptr, oval, nval) __sync_bool_compare_and_swap(ptr, oval, nval)

				// GCC 内置函数，原子的加法操作，实现 原子操作+1
				define ATOM_FINC(ptr) __sync_fetch_and_add(ptr, 1)
				
				// GCC 内置函数，原子的减法操作，实现 原子操作-1
				define ATOM_FDEC(ptr) __sync_fetch_and_sub(ptr, 1)
				
				// GCC 内置函数，原子的加法操作，实现 原子操作+n
				define ATOM_FADD(ptr,n) __sync_fetch_and_add(ptr, n)

				// GCC 内置函数，原子的减法操作，实现 原子操作-n
				define ATOM_FSUB(ptr,n) __sync_fetch_and_sub(ptr, n)

				// GCC 内置函数，原子的与操作，实现 原子操作 与运算
				define ATOM_FAND(ptr,n) __sync_fetch_and_and(ptr, n)

		else
				// 编译器支持 C11 中的原子操作，不需要用GCC编译器内置的函数来代替POSIX标准中定义的原子操作函数
				// 即：使用stdatomic.h文件即可
				
				// 在开始之前，还需要判断编译器是否支持C++
				// 如果支持C++，就用 atomic.h文件 来实现原子操作函数
				// 如果不支持C++，就用 stdatomic.h文件 来实现原子操作函数
				
				// 如果编译器是 C++ 编译器，那么会包含 <atomic> 头文件，并定义 STD_ 为 std::，用于在代码中指明标准命名空间std
				// 
				// 如果编译器不是 C++ 编译器，那么会包含 <stdatomic.h> 头文件，并将 STD_ 和 atomic_value_type_ 定义为空
				// 因为在 C 中不需要指明命名空间，并且 stdatomic.h 中已经提供了相应的宏定义

				// 这样做的目的是为了使代码在 C 和 C++ 中都能正常编译和工作，而不需要修改原子操作的代码
				
				// __cplusplus 是一个预定义宏，用于指示编译器是否正在编译 C++ 代码
				if defined (__cplusplus)
					include <atomic>
					define STD_ std::
					define atomic_value_type_(p, v) decltype((p)->load())(v) 
				else
					include <stdatomic.h>
					define STD_
					define atomic_value_type_(p, v) v
				endif
				// 特别关于 atomic_value_type_ 的定义
				// 
				// decltype 是 C++ 中的一个关键字，用于获取表达式的类型而不执行实际的表达式
				// 例如：decltype(expression)
				// 		expression是一个表达式，可以是变量、函数调用、类型转换等
				// 
				// decltype 的作用是根据表达式的类型推导出一个类型，并在编译时确定该类型
				// 
				// 1，推导变量的类型：可以使用 decltype 来声明一个变量，该变量的类型与给定表达式的类型相同
				// 					int x = 5;
				// 					decltype(x) y;   	// y 的类型与给定表达式的类型相同，都为int
				//
				// 2，推导函数返回值的类型：可以使用 decltype 来推导函数的返回值类型，尤其在函数返回类型比较复杂或依赖于参数类型等情况下
				// 					int foo();
				// 					decltype(foo()) result;  // result 的类型与 foo() 的返回类型相同
				//
				// 那么 (p)->load() 又是什么含义，有什么作用呢？
				// 在 C++ 中，p 是一个指向 std::atomic<int> 类型对象的指针，而 p->load() 是调用了 std::atomic 类的 load() 成员函数
				// (后面我们能知道，我们通过 atomic_init(ref, v) 初始化 atomic 原子对象，所以传进来的 p 也一定是 atomic 对象)
				// std::atomic 是 C++ 中用于实现原子操作的模板类，load() 是它的一个成员函数，用于原子地读取 std::atomic 对象的值
				// 在这种情况下，p->load() 表示通过指针 p 原子地访问到的 std::atomic<int> 对象的值
				// 
				// 现在我们知道 #define atomic_value_type_(p, v) decltype((p)->load())(v) 的作用了
				// atomic_value_type_(p, v) 就是把 传入的 v 的类型，转为 (p)->load() 的返回值的类型
				
				// C11 标准中 <stdatomic.h> 头文件中定义的一种原子类型
				// atomic_int用于表示 int 类型的变量
				define ATOM_INT  STD_ atomic_int
				
				// C11 标准中 <stdatomic.h> 头文件中定义的一种原子类型
				// atomic_uintptr_t用于表示 uintptr_t 类型的变量
				define ATOM_POINTER STD_ atomic_uintptr_t

				// C11 标准中 <stdatomic.h> 头文件中定义的一种原子类型
				// atomic_size_t用于表示 size_t 类型的变量
				define ATOM_SIZET STD_ atomic_size_t

				// C11 标准中 <stdatomic.h> 头文件中定义的一种原子类型
				// atomic_ulong 是用于表示 unsigned long 类型的变量
				define ATOM_ULONG STD_ atomic_ulong 
				
				define ATOM_INIT(ref, v) STD_ atomic_init(ref, v) // 用于初始化原子类型的对象
				define ATOM_LOAD(ptr) STD_ atomic_load(ptr) // 从原子变量中加载值
				define ATOM_STORE(ptr, v) STD_ atomic_store(ptr, v) // 将值存储到原子变量中

				
				// C++ 中的原子操作函数，用于比较并交换原子类型的值，适用于对 int 类型的变量
				static inline int
				ATOM_CAS(STD_ atomic_int *ptr, int oval, int nval) {
					return STD_ atomic_compare_exchange_weak(ptr, &(oval), nval);
				}

				// C++ 中的原子操作函数，用于比较并交换原子类型的值，适用于对 size_t 类型的变量
				static inline int
				ATOM_CAS_SIZET(STD_ atomic_size_t *ptr, size_t oval, size_t nval) {
					return STD_ atomic_compare_exchange_weak(ptr, &(oval), nval);
				}
				
				// C++ 中的原子操作函数，用于比较并交换原子类型的值，适用于对 unsigned long 类型的变量
				static inline int
				ATOM_CAS_ULONG(STD_ atomic_ulong *ptr, unsigned long oval, unsigned long nval) {
					return STD_ atomic_compare_exchange_weak(ptr, &(oval), nval);
				}

				// C++ 中的原子操作函数，用于比较并交换原子类型的值，适用于对 uintptr_t 类型的变量
				static inline int
				ATOM_CAS_POINTER(STD_ atomic_uintptr_t *ptr, uintptr_t oval, uintptr_t nval) {
					return STD_ atomic_compare_exchange_weak(ptr, &(oval), nval);
				}


				define ATOM_FINC(ptr) STD_ atomic_fetch_add(ptr, atomic_value_type_(ptr, 1)) // 原子操作+1
				define ATOM_FDEC(ptr) STD_ atomic_fetch_sub(ptr, atomic_value_type_(ptr, 1)) // 原子操作-1
				define ATOM_FADD(ptr,n) STD_ atomic_fetch_add(ptr, atomic_value_type_(ptr, n)) // 原子操作+n
				define ATOM_FSUB(ptr,n) STD_ atomic_fetch_sub(ptr, atomic_value_type_(ptr, n)) // 原子操作-n
				define ATOM_FAND(ptr,n) STD_ atomic_fetch_and(ptr, atomic_value_type_(ptr, n)) // 原子操作 与运算
		endif
endif

// 声明
struct skynet_node {
    // 参看上面的 类型声明类 - int型：ATOM_INT
    // 在 skynet_node 结构体中，声明了原子对象 total，类型为 int型
	ATOM_INT total;
    
	// 其他代码可以忽略
};

static struct skynet_node G_NODE; // 建立全局单例G_NODE

// 初始化
void skynet_globalinit(void) {
    // 参看上面的 基础操作类 - 初始化操作：ATOM_INIT(ref， v)
    // 把刚才在 skynet_node 结构体中声明的原子对象 total，初始化为0
	ATOM_INIT(&G_NODE.total, 0);
	
    // 其他代码可以忽略
}

// 读取操作
int skynet_context_total() {
	return ATOM_LOAD(&G_NODE.total); // 参看上面的 基础操作类 - 加载操作：ATOM_LOAD(ptr)，实际就是读取数值
}

// 增加操作
static void context_inc() {
	ATOM_FINC(&G_NODE.total); // 参看上面的 基础操作类 - 加1操作：ATOM_FINC(ptr)
}

// 减少操作
static void context_dec() {
	ATOM_FDEC(&G_NODE.total); // 参看上面的 基础操作类 - 减1操作：ATOM_FDEC(ptr)
}