Namespaces
Variants

std:: kill_dependency

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
kill_dependency
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
Definido en el encabezado <atomic>
template < class T >
T kill_dependency ( T y ) noexcept ;
(desde C++11)
(constexpr desde C++26)
(obsoleto en C++26)

Informa al compilador que el árbol de dependencias 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 propaga una dependencia al valor de retorno.

Esto puede utilizarse para evitar barreras std::memory_order_acquire innecesarias cuando la cadena de dependencias sale del ámbito de la función (y la función no tiene el atributo [[ carries_dependency ]] ).

(until C++26)

Simplemente retorna y . Esta plantilla de función está obsoleta.

(since C++26)

Contenidos

Parámetros

y - la expresión cuyo valor de retorno debe eliminarse de un árbol de dependencias

Valor de retorno

Devuelve y , que ya no forma parte de un árbol de dependencias (hasta C++26) .

Ejemplos

file1.cpp: 
struct Foo
{
    int* a;
    int* b;
};
std::atomic<Foo*> foo_head[10];
int foo_array[10][10];
// la operación consume inicia una cadena de dependencia, que escapa de esta función
[[carries_dependency]] Foo* f(int i)
{
    return foo_head[i].load(memory_order_consume);
}
// la cadena de dependencia entra en esta función a través del parámetro derecho y se
// elimina antes de que finalice la función (por lo que no ocurre ninguna operación de adquisición adicional)
int g(int* x, int* y [[carries_dependency]])
{
    return std::kill_dependency(foo_array[*x][*y]);
}
file2.cpp: 
[[carries_dependency]] struct Foo* f(int i);
int g(int* x, int* y [[carries_dependency]]);
int c = 3;
void h(int i)
{
    Foo* p;
    p = f(i); // la cadena de dependencia iniciada dentro de f continúa en p sin adquisición indebida
    do_something_with(g(&c, p->a)); // p->b no se carga desde la caché
    do_something_with(g(p->a, &c)); // el argumento izquierdo no tiene el atributo carries_dependency
                                    // puede emitirse una barrera de adquisición de memoria
                                    // p->b se vuelve visible antes de que se ingrese a g()
}

Véase también

(C++11)
define las restricciones de ordenamiento de memoria para la operación atómica dada
(enum)
C documentation para kill_dependency