关于std::kill_dependency的作用及cppreference示例疑问

问题1：std::kill_dependency()的编译优化行为 #

参考Antony Williams所著《Concurrency in Action》中的示例：存在全局只读数组，从其他线程获取数组索引时使用std::memory_order_consume，代码如下：

int global_data[]={ ... };
std::atomic<int> index;
void f(){
    int i=index.load(std::memory_order_consume);
    do_something_with(global_data[std::kill_dependency(i)]);
}

疑问：std::kill_dependency()是指示编译器可重排对i的访问，还是告知无需重读数组内容？对应两种可能的编译优化行为。

解答 #

std::kill_dependency()的核心作用是中断内存依赖链，和你提到的两种猜测都不直接相关：

• 它不是允许编译器重排对i的访问，而是切断global_data[i]与index.load(std::memory_order_consume)之间的依赖关系。
• 它也不是告知无需重读数组内容，而是终止依赖后，让global_data[i]的访问不再受memory_order_consume语义的约束。

memory_order_consume的语义要求：所有依赖于原子加载结果的操作，不能被重排到加载操作之前，同时要保证依赖数据的可见性。而std::kill_dependency(i)会让global_data[i]不再被标记为依赖于index.load的结果，这样编译器和CPU就可以对index.load和global_data[i]的访问进行重排优化，也无需维护该访问的内存依赖可见性——本质是通过中断依赖链来释放优化空间。

问题2：为何第二次调用g仍可能触发内存屏障？ #

再看cppreference的复杂示例：

struct Foo{int* a;int* b;};
std::atomic<Foo*> foo_head[10];
int foo_array[10][10];

[[carries_dependency]] Foo* f(int i){
    return foo_head[i].load(memory_order_consume);
}

int g(int* x, int* y [[carries_dependency]]){
    return std::kill_dependency(foo_array[*x][*y]);
}

int c = 3;
void h(int i){
    Foo* p;
    p = f(i);
    do_something_with(g(&c, p->a));
    do_something_with(g(p->a, &c));
}

疑问：为何调用g(p->a, &c)时仍可能触发内存获取屏障，即便第一次调用g时已使用std::kill_dependency？

解答 #

std::kill_dependency和[[carries_dependency]]都是针对特定依赖链生效的，彼此的作用范围不交叉：

1. 第一次调用g(&c, p->a)时，std::kill_dependency中断的是g内部foo_array[*x][*y]与参数y（即p->a）的依赖链，但这只影响本次g调用内部的逻辑，不会改变p->a本身的依赖来源——p是通过f(i)用memory_order_consume加载的，p->a仍然依赖于foo_head[i]的原子加载操作。
2. 第二次调用g(p->a, &c)时，第一个参数是p->a，此时g内部访问*x（即*p->a）仍然属于foo_head[i].load(consume)启动的依赖链：foo_head加载 → p → p->a → g的第一个参数 → 内部*x访问。这条全新的依赖链并没有被之前的kill_dependency中断，因为之前的操作只终止了第一次g调用里foo_array访问的依赖，所以为了维护memory_order_consume的语义，仍然需要对应的内存屏障（或CPU层面的依赖顺序保证）来确保依赖数据的可见性。

内容的提问来源于stack exchange，提问作者mentalmushroom