Question

operating system engineering , please read the question and solve on the given skeleton code .

Write a multi-threaded program with Semaphores as counters and pthread_mutex_t mutex to solve the producer-consumer problem: A bounded buffer is simply a global integer array of size N (2) which can be accessed by multiple threads. • Create two types of threads - Producer (2) and Consumer (2). Producers will write to the buffer, and the consumers will read the buffer. In this scenario, threads with even IDs will be producers and those with odd IDs will be the consumers. Only threads with even IDs will be producers. Only threads with odd IDs will be consumers. Initialize two global integer variables-next_in and next_out, these two variables will be used by the threads to track the next index of the buffer to write to or read from. The Producer thread will update the buffer at index next_in, and it will increment (+1) the next_in variable; incase the next_in == 2, the thread will set the next_in= 0. The Consumer will read the buffer at index at next_out, and will have to print out the variable that was read on the screen. It shall also increment (+1) next_out, and if next_out == 2, the thread will set next_out = 0. To avoid race conditions between the threads, you will use 1 mutex, of type pthread_mutex_t *mutex. Any thread that wants access to the critical section will have to lock this mutex 2 critical sections - one for Producers and one for Consumers. Semaphores will be used to count the number of empty and number of filled slots in the shared bounded buffer, and this will help with synchronization. Following below guidelines: Producer thread will acquire the semaphore empty. Initialize the empty semaphore to the size of the buffer and it should be a global semaphore. Producer will signal the full semaphore while it exits the critical section. Initialize the full semaphore to 0 (indicating that the buffer is initially not fully and it should be a global semaphore. Consumer thread must acquire the full semaphore if it wants to enter the critical section. Initialization information has been discussed in the above point. Consumer thread must signal the empty semaphore while exiting the critical section Variables 1. Mutex of type semaphore. 2. 2 counting semaphores for tracking. 3. Bounded buffer of size 2. Course Title: Operating Systems Engineering Course Code: CE469 41 Page

Answer 1

semaphores.c

#include "semaphores.h"

#ifdef WIN32

#include <Windows.h>
#include <stdlib.h>

struct _SemaphoreData
{
HANDLE counter;
size_t count, maxCount;
};

Semaphore Sem_Create( size_t startCount, size_t maxCount )
{
Semaphore sem = (Semaphore) malloc( sizeof(SemaphoreData) );
sem->counter = CreateSemaphore( NULL, startCount, maxCount, NULL );
sem->count = startCount;
sem->maxCount = maxCount;
  
return sem;
}

void Sem_Discard( Semaphore sem )
{
CloseHandle( sem->counter );
free( sem );
}

void Sem_Increment( Semaphore sem )
{
ReleaseSemaphore( sem->counter, 1, &(sem->count) );
sem->count++;
}

void Sem_Decrement( Semaphore sem )
{
WaitForSingleObject( sem->counter, INFINITE );
sem->count--;
}

size_t Sem_GetCount( Semaphore sem )
{
if( sem == NULL ) return 0;
  
return sem->count;
}

void Sem_SetCount( Semaphore sem, size_t count )
{
if( sem == NULL ) return;
  
if( count > sem->maxCount ) count = sem->maxCount;

size_t countDelta = (size_t) abs( (int) count - (int) sem->count );
if( count > sem->count )
{
for( size_t i = 0; i < countDelta; i++ )
Sem_Increment( sem );
}
else if( count < sem->count )
{
for( size_t i = 0; i < countDelta; i++ )
Sem_Decrement( sem );
}
}

#else // Unix

#include <semaphore.h>
#include <stdlib.h>
#include <malloc.h>

struct _SemaphoreData
{
sem_t upCounter;
sem_t downCounter;
size_t maxCount;
};

Semaphore Sem_Create( size_t startCount, size_t maxCount )
{
Semaphore sem = (Semaphore) malloc( sizeof(SemaphoreData) );
sem_init( &(sem->upCounter), 0, maxCount - startCount );
sem_init( &(sem->downCounter), 0, startCount );
  
sem->maxCount = maxCount;
  
return sem;
}

void Sem_Discard( Semaphore sem )
{
sem_destroy( &(sem->upCounter) );
sem_destroy( &(sem->downCounter) );
free( sem );
}

void Sem_Increment( Semaphore sem )
{
sem_wait( &(sem->upCounter) );
sem_post( &(sem->downCounter) );
}

void Sem_Decrement( Semaphore sem )
{
sem_wait( &(sem->downCounter) );
sem_post( &(sem->upCounter) );
}

size_t Sem_GetCount( Semaphore sem )
{
int countValue;
sem_getvalue( &(sem->downCounter), &countValue );
  
return (size_t) countValue;
}

void Sem_SetCount( Semaphore sem, size_t count )
{
if( count <= sem->maxCount )
{
size_t currentCount = Sem_GetCount( sem );
  
if( currentCount > count )
{
for( size_t i = count; i < currentCount; i++ )
Sem_Decrement( sem );
}
else if( currentCount < count )
{
for( size_t i = currentCount; i < count; i++ )
Sem_Increment( sem );
}
}
}

i hope this is helpful to you!

Thank you!