事务性内存 (TM TS)

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏(C++20)

语言支持库

概念库(C++20)

诊断库

内存管理库

元编程库(C++11)

通用工具库

容器库

迭代器库

范围库(C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库(C++17)

并发支持库(C++11)

执行控制库(C++26)

技术规范

符号索引

外部库

 

C++ 语言

一般主题
预处理器 注释	关键词 转义序列
流程控制
条件执行语句
if	switch
重复语句（循环）
for 范围 for(C++11)	while do-while
跳转语句
continue - break	goto - return
函数
函数声明
lambda 函数表达式
inline 说明符
动态异常说明(C++17 前*)
noexcept 说明符(C++11)
异常
throw 表达式 try 块	catch 处理块
命名空间
命名空间声明	命名空间别名
类型
基础类型 枚举类型 函数类型	类/结构体类型 联合体类型
说明符
const/volatile decltype(C++11)   auto(C++11)	constexpr(C++11)   consteval(C++20) constinit(C++20)
存储期说明符
初始化
默认初始化 值初始化 零初始化 复制初始化 直接初始化	聚合初始化 列表初始化(C++11) 常量初始化 引用初始化

表达式
值类别 求值顺序	运算符 运算符优先级
替代表示
字面量
布尔 - 整数 - 浮点
字符 - 字符串 - nullptr(C++11)
用户定义(C++11)
工具
属性(C++11)
类型
typedef 声明
类型别名声明(C++11)
类型转换
隐式转换 static_cast const_cast	显式转换 dynamic_cast reinterpret_cast
内存分配
new 表达式	delete 表达式
类
类声明 构造函数 this 指针	访问说明符 friend 说明符
类特有的函数性质
虚函数 override 说明符(C++11)   final 说明符(C++11)	explicit(C++11) static
特殊成员函数
默认构造函数 复制构造函数 移动构造函数(C++11)	复制赋值 移动赋值(C++11) 析构函数
模板
类模板 函数模板	模板特化 形参包(C++11)
杂项
内联汇编	C++ 的历史

 

语句

标号

标号 : 语句

表达式语句

表达式 ;

复合语句

{语句... }

选择语句

if

switch

循环语句

while

do while

for

范围 for(C++11)

跳转语句

break

continue

return

goto

断言

contract_assert(C++26)

声明语句

声明 ;

try 块

try 块

事务性内存

synchronized, atomic_commit 等 (TM TS)

 

事务性内存（transactional memory）是在事务中结合语句组的并发同步机制，事务具有

• 原子性（atomic）（要么语句全部发生，要么全部不发生）
• 隔离性（isolated）（事务中的语句不会观察到另一事务写入一半，即使它们并行执行）

典型实现在受支持的平台上将硬件事务性内存使用到极致（例如，直至变更集饱和），再退回到软件事务性内存，后者常以乐观并发（optimistic concurrency）来实现：如果另一事务更新了事务所用的某些变量，那么该事务会安静地重试。由于这个原因，可重试事务（“原子块”）只能调用事务安全的函数。

注意，在没有其他的外部同步的情况下在事务内和事务外访问变量是数据竞争。

如果支持功能特性测试，那么本页所描述的功能特性由具有大于或等于 201505 的值的宏常量 __cpp_transactional_memory 标明。

同步块

synchronized复合语句

如同在一个全局锁下执行复合语句：程序中的所有最外层同步块都以一个单独的全序执行。在该顺序中，每个同步块的结尾同步于（synchronize with）下个同步块的开始。内嵌于其他同步块的同步块没有特殊语义。

同步块不是事务（不同于后面的原子块），并可以调用事务不安全的函数。

运行此代码

#include <iostream>#include <thread>#include <vector>   int f(){staticint i =0; synchronized {// 开始同步块std::cout<< i <<" -> ";++i;// 每次调用 f() 都获得唯一的 i 值std::cout<< i <<'\n';return i;// 结束同步块}}   int main(){std::vector<std::thread> v(10);for(auto& t : v) t =std::thread([]{for(int n =0; n <10;++n) f();});for(auto& t : v) t.join();}

输出：

0 -> 1 1 -> 2 2 -> 3 ... 99 -> 100

以任何方式（抵达结尾，执行 goto、break、continue 或 return，或抛出异常）离开同步块都会退出该块，而如果退出的块是外层块，那么这在单一全序中同步于下个同步块。如果使用 std::longjmp 退出同步块则行为未定义。

不允许用 goto 或 switch 进入同步块。

尽管同步块如同在一个全局锁下执行，我们仍然期待各实现检验每个块内的代码，并为事务安全代码使用乐观并发（在可用时以硬件事务性内存为后盾），为非事务安全代码使用最小锁定。当同步块调用非内联函数时，除非该函数声明为 transaction_safe（见下文）或使用 [[optimize_for_synchronized]] 属性（见下文），否则编译器可能必须放弃推测执行（spculative execution），并在整个调用周围持有一个锁。

原子块

atomic_noexcept复合语句

atomic_cancel复合语句

atomic_commit复合语句

1) 如果抛出异常，那么调用 std::abort

2) 如果抛出异常，那么调用 std::abort，除非该异常是用于事务取消的异常之一（见后述），这种情况下事务被取消（cancel）：程序中所有由该原子块的各操作的副作用所修改的内存位置的值，被还原到该原子块的执行开始时它们曾拥有的值，而异常照常持续栈回溯。

3) 如果抛出异常，那么正常提交事务。

用于 atomic_cancel 块中的事务取消的异常有 std::bad_alloc、std::bad_array_new_length、std::bad_cast、std::bad_typeid、std::bad_exception、std::exception 和所有从它派生的标准库异常，以及特殊异常类型 std::tx_exception<T>。

不允许原子块中的 复合语句 执行任何非 transaction_safe 的表达式或语句，或调用非 transaction_safe 的函数（这是编译时错误）。

// 每次调用 f() 都取得唯一的 i 值，即使以并行进行int f(){staticint i =0; atomic_noexcept {// 开始事务// printf("before %d\n", i); // 错误：不能调用非事务安全的函数++i;return i;// 提交事务}}

以除异常之外的任何方式（抵达结尾、goto、break、continue、return）离开原子块时，将提交事务。如果用 std::longjmp 退出原子块则行为未定义。

事务安全的函数

可在函数声明中用关键词 transaction_safe 将其显式声明为事务安全。

Lambda 表达式声明中，它可以紧跟俘获列表之后，或紧跟关键词 mutable 之后（如果使用它）出现。

externvolatileint* p =0;struct S {virtual ~S();};int f() transaction_safe {int x =0;// OK：非 volatile p =&x;// OK：指针非 volatileint i =*p;// 错误：通过 volatile 泛左值读取 S s;// 错误：调用不安全的析构函数}

int f(int x){// 隐式事务安全if(x <=0)return0;return x + f(x -1);}

如果通过指向事务安全函数的引用或指针调用非事务安全的函数，那么行为未定义。

指向事务安全函数的指针和指向事务安全成员函数的指针分别可隐式转换为函数指针和成员函数指针。结果指针和原指针是否比较相等是未指明的。

事务安全的虚函数

如果 transaction_safe_dynamic 函数的最终覆盖函数未被声明为 transaction_safe，那么在原子块中调用它是未定义行为。

标准库

除了引入新的异常模板 std::tx_exception 之外，事务性内存技术规范还对标准库做出下列更改：

• 令下列函数为显式 transaction_safe：

• std::forward、std::move、std::move_if_noexcept、std::align、std::abort、全局默认 operator new、全局默认 operator delete、std::allocator::construct（如果调用的构造函数是事务安全的）、std::allocator::destroy（如果调用的析构函数是事务安全的）、std::get_temporary_buffer、std::return_temporary_buffer、std::addressof、std::pointer_traits::pointer_to、所有支持事务取消的异常类型（见上文的 atomic_cancel）的每个非虚成员函数

• 令下列函数为显式 transaction_safe_dynamic：

• 所有支持事务取消的异常类型（见上文的 atomic_cancel）的每个虚函数

• 要求分配器 X 上所有事务安全的操作在 X::rebind<>::other 上也是事务安全的

属性

[[optimize_for_synchronized]] 属性可以应用到函数声明中的声明符中，而且必须在函数的首个声明上出现。

如果某函数在一个翻译单元中被声明为 [[optimize_for_synchronized]]，而同一个函数在另一翻译单元中的声明不带 [[optimize_for_synchronized]]，那么程序非良构；不要求诊断。

它指示函数定义应该针对从 synchronized 语句中调用而优化。具体而言，如果函数对大多数的调用但非全部调用为事务安全（例如可能必须重算散列的哈希表插入、可能必须请求新内存块的分配器、可能罕有记录日志的简单函数），那么该属性避免对调用该函数的同步块进行串行化。

std::atomic<bool> rehash{false};   // 维护线程运行此循环void maintenance_thread(void*){while(!shutdown){ synchronized {if(rehash){ hash.rehash(); rehash =false;}}}}   // 工作线程每秒执行数十万次对此函数的调用。// 从另一翻译单元中的同步块调用 insert_key() 将导致这些块被串行化，// 除非标记 insert_key() 为 [[optimize_for_synchronized]][[optimize_for_synchronized]]void insert_key(char* key, char* value){bool concern = hash.insert(key, value);if(concern) rehash =true;}

无该属性的 GCC 汇编：串行化整个函数

insert_key(char*, char*): subq $8, %rsp movq %rsi, %rdx movq %rdi, %rsi movl $hash, %edi call Hash::insert(char*, char*) testb %al, %al je .L20 movb $1, rehash(%rip) mfence .L20: addq $8, %rsp ret 

有该属性的 GCC 汇编：

transaction clone for insert_key(char*, char*): subq $8, %rsp movq %rsi, %rdx movq %rdi, %rsi movl $hash, %edi call transaction clone for Hash::insert(char*, char*) testb %al, %al je .L27 xorl %edi, %edi call _ITM_changeTransactionMode # 注意：这是串行化点 movb $1, rehash(%rip) mfence .L27: addq $8, %rsp ret 

关键词

atomic_cancel, atomic_commit, atomic_noexcept, synchronized, transaction_safe, transaction_safe_dynamic

编译器支持

GCC 从版本 6.1 起支持此技术规范（要求启用 -fgnu-tm）。GCC 4.7 时曾支持此规范的一个旧版变体。