Peterson's Algorithm for Mutual Exclusion | Set 2 (CPU Cycles and Memory Fence)

// Filename: peterson_yieldlock_memoryfence.cpp
// Use below command to compile:
// g++ -pthread peterson_yieldlock_memoryfence.cpp -o peterson_yieldlock_memoryfence

#include<iostream>
#include<thread>
#include<atomic>

std::atomic<int> flag[2];
std::atomic<int> turn;
const int MAX = 1e9;
int ans = 0;

void lock_init()
{
    // Initialize lock by resetting the desire of
    // both the threads to acquire the locks.
    // And, giving turn to one of them.
    flag[0] = flag[1] = 0;

    turn = 0;
}

// Executed before entering critical section
void lock(int self)
{
    // Set flag[self] = 1 saying you want
    // to acquire lock
    flag[self]=1;

    // But, first give the other thread the
    // chance to acquire lock
    turn = 1-self;

    // Memory fence to prevent the reordering
    // of instructions beyond this barrier.
    std::atomic_thread_fence(std::memory_order_seq_cst);

    // Wait until the other thread loses the
    // desire to acquire  lock or it is your
    // turn to get the lock.
    while (flag[1-self]==1 && turn==1-self)

        // Yield to avoid wastage of resources.
        std::this_thread::yield();
}

// Executed after leaving critical section
void unlock(int self)
{
    // You do not desire to acquire lock in future.
    // This will allow the other thread to acquire
    // the lock.
    flag[self]=0;
}

// A Sample function run by two threads created
// in main()
void func(int s)
{
    int i = 0;
    int self = s;
    std::cout << "Thread Entered: " << self << std::endl;
    lock(self);

    // Critical section (Only one thread
    // can enter here at a time)
    for (i=0; i<MAX; i++)
        ans++;

    unlock(self);
}

// Driver code
int main()
{    
    // Initialize the lock 
    lock_init();

    // Create two threads (both run func)
    std::thread t1(func, 0);
    std::thread t2(func, 1);

    // Wait for the threads to end.
    t1.join();
    t2.join();

    std::cout << "Actual Count: " << ans << " | Expected Count: " << MAX*2 << std::endl;

    return 0;
}

// mythread.h (A wrapper header file with assert statements)
#ifndef __MYTHREADS_h__
#define __MYTHREADS_h__

#include <pthread.h>
#include <cassert>
#include <sched.h>

// Function to lock a pthread mutex
void Pthread_mutex_lock(pthread_mutex_t *m)
{
    int rc = pthread_mutex_lock(m);
    assert(rc == 0); // Assert that the mutex was locked successfully
}
                                                                                
// Function to unlock a pthread mutex
void Pthread_mutex_unlock(pthread_mutex_t *m)
{
    int rc = pthread_mutex_unlock(m);
    assert(rc == 0); // Assert that the mutex was unlocked successfully
}
                                                                                
// Function to create a pthread
void Pthread_create(pthread_t *thread, const pthread_attr_t *attr,     
           void *(*start_routine)(void*), void *arg)
{
    int rc = pthread_create(thread, attr, start_routine, arg);
    assert(rc == 0); // Assert that the thread was created successfully
}

// Function to join a pthread
void Pthread_join(pthread_t thread, void **value_ptr)
{
    int rc = pthread_join(thread, value_ptr);
    assert(rc == 0); // Assert that the thread was joined successfully
}

#endif // __MYTHREADS_h__