printf preventing race conditions

Question

In this example code I do a summation from i=0 to i=n and then add the result to itself k times, where k is the number of threads. I purposely did it without critical (surrounding the printf and ans += ans) to cause race conditions. However, to my surprise, no race condition happened:

int summation_with_operation_after_it_wrong1(int n, int k) {
        int ans = 0;
        #pragma omp parallel firstprivate(n) num_threads(k)
        {
                int i; /* Private */
                #pragma omp for schedule(dynamic) reduction(+:ans)
                for (i = 0; i < n; i++) {
                        ans += i;
                }
                printf("Thread %d ans=%d\n", omp_get_thread_num(), ans);
                ans += ans;    
        }
        return ans;
}

Using n=10 and k=4, the output is (always the same, except for thread order):

Thread 1 ans=45
Thread 3 ans=45
Thread 0 ans=45
Thread 2 ans=45
720

However, I did noticed something odd about it. ans was always 45, instead of

Thread 3 ans=45
Thread 0 ans=90
Thread 2 ans=180
Thread 1 ans=360
720

When using critical. So I moved the printf to after the ans += ans to see what it was doing, and, for my surprise, the predicted race conditions started to occur all the time!

Thread 3 ans=90
Thread 1 ans=135
Thread 2 ans=90
Thread 0 ans=135
135

So... How does the printf prevented race conditions? And how does that sum ended up to be 720? I'm completely lost here.

Perhaps it is because printf() has some 'thread safety' built into it, which forces some serialization. I've not checked, but there are functions like putc_unlocked(), but printf() is written in terms of putc() for character output. So, simply using printf() may impose some sequencing, leaving the program better behaved than you'd expect. — Jonathan Leffler

Massimiliano Massimiliano · Accepted Answer · 2014-05-11T10:32:13

Section 1.4 of the latest OpenMP standard specifies what is the result of a race condition (emphasis mine):

If multiple threads write without synchronization to the same memory unit, including cases due to atomicity considerations as described above, then a data race occurs. Similarly, if at least one thread reads from a memory unit and at least one thread writes without synchronization to that same memory unit, including cases due to atomicity considerations as described above, then a data race occurs. If a data race occurs then the result of the program is unspecified.

What you notice is completely consistent with the statement in bold. In fact, as the behavior in a program containing a data-race is unspecified, it makes little sense to argue why a particular output results from a given run. In particular, it is only by chance that you obtained 720 when inserting a printf before the ans+=ans command, and there's no guarantee that you will always encounter the same behavior.

printf preventing race conditions

2 Answers