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)
Défini dans l'en-tête <atomic>
template < class T >
T kill_dependency ( T y ) noexcept ;
(depuis C++11)
(constexpr depuis C++26)
(obsolète en C++26)

Informe le compilateur que l'arbre de dépendance démarré par une opération de chargement atomique std::memory_order_consume ne s'étend pas au-delà de la valeur de retour de std::kill_dependency ; c'est-à-dire que l'argument ne transporte pas de dépendance dans la valeur de retour.

Cela peut être utilisé pour éviter les barrières std::memory_order_acquire inutiles lorsque la chaîne de dépendance quitte la portée de la fonction (et que la fonction ne possède pas l'attribut [[ carries_dependency ]] ).

(jusqu'à C++26)

Retourne simplement y . Ce modèle de fonction est déprécié.

(depuis C++26)

Table des matières

Paramètres

y - l'expression dont la valeur de retour doit être supprimée d'un arbre de dépendance

Valeur de retour

Retourne y , qui ne fait plus partie d'un arbre de dépendances (jusqu'à C++26) .

Exemples

file1.cpp : 
struct Foo
{
    int* a;
    int* b;
};
std::atomic<Foo*> foo_head[10];
int foo_array[10][10];
// l'opération consume démarre une chaîne de dépendance, qui s'échappe de cette fonction
[[carries_dependency]] Foo* f(int i)
{
    return foo_head[i].load(memory_order_consume);
}
// la chaîne de dépendance entre dans cette fonction via le paramètre droit et est
// supprimée avant la fin de la fonction (donc aucune opération acquire supplémentaire n'a lieu)
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 chaîne de dépendance commencée dans f continue dans p sans acquisition excessive
    do_something_with(g(&c, p->a)); // p->b n'est pas extrait du cache
    do_something_with(g(p->a, &c)); // l'argument de gauche ne possède pas l'attribut carries_dependency
                                    // une barrière d'acquisition mémoire peut être émise
                                    // p->b devient visible avant l'entrée dans g()
}

Voir aussi

(C++11)
définit les contraintes d'ordonnancement de la mémoire pour l'opération atomique donnée
(enum)
Documentation C pour kill_dependency