Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::kill_dependency

      From cppreference.com
      <cpp‎ |atomic
       
       
      Concurrency support library
      Threads
      (C++11)
      (C++20)
      this_thread namespace
      (C++11)
      (C++11)
      (C++11)
      Cooperative cancellation
      Mutual exclusion
      Generic lock management
      (C++11)
      (C++11)
      (C++11)
      (C++11)
      Condition variables
      (C++11)
      Semaphores
      Latches and Barriers
      (C++20)
      (C++20)
      Futures
      (C++11)
      (C++11)
      (C++11)
      Safe reclamation
      Hazard pointers
      Atomic types
      (C++11)
      (C++20)
      Initialization of atomic types
      (C++11)(deprecated in C++20)
      (C++11)(deprecated in C++20)
      Memory ordering
      kill_dependency
      (C++11)(deprecated in C++26)
      Free functions for atomic operations
      Free functions for atomic flags
       
      Defined in header<atomic>
      template<class T>
      T kill_dependency( T y)noexcept;
      (since C++11)
      (constexpr since C++26)
      (deprecated in C++26)

      Informs the compiler that the dependency tree started by anstd::memory_order_consume atomic load operation does not extend past the return value ofstd::kill_dependency; that is, the argument does not carry a dependency into the return value.

      This may be used to avoid unnecessarystd::memory_order_acquire fences when the dependency chain leaves function scope (and the function does not have the[[carries_dependency]] attribute).

      (until C++26)

      Simply returnsy. This function template is deprecated.

      (since C++26)

      Contents

      [edit]Parameters

      y - the expression whose return value is to be removed from a dependency tree

      [edit]Return value

      Returnsy, no longer a part of a dependency tree(until C++26).

      [edit]Examples

      [edit]file1.cpp:
      struct Foo{int* a;int* b;}; std::atomic<Foo*> foo_head[10];int foo_array[10][10]; // consume operation starts a dependency chain, which escapes this function[[carries_dependency]] Foo* f(int i){return foo_head[i].load(memory_order_consume);} // the dependency chain enters this function through the right parameter and is// killed before the function ends (so no extra acquire operation takes place)int g(int* x,int* y[[carries_dependency]]){return std::kill_dependency(foo_array[*x][*y]);}
      [edit]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);// dependency chain started inside f continues into p without undue acquire    do_something_with(g(&c, p->a));// p->b is not brought in from the cache    do_something_with(g(p->a,&c));// left argument does not have the carries_dependency// attribute: memory acquire fence may be issued// p->b becomes visible before g() is entered}

      [edit]See also

      defines memory ordering constraints for the given atomic operation
      (enum)[edit]
      C documentation forkill_dependency
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/atomic/kill_dependency&oldid=181320"

      [8]ページ先頭

      ©2009-2025 Movatter.jp