[intro.execution] p7 Does the evaluation that initates a side effect need to be executed by the thread to produce the side effect

[xmh0511]

Full name of submitter (unless configured in github; will be published with the issue): Jim X

[intro.execution] p7 says:

Evaluation of an expression (or a subexpression) in general includes both value computations (including determining the identity of an object for glvalue evaluation and fetching a value previously assigned to an object for prvalue evaluation) and initiation of side effects.

This wording only says evaluation includes initiating the side effect. However, it says nothing about whether the evaluation needs to be executed by the thread in which the expression appears. Consider this example:

#include <atomic>
#include <iostream>
#include <chrono>
#include <thread>
#include <cassert>

int main(){
  std::atomic<int> val = {0};
  auto t1 = std::thread([&]() {
     auto r = val.load(std::memory_order::relaxed); // #1
    assert(r==1);
  });
  auto t2 = std::thread([&]() {
      std::this_thread::sleep_for(std::chrono::milliseconds(6000)); // #2
      val.store(1,std::memory_order::release); // #4
  });
  t1.join();
  std::cout<<"t1 completed\n";
  t2.join();
}

#1 and #4 are unordered, so the allowed values read by #1 are regulated by [intro.races] p10

The value of an atomic object M, as determined by evaluation B, is the value stored by some unspecified side effect A that modifies M, where B does not happen before A.

So, #4 is allowed to be loaded by #1. This could cause a possible execution that #1 loads 1 and t1 exits, but simultaneously #4 has not been executed by thread t2 due to the sleep.

The issue is that if #1 loads value 1, does it mean thread t2 has executed #4? If t2 has not executed #4 yet, where is that side effect produced from? It sounds like #1 loads a future value.

Does the evaluation need to be executed by the thread to produce the side effect, instead that the evaluation merely appear in the source code? If a load reads the value, does the corresponding evaluation need to have already been executed by the thread, or is the evaluation only required to be executed somewhere in the lifetime of the program?

This seems to be vague in the current standard.

[frederick-vs-ja]

However, it says nothing about whether the evaluation needs to be executed by the thread in which the expression appears.

Correction seems needed. How can an expression appear in a thread?

Does the evaluation need to be executed by the thread to produce the side effect, instead that the evaluation merely appear in the source code?

Similarly, how can an evaluation appear in the source code?

[xmh0511]

However, it says nothing about whether the evaluation needs to be executed by the thread in which the expression appears.

Correction seems needed. How can an expression appear in a thread?

Does the evaluation need to be executed by the thread to produce the side effect, instead that the evaluation merely appear in the source code?

Similarly, how can an evaluation appear in the source code?

I meant that the evaluation of the expression is executed by the thread, where "the thread" refers to the thread that would invoke the function in which the expression syntactically appears.

[t3nsor]

Side effects don't exist until they're produced by an evaluation.

[xmh0511]

until they're produced by an evaluation.

How does an evaluation produce the side effect? Does that evaluation need to be executed by the thread? If the thread needs to execute the evaluation to produce the side effect, and a load sees the side effect, by your utterance, does it mean the evaluation has already produced the side effect(i.e., the thread has already executed the evaluation)? This contradicts the described possible execution in the issue.

[t3nsor]

There is no "already". For two different threads there is no global linear time. In the thread that causes the side effect, the side effect does not exist until the evaluation that produces it occurs. In the other thread, in order to load the value produced by that side effect, it must be the case that the side effect exists. However, if the side effect exists, you can't necessarily say whether the side effect was produced before or after the load. If the side effect doesn't exist, then you of course can't load the value that it produces.

[xmh0511]

In the other thread, in order to load the value produced by that side effect, it must be the case that the side effect exists.

«must be the case that the side effect exists» How is the order of the existence of the side effect relative to loading? I mean, do you mean the side effect must be produced at the point when the load in another thread reads it? (not sure this implies there is a global timeline.)

However, if the side effect exists, you can't necessarily say whether the side effect was produced before or after the load. If the side effect doesn't exist, then you of course can't load the value that it produces.

Do you mean, to let the load in another thread read the side effect, the side effect must exist somewhere in the whole lifetime of the program? This is what "exist" you mean?

The latter should be a right read; however, its meaning is not very explicit in the current wording.

[frederick-vs-ja]

This seems touching the OOTA (Out Of Thin Air) problem.

[xmh0511]

This seems touching the OOTA (Out Of Thin Air) problem.

There is no circular dependency on value computation here.