> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# C++ Carries Dependency Attribute
The `[[carries_dependency]]` attribute is a C++11 optimization hint used in concurrent programming to propagate data dependency chains across function boundaries. It informs the compiler that a value passed into or returned from a function carries a dependency originating from an atomic load operation with `std::memory_order_consume`, thereby suppressing the generation of unnecessary hardware memory barriers on weakly-ordered architectures.
## Syntax and Placement
The attribute appertains to two specific entities within a function signature:
1. **Function Declaration:** Indicates that the function's return value carries a dependency chain originating from within the function. It appertains to the function itself, not the return type.
2. **Function Parameter:** Indicates that the argument passed to the function carries a dependency chain originating from the caller. To apply correctly to the parameter (and not the pointer/reference type), it must be placed before the declaration specifiers or after the parameter name.
```cpp theme={"dark"}
// 1. Applied to the function declaration (indicates the return value carries a dependency)
[[carries_dependency]] int* process_node(int* node);
// 2. Applied to a function parameter
// (Placed before the declaration specifiers)
void evaluate_node([[carries_dependency]] int* node);
// (Alternatively, placed after the parameter name)
void evaluate_node_alt(int* node [[carries_dependency]]);
// 3. Applied to both the function declaration and a parameter
[[carries_dependency]] int* transform_node([[carries_dependency]] int* node);
```
## Technical Semantics
To understand `[[carries_dependency]]`, it must be contextualized with `std::memory_order_consume`. When a thread loads an atomic variable using `memory_order_consume`, the compiler establishes a dependency chain. Any subsequent operations that rely on the loaded value (e.g., dereferencing a loaded pointer) are guaranteed to be ordered after the load, without requiring a heavy memory fence.
However, compilers typically treat function calls as opaque boundaries.
**Without the attribute:**
If a value carrying a dependency is passed into a function, or returned from one, the compiler must assume the dependency chain is broken. To maintain the memory ordering guarantees required by the C++ memory model, the compiler is forced to emit a hardware memory barrier (fence) instruction at the function boundary.
**With the attribute:**
`[[carries_dependency]]` bridges this opaque boundary.
* When applied to a **parameter**, the callee assumes the caller has provided a value that already carries a dependency. The compiler can safely omit the memory barrier inside the callee.
* When applied to a **function declaration**, the caller assumes the callee is returning a value that carries a dependency. The compiler can safely omit the memory barrier at the call site.
## Compilation and ABI Handling
The attribute affects the Application Binary Interface (ABI) at the compiler level. The compiler must manage the dependency state between the caller and the callee:
* **Matching Contexts:** If the caller provides a dependency and the callee expects one (`[[carries_dependency]]` parameter), the code executes optimally without injected fences.
* **Mismatch Handling:** If a function expects a dependency but is called with a standard, non-dependent value, the compiler automatically injects a memory barrier at the call site to satisfy the callee's internal memory ordering requirements.
## Current Compiler Implementation Reality
While mechanically defined in the C++ standard, `[[carries_dependency]]` is effectively a historical artifact in modern C++ development.
Because tracking dependency chains through arbitrary code paths proved exceptionally difficult for compiler authors, all major compilers (GCC, Clang, MSVC) currently map `std::memory_order_consume` directly to the stronger `std::memory_order_acquire`. Because `memory_order_acquire` enforces ordering via memory barriers rather than data dependency chains, the `[[carries_dependency]]` attribute is currently ignored by these compilers and acts as a semantic no-op.
Tired of Poor C++ Skills? Fix That With Deep Grasping!
Learn More
