Edit - Stack Overflow

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Rev

Required fields*

What does the [[carries_dependency]] attribute mean?

Can someone explain it in a language that mere mortals understand?

Answer*

`[[carries_dependency]]` is used to allow dependencies to be carried across function calls. This potentially allows the compiler to generate better code when used with `std::memory_order_consume` for transferring values between threads on platforms with weakly-ordered architectures such as IBM's POWER architecture.

In particular, if a value read with `memory_order_consume` is passed in to a function, then without `[[carries_dependency]]`, then the compiler may have to issue a memory fence instruction to guarantee that the appropriate memory ordering semantics are upheld. If the parameter is annotated with `[[carries_dependency]]` then the compiler can assume that the function body will correctly carry the dependency, and this fence may no longer be necessary.

Similarly, if a function returns a value loaded with `memory_order_consume`, or derived from such a value, then without `[[carries_dependency]]` the compiler may be required to insert a fence instruction to guarantee that the appropriate memory ordering semantics are upheld. With the `[[carries_dependency]]` annotation, this fence may no longer be necessary, as the caller is now responsible for maintaining the dependency tree.

e.g.


    void print(int * val)
    {
        std::cout<<*val<<std::endl;
    }

    void print2(int * [[carries_dependency]] val)
    {
        std::cout<<*val<<std::endl;
    }

    std::atomic<int*> p;
    int* local=p.load(std::memory_order_consume);
    if(local)
        std::cout<<*local<<std::endl; // 1

    if(local)
        print(local); // 2

    if(local)
        print2(local); // 3

In line (1), the dependency is explicit, so the compiler knows that `local` is dereferenced, and that it must ensure that the dependency chain is preserved in order to avoid a fence on POWER.

In line (2), the definition of `print` is opaque (assuming it isn't inlined), so the compiler must issue a fence in order to ensure that reading `*p` in `print` returns the correct value.

On line (3), the compiler can assume that although `print2` is also opaque then the dependency from the parameter to the dereferenced value is preserved in the instruction stream, and no fence is necessary on POWER. Obviously, the definition of `print2` must actually preserve this dependency, so the attribute will also impact the generated code for `print2`.

Required fields are marked with *

Edit Summary*

Cancel

21

This is a great answer. But... how would you go about coding the function to preserve the dependency? What would an improperly coded function look like and what would the consequences be?

Omnifarious
– Omnifarious

2011-06-20 13:20:02 +00:00
Commented Jun 20, 2011 at 13:20
2

BTW, I got a pre-release copy of your book as a PDF. It is a fantastic book. I really wish you had carried on your 'person in a cubicle receiving phone calls' metaphor all the way through though. That was a great tool for understanding what was going on.

Omnifarious
– Omnifarious

2011-06-20 13:31:06 +00:00
Commented Jun 20, 2011 at 13:31
5

From the POV of the source, all you need to do is use the [[carries_dependency]] attribute, and not call std::kill_dependency unless you mean it. The compiler will then ensure that it doesn't break the dependency chain in the generated code.

Anthony Williams
– Anthony Williams

2011-06-20 16:31:56 +00:00
Commented Jun 20, 2011 at 16:31
11

@AnthonyWilliams: I'm with Omnifarious here: it sounds like you just have to plaster all the function declarations with [[carries_dependency]] and the compiler will magically generate faster code. I'd be interested in an example function where you cannot use [[carries_dependency]] or where you'd have to use std::kill_dpendency.

Marc Mutz - mmutz
– Marc Mutz - mmutz

2012-07-02 17:40:17 +00:00
Commented Jul 2, 2012 at 17:40
2

@MarcMutz-mmutz "the compiler will magically generate faster code" Wrong. The compiler will generate equal, or less optimized (slower) code.

curiousguy
– curiousguy

2012-07-29 06:30:28 +00:00
Commented Jul 29, 2012 at 6:30

| Show 8 more comments

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>

formatting help »
answering help »

Collectives™ on Stack Overflow

What does the [[carries_dependency]] attribute mean?

Answer*