Operating System
Assignment: 3
SP22-BCS-136
1.Implementing a Mutex Lock:
#include <mutex>
#include <thread>
#include <iostream>
using namespace std;
mutex mtx;
void accessSharedResource(int threadId)
lock_guard<mutex> lock(mtx);
cout << "Thread " << threadId << " acquired the lock." << endl;
this_thread::sleep_for(chrono::milliseconds(100));
cout << "Thread " << threadId << " releasing the lock." << endl;
}
int main()
thread t1(accessSharedResource, 1);
thread t2(accessSharedResource, 2);
thread t3(accessSharedResource, 3);
t1.join();
t2.join();
t3.join();
return 0;
output:
1. Semaphore Implementation:
#include <condition_variable>
#include <atomic>
#include <mutex>
#include <thread>
#include <iostream>
using namespace std;
mutex mtx;
condition_variable cv;
atomic<int> count;
const int MAX_COUNT = 3;
void accessSharedResource(int threadId)
unique_lock<mutex> lock(mtx);
cv.wait(lock, []
{ return count.load() < MAX_COUNT; });
count.fetch_add(1);
cout << "Thread " << threadId << " acquired the semaphore." << endl;
this_thread::sleep_for(chrono::milliseconds(100));
cout << "Thread " << threadId << " releasing the semaphore." << endl;
lock.unlock();
cv.notify_one();
int main()
count.store(0);
thread t1(accessSharedResource, 1);
thread t2(accessSharedResource, 2);
thread t3(accessSharedResource, 3);
thread t4(accessSharedResource, 4);
thread t5(accessSharedResource, 5);
t1.join();
t2.join();
t3.join();
t4.join();
t5.join();
return 0;
output:
2. Peterson's Solution Implementation:
#include <iostream>
#include <sys/mman.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <mutex>
#include <thread>
#include <sys/wait.h>
const int PROCESS_COUNT = 2;
struct SharedMemory
{
std::mutex mtx;
int turn;
bool flag[PROCESS_COUNT];
SharedMemory() : turn(0), flag{false, false} {}
};
const int SHARED_MEMORY_SIZE = sizeof(struct SharedMemory);
void enterCriticalSection(struct SharedMemory *shm, int processId)
{
shm->flag[processId] = true;
shm->turn = processId;
while (shm->turn == processId && shm->flag[1 - processId])
;
}
void leaveCriticalSection(struct SharedMemory *shm, int processId)
{
shm->flag[processId] = false;
}
void process(int processId)
{
int fd = shm_open("/my_shared_memory", O_RDWR | O_CREAT, 0666);
ftruncate(fd, SHARED_MEMORY_SIZE);
struct SharedMemory *shm = static_cast<struct SharedMemory
*>(mmap(NULL, SHARED_MEMORY_SIZE, PROT_READ | PROT_WRITE,
MAP_SHARED, fd, 0));
close(fd);
for (int i = 0; i < 10; i++)
{
enterCriticalSection(shm, processId);
std::cout << "Process " << processId << " entered the critical section."
<< std::endl;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::cout << "Process " << processId << " left the critical section." <<
std::endl;
leaveCriticalSection(shm, processId);
}
munmap(shm, SHARED_MEMORY_SIZE);
}
int main()
{
pid_t pids[PROCESS_COUNT];
for (int i = 0; i < PROCESS_COUNT; i++)
{
pids[i] = fork();
if (pids[i] == 0)
{
process(i);
return 0;
}
else if (pids[i] < 0)
{
std::cerr << "Error in fork." << std::endl;
return 1;
}
}
for (int i = 0; i < PROCESS_COUNT; i++)
{
waitpid(pids[i], NULL, 0);
}
return 0;
}
output:
3. Producer-Consumer Problem with Mutex:
#include <iostream>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <chrono>
using namespace std;
const int BUFFER_SIZE = 5;
queue<int> sharedBuffer;
mutex mtx;
condition_variable cvProducer, cvConsumer;
bool finishedProducing = false;
void producer(int id)
for (int i = 0; i < 10; i++)
unique_lock<mutex> lock(mtx);
cvProducer.wait(lock, []
{ return sharedBuffer.size() < BUFFER_SIZE; });
int item = i;
sharedBuffer.push(item);
cout << "Producer " << id << " produced item " << item << endl;
cvConsumer.notify_one();
lock.unlock();
this_thread::sleep_for(chrono::milliseconds(100));
finishedProducing = true;
void consumer(int id)
while (!finishedProducing || !sharedBuffer.empty())
unique_lock<mutex> lock(mtx);
cvConsumer.wait(lock, []
{ return !sharedBuffer.empty(); });
int item = sharedBuffer.front();
sharedBuffer.pop();
cout << "Consumer " << id << " consumed item " << item << endl;
cvProducer.notify_one();
lock.unlock();
this_thread::sleep_for(chrono::milliseconds(100));
int main()
thread producer1(producer, 1);
thread producer2(producer, 2);
thread consumer1(consumer, 1);
thread consumer2(consumer, 2);
producer1.join();
producer2.join();
consumer1.join();
consumer2.join();
return 0;
output:
4. Reader-Writer Problem with Semaphores:
#include <iostream>
#include <queue>
#include <mutex>
#include <condition_variable>
#include <thread>
#include <chrono>
#include <semaphore.h>
const int MAX_READERS = 5;
const int MAX_WRITERS = 2;
sem_t rw_mutex, wr_mutex;
sem_t readers_mutex;
int readers = 0;
void reader(int id)
{
sem_wait(&readers_mutex);
readers++;
if (readers == 1)
sem_wait(&wr_mutex);
sem_post(&readers_mutex);
std::cout << "Reader " << id << " started reading." << std::endl;
// simulate reading
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::cout << "Reader " << id << " finished reading." << std::endl;
sem_wait(&readers_mutex);
readers--;
if (readers == 0)
{
sem_post(&wr_mutex);
sem_post(&readers_mutex);
void writer(int id)
sem_wait(&wr_mutex);
std::cout << "Writer " << id << " started writing." << std::endl;
// simulate writing
std::this_thread::sleep_for(std::chrono::milliseconds(100));
std::cout << "Writer " << id << " finished writing." << std::endl;
sem_post(&wr_mutex);
}
int main()
sem_init(&rw_mutex, 0, 1);
sem_init(&wr_mutex, 0, 1);
sem_init(&readers_mutex, 0, 1);
std::thread reader1(reader, 1);
std::thread reader2(reader, 2);
std::thread reader3(reader, 3);
std::thread reader4(reader, 4);
std::thread reader5(reader, 5);
std::thread writer1(writer, 1);
std::thread writer2(writer, 2);
reader1.join();
reader2.join();
reader3.join();
reader4.join();
reader5.join();
writer1.join();
writer2.join();
sem_destroy(&rw_mutex);
sem_destroy(&wr_mutex);
sem_destroy(&readers_mutex);
return 0;
output:
