Skip to contentSkip to conversation

Control dependency between prior load in while condition and later store?

DISCUSSION Daniel Jordan 3 participants 7 messages Apr 4, 2018 – Apr 5, 2018

lore
Share & tools
lore
#0 lore raw

A question for memory-barriers.txt aficionados.

Is there a control dependency between the prior load of 'a' and the later store of 'c'?:

  while (READ_ONCE(a));
  WRITE_ONCE(c, 1);

I have my doubts because memory-barriers.txt doesn't talk much about loops and because of what that document says here:

In addition, control dependencies apply only to the then-clause and else-clause of the if-statement in question. In particular, it does not necessarily apply to code following the if-statement:

  	q = READ_ONCE(a);
  	if (q) {
  		WRITE_ONCE(b, 1);
  	} else {
  		WRITE_ONCE(b, 2);
  	}
  	WRITE_ONCE(c, 1);  /* BUG: No ordering against the read from 'a'. */

It's not obvious to me how the then-clause/else-clause idea maps onto loops, but if we think of the example at the top like this...

  while (1) {
      if (!READ_ONCE(a)) {
          WRITE_ONCE(c, 1);
          break;
      }
  }

...then the dependent store is within the then-clause. Viewed this way, it seems there would be a control dependency between a and c.

Is that right?

Thanks,
Daniel

#1 lore raw
Quoted 7 lines · Daniel Jordan

A question for memory-barriers.txt aficionados.

Is there a control dependency between the prior load of 'a' and the later store of 'c'?:

   while (READ_ONCE(a));
   WRITE_ONCE(c, 1);

I would say that yes, there is.

Quoted 14 lines

I have my doubts because memory-barriers.txt doesn't talk much about loops and because of what that document says here:

   In addition, control dependencies apply only to the then-clause and
   else-clause of the if-statement in question.  In particular, it does
   not necessarily apply to code following the if-statement:

   	q = READ_ONCE(a);
   	if (q) {
   		WRITE_ONCE(b, 1);
   	} else {
   		WRITE_ONCE(b, 2);
   	}
   	WRITE_ONCE(c, 1);  /* BUG: No ordering against the read from 'a'. */

This refers to situations where the two code paths meet up at the end of the "if" statement. If they don't meet up (because one of the paths branches away -- especially if it branches backward) then the disclaimer doesn't apply, and everything following the "if" is dependent.

The reason is because the compiler knows that code following the "if" statement will be executed unconditionally if the paths meet up, so it can move that code back before the "if" (provided nothing else prevents such motion). But if the paths don't meet up, the compiler can't perform the code motion -- if it did then the program might end up executing something that should not have been executed!

Quoted 10 lines

It's not obvious to me how the then-clause/else-clause idea maps onto loops, but if we think of the example at the top like this...

   while (1) {
       if (!READ_ONCE(a)) {
           WRITE_ONCE(c, 1);
           break;
       }
   }
Quoted 4 lines

...then the dependent store is within the then-clause. Viewed this way, it seems there would be a control dependency between a and c.

Is that right?

Yes, except that a more accurate view of the object code would be something like this:

Loop:	r1 = READ_ONCE(a);
	if (r1)
		goto Loop;
	else
		;	// Do nothing
	WRITE_ONCE(c, 1);

Here you can see that one path branches backward, so everything following the "if" is dependent on the READ_ONCE.

Alan

#2 lore raw
Quoted 27 lines · Alan Stern
Quoted 7 lines · Daniel Jordan

A question for memory-barriers.txt aficionados.

Is there a control dependency between the prior load of 'a' and the later store of 'c'?:

    while (READ_ONCE(a));
    WRITE_ONCE(c, 1);

I would say that yes, there is.

Quoted 14 lines

I have my doubts because memory-barriers.txt doesn't talk much about loops and because of what that document says here:

    In addition, control dependencies apply only to the then-clause and
    else-clause of the if-statement in question.  In particular, it does
    not necessarily apply to code following the if-statement:

    	q = READ_ONCE(a);
    	if (q) {
    		WRITE_ONCE(b, 1);
    	} else {
    		WRITE_ONCE(b, 2);
    	}
    	WRITE_ONCE(c, 1);  /* BUG: No ordering against the read from 'a'. */
Quoted 5 lines

This refers to situations where the two code paths meet up at the end of the "if" statement. If they don't meet up (because one of the paths branches away -- especially if it branches backward) then the disclaimer doesn't apply, and everything following the "if" is dependent.

Ok, that's the part I wasn't getting: this is how the while loop changes the situation.

Quoted 32 lines

The reason is because the compiler knows that code following the "if" statement will be executed unconditionally if the paths meet up, so it can move that code back before the "if" (provided nothing else prevents such motion). But if the paths don't meet up, the compiler can't perform the code motion -- if it did then the program might end up executing something that should not have been executed!

Quoted 10 lines

It's not obvious to me how the then-clause/else-clause idea maps onto loops, but if we think of the example at the top like this...

    while (1) {
        if (!READ_ONCE(a)) {
            WRITE_ONCE(c, 1);
            break;
        }
    }
Quoted 4 lines

...then the dependent store is within the then-clause. Viewed this way, it seems there would be a control dependency between a and c.

Is that right?

Yes, except that a more accurate view of the object code would be something like this:

Loop:	r1 = READ_ONCE(a);
	if (r1)
		goto Loop;
	else
		;	// Do nothing
	WRITE_ONCE(c, 1);
Quoted 2 lines

Here you can see that one path branches backward, so everything following the "if" is dependent on the READ_ONCE.

That clears it up, thanks very much!

#3 lore raw
In reply to Alan Stern
Quoted 11 lines · Alan Stern
Quoted 7 lines · Daniel Jordan

A question for memory-barriers.txt aficionados.

Is there a control dependency between the prior load of 'a' and the later store of 'c'?:

   while (READ_ONCE(a));
   WRITE_ONCE(c, 1);

I would say that yes, there is.

Indeed.

Quoted 10 lines

Yes, except that a more accurate view of the object code would be something like this:

Loop:	r1 = READ_ONCE(a);
	if (r1)
		goto Loop;
	else
		;	// Do nothing
	WRITE_ONCE(c, 1);
Quoted 2 lines

Here you can see that one path branches backward, so everything following the "if" is dependent on the READ_ONCE.

Agreed, and I think I even have code that relies on such a pattern somewhere.. Ah.. yes, see smp_cond_load_acquire().

#4 lore raw
Quoted 25 lines · Peter Zijlstra
Quoted 11 lines · Alan Stern
Quoted 7 lines · Daniel Jordan

A question for memory-barriers.txt aficionados.

Is there a control dependency between the prior load of 'a' and the later store of 'c'?:

   while (READ_ONCE(a));
   WRITE_ONCE(c, 1);

I would say that yes, there is.

Indeed.

Quoted 10 lines

Yes, except that a more accurate view of the object code would be something like this:

Loop:	r1 = READ_ONCE(a);
	if (r1)
		goto Loop;
	else
		;	// Do nothing
	WRITE_ONCE(c, 1);
Quoted 5 lines
Quoted 2 lines

Here you can see that one path branches backward, so everything following the "if" is dependent on the READ_ONCE.

Agreed, and I think I even have code that relies on such a pattern somewhere.. Ah.. yes, see smp_cond_load_acquire().

One does have to be very careful when talking about compiler behavior. This happens to be a particularly delicate point. My old copy of the C++11 draft standard says (section 1.10 paragraph 24):

The implementation may assume that any thread will eventually do one of the following:

�- terminate,
�- make a call to a library I/O function,
�- access or modify a volatile object, or
�- perform a synchronization operation or an atomic operation.

[ Note: This is intended to allow compiler transformations such as removal of empty loops, even when termination cannot be proven. - end note ]

In this example, READ_ONCE() is in fact a volatile access, so we're okay. But if it weren't, the compiler might decide to assume the loop will eventually terminate, meaning that the WRITE_ONCE() would always be executed eventually. Then there would be nothing to prevent the compiler from moving the WRITE_ONCE() up before the start of the loop, which would of course destroy the control dependency.

Alan

#5 lore raw
Quoted 2 lines · Alan Stern

In this example, READ_ONCE() is in fact a volatile access, so we're okay.

But our documentation clearly states a control-dep can only be from a READ_ONCE() (or something stronger), right? So we should be good irrespectively.

#6 lore raw
Quoted 7 lines · Peter Zijlstra
Quoted 2 lines · Alan Stern

In this example, READ_ONCE() is in fact a volatile access, so we're okay.

But our documentation clearly states a control-dep can only be from a READ_ONCE() (or something stronger), right? So we should be good irrespectively.

Agreed. My point was that these are delicate issues. (And they will become more relevant when we want to expand the Linux Kernel Memory Consistency Model to cover ordinary accesses and data races.)

Alan