Ongoing Optimization

Now it's time to put the theory into practice. The job is quite easy. A small program should undergo an ongoing optimization.

The program

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// ongoingOptimization.cpp

#include <iostream>
#include <thread>

int x= 0;
int y= 0;

void writing(){
  x= 2000;
  y= 11;
}

void reading(){ 
  std::cout << "y: " << y << " ";
  std::cout << "x: " << x << std::endl;
}

int main(){
  std::thread thread1(writing);
  std::thread thread2(reading);
  thread1.join();
  thread2.join();
}

The program is quite simple. It consists of two threads thread1 and thread2.thread1 writes the values x and y. thread 2 reads the values x and y in the opposite direction.  The execution of the program is not so thrilling either.

But you see, even this simple program has different results. So I finally come to my key idea.

In the process of the ongoing optimization of the program, I have two questions in my mind.

1. Is the program well defined? Precisely, is there a data race?
2. Which values for x and y are possible?

The first question is often very challenging to answer. So I will reason in the first step about the program and I will verify in the second step my reasoning with CppMem.  If I have answered the first question, the second answer can easily be derived. I will provide the possible values in a table.

But still, one question isn't answered yet? What do I mean by ongoing optimization? I mean by ongoing optimization, that I try to improve the program by weakening the C++ memory model. So in my journey, I discuss the following stations.

• Non-atomic variables
• Locks
• Atomics with sequential consistency
• Atomics with acquire-release semantic
• Atomics with relaxed semantic
• Volatile variables

What's next?

Of course, this was a very short post. But this post should provide you only the context of my ongoing optimization. In case you are bored, reason about the small program and answer the two question.

1. Is the program well defined?
2. Which values for x and y are possible?

Still bored? Then reason about the weakening of the memory model in the program and about the consequences. In the next post, I will analyse the unsynchronized access with the help of CppMem. Stay tuned.