std::kill_dependency
De cppreference.com
<tbody>
</tbody>
| Definido en el archivo de encabezado <atomic>
|
||
template< class T > T kill_dependency( T y ) noexcept; |
(desde C++11) | |
Informa al compilador que el árbol de dependencia iniciado por una operación de carga atómica std::memory_order_consume no se extiende más allá del valor de retorno de std::kill_dependency, es decir, el argumento no conlleva una dependencia al valor de retorno.
Esto puede utilizarse para evitar barreras std::memory_order_acquire cuando la cadena de dependencias sale del ámbito de función (y la función no tiene el atributo [[carries_dependency]].
Parámetros
| y | - | La expresión cuyo valor de retorno debe removerse de un árbol de dependencias. |
Valor de retorno
Devuelve y, que ya no es parte de un árbol de dependencias.
Ejemplos
- archivo1.cpp:
struct foo { int* a; int* b; };
std::atomic<struct foo*> foo_head[10];
int foo_array[10][10];
// la operación de consumo inicia una cadena de dependencias, que se escapa de esta función
[[carries_dependency]] struct foo* f(int i) {
return foo_head[i].load(memory_order_consume);
}
// cadena de dependencias ingresa en esta función a través del parámetro correcto
// y se elimina antes que la función termine (y no toma lugar una operación de toma extra)
int g(int* x, int* y [[carries_dependency]]) {
return std::kill_dependency(foo_array[*x][*y]);
}
- archivo2.cpp:
[[carries_dependency]] struct foo* f(int i);
int g(int* x, int* y [[carries_dependency]]);
int c = 3;
void h(int i) {
struct foo* p;
// cadena de dependencias que inició dentro de f continúa en p sin una toma indebida
p = f(i);
do_something_with(g(&c, p->a)); // p->b no se trae de la caché
do_something_with(g(p->a, &c)); // el argumento izquierdo no tiene el atributo
// carries_dependency: puede emitirse una barrera
// de toma de memoria
// p->b se vuelve visible antes que se ingrese a g()
}
Véase también
(C++11) |
Define las restricciones del ordenamiento de memoria para la operación atómica dada. (typedef) |