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)
Definiert im Header <atomic>
template < class T >
T kill_dependency ( T y ) noexcept ;
(seit C++11)
(constexpr seit C++26)
(veraltet in C++26)

Informiert den Compiler, dass der durch einen std::memory_order_consume atomaren Ladevorgang gestartete Abhängigkeitsbaum nicht über den Rückgabewert von std::kill_dependency hinausreicht; das heißt, das Argument trägt keine Abhängigkeit in den Rückgabewert.

Dies kann verwendet werden, um unnötige std::memory_order_acquire Barrieren zu vermeiden, wenn die Abhängigkeitskette den Funktionsbereich verlässt (und die Funktion nicht das [[ carries_dependency ]] Attribut besitzt).

(bis C++26)

Gibt einfach y zurück. Diese Funktionsvorlage ist veraltet.

(seit C++26)

Inhaltsverzeichnis

Parameter

y - der Ausdruck, dessen Rückgabewert aus einem Abhängigkeitsbaum entfernt werden soll

Rückgabewert

Gibt y zurück, nicht länger Teil eines Abhängigkeitsbaums (bis C++26) .

Beispiele

file1.cpp: 
struct Foo
{
    int* a;
    int* b;
};
std::atomic<Foo*> foo_head[10];
int foo_array[10][10];
// Die Consume-Operation startet eine Abhängigkeitskette, die diese Funktion verlässt
[[carries_dependency]] Foo* f(int i)
{
    return foo_head[i].load(memory_order_consume);
}
// Die Abhängigkeitskette tritt durch den rechten Parameter in diese Funktion ein und wird
// beendet, bevor die Funktion endet (daher findet keine zusätzliche Acquire-Operation statt)
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); // Die innerhalb von f begonnene Abhängigkeitskette setzt sich in p fort ohne unnötigen Acquire
    do_something_with(g(&c, p->a)); // p->b wird nicht aus dem Cache geladen
    do_something_with(g(p->a, &c)); // Linkes Argument besitzt nicht das carries_dependency
                                    // Attribut: Memory Acquire Fence könnte ausgegeben werden
                                    // p->b wird sichtbar bevor g() betreten wird
}

Siehe auch

(C++11)
definiert Speicherreihenfolge-Einschränkungen für die gegebene atomare Operation
(enum)
C-Dokumentation für kill_dependency