Peterson's Algorithm on C++ multithreading - c++

Question

I've written a simple implementation for Peterson's Algorithm in C++ with multi threading. This program changes the string through two threads. But I'm not getting the final result. Where am I wrong?
using namespace std;
int flag[2]={0,1};
int turn;
void* first(void* data){
flag[0]=1;
turn=1;
while(flag[1] && turn==1){}
string &str=*(static_cast<string*>(data));
if(str!=""){
if(str=="abcd"){
str="Hello";
}
}
flag[0]=0;
pthread_exit(NULL);
}
void* second(void* data){
flag[1]=1;
turn=0;
while(flag[0] && turn==0){}
string &str=*(static_cast<string*>(data));
if(str!=""){
if(str=="wxyz"){
str="abcd";
}
}
flag[1]=0;
pthread_exit(NULL);
}
int main(){
int rc=0;
string s = "wxyz";
pthread_t t;
rc=pthread_create(&t,NULL,first,static_cast<void*>(&s));
if(rc!=0){
cout<<"error!";
exit(rc);
}
rc=pthread_create(&t,NULL,second,static_cast<void*>(&s));
if(rc!=0){
cout<<"error!";
exit(rc);
}
while(flag[0] && flag[1]!=0){}
cout<<s;
pthread_exit(NULL);
return 0;
}

Answer 1

Prior to C++11 there was no threading model in C++. After C++11, your code does unordered access to the same variable causing race conditions.
Race conditions result in undefined behavior.
Changing a std::string is not atomic. You cannot do it safely while other threads are reading or writing from it.
In C++11 the threading primitives of std are a better idea than the above raw pthread code, excluding the very rare features you cannot emulate.

Answer 2

Refactored to use atomics. Note the explicit fences to guarantee correct ordering or reads/writes to the (non-atomic) string across threads.
Maybe someone would like to sanity-check my logic?
#include <iostream>
#include <thread>
#include <atomic>
#include <memory>
using namespace std;
// atomic types require the compiler to issue appropriate
// store-release/load-acquire ordering
std::atomic<int> flag[2]={{0},{1}};
std::atomic<int> turn;
void first(std::string& str){
flag[0]=1;
turn=1;
while(flag[1] && turn==1){}
std::atomic_signal_fence(std::memory_order_acquire);
if(str!=""){
if(str=="abcd"){
str="Hello";
std::atomic_signal_fence(std::memory_order_release);
}
}
flag[0]=0;
}
void second(std::string& str){
flag[1]=1;
turn=0;
while(flag[0] && turn==0){}
std::atomic_signal_fence(std::memory_order_acquire);
if(str!=""){
if(str=="wxyz"){
str="abcd";
std::atomic_signal_fence(std::memory_order_release);
}
}
flag[1]=0;
}
int main(){
string s = "wxyz";
auto t1 = std::thread(first, std::ref(s));
auto t2 = std::thread(second, std::ref(s));
for( ; flag[0] && flag[1]; )
;
std::atomic_signal_fence(std::memory_order_acquire);
cout << s << endl;
t1.join();
t2.join();
return 0;
}
expected output:
wxyz
Endnote:
Modern memory architectures are not what they were when this algorithm was invented. Reads and writes to memory don't happen when you expect on a modern chip, and sometimes don't happen at all.
Cancel your appointments for the next 3 hours and watch this fantastic talk on the subject:
https://channel9.msdn.com/Shows/Going+Deep/Cpp-and-Beyond-2012-Herb-Sutter-atomic-Weapons-1-of-2

Answer 3

I had to make the threads wait till the thread first has finished, so I created separate threads, t for first and u for second and make main wait by pthread_join till the threads have finished. This removed the need to main spin.
Changes:
pthread_t t,u;
pthread_create(&t,NULL,first,static_cast<void*>(&s));
pthread_create(&u,NULL,second,static_cast<void*>(&s));
pthread_join(u,NULL);
pthread_join(t,NULL);
//while(flag[0] && flag[1]!=0){}
cout<<s;
The atomic fence in functions remained as they ensured ordered execution of instructions.
OUTPUT
abcd
and
Hello
And although changing the order of pthread_createof first and second always outputs to Hello, It kills the very idea of first thread waiting for second thread to complete. So I think the above changes will be the answer to it.