using memory mapped files for in global variables - c

Question

I wrote the following code for the famous sleeping barber problem, but now I found out i had to use memory mapped files instead of global variables. How Can I do that?I have no idea about memory mapped files.
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <semaphore.h>
#define MAX_CUSTOMERS 5
void *customer(void *num);
void *barber(void *);
// CWait is used to make the customer to wait until the barber is done cutting his/her hair.
sem_t CWait;
// waitingRoom Limits the # of customers allowed to enter the waiting room at one time.
sem_t waitingRoom;
// barberChair ensures mutually exclusive access to the barber chair.
sem_t barberChair;
// barberPillow is used to allow the barber to sleep until a customer arrives.
sem_t barberPillow;
// Flag to stop the barber thread when all customers have been serviced.
int allDone = 0;
int main(int argc, char *argv[])
{
pthread_t btid;
pthread_t tid[MAX_CUSTOMERS];
int i, numChairs;
int Number[MAX_CUSTOMERS];
numChairs = MAX_CUSTOMERS; //number of chairs will be equal to max num of costumers
printf("A solution to the sleeping barber problem using semaphores.\n");
for (i = 0; i < MAX_CUSTOMERS; i++) {
Number[i] = i;
}
sem_init(&waitingRoom, 0, numChairs);
sem_init(&barberChair, 0, 1);
sem_init(&barberPillow, 0, 0);
sem_init(&CWait, 0, 0);
// Create the barber.
pthread_create(&btid, NULL, barber, NULL);
// Create the customers.
for (i = 0; i < MAX_CUSTOMERS; i++) {
pthread_create(&tid[i], NULL, customer, (void *)&Number[i]);
}
// Join each of the threads to wait for them to finish.
for (i = 0; i < MAX_CUSTOMERS; i++) {
pthread_join(tid[i],NULL);
}
// When all of the customers are finished, kill the barber thread.
allDone = 1;
sem_post(&barberPillow); // Wake the barber so he will exit.
pthread_join(btid,NULL);
return 0;
}
void *customer(void *number) {
int num = *(int *)number; // Leave for the shop and take some random amount of time to arrive.
sleep(1);
printf("Customer %d arrived at barber shop.\n", num); // Wait for space to open up in the waiting room...
sem_wait(&waitingRoom);
printf("Customer %d entering waiting room.\n", num); // Wait for the barber chair to become free.
sem_wait(&barberChair); // The chair is free so give up your spot in the waiting room.
sem_post(&waitingRoom); // Wake up the barber...
printf("Customer %d waking the barber.\n", num);
sem_post(&barberPillow); // Wait for the barber to finish cutting your hair.
sem_wait(&CWait); // Give up the chair.
sem_post(&barberChair);
printf("Customer %d leaving barber shop.\n", num);
}
void *barber(void *junk)
{
// While there are still customers to be serviced... Our barber is omniscient and can tell if there are customers still on the way to his shop.
while (!allDone) { // Sleep until someone arrives and wakes you..
printf("The barber is sleeping\n");
sem_wait(&barberPillow); // Skip this stuff at the end...
if (!allDone)
{ // Take a random amount of time to cut the customer's hair.
printf("The barber is cutting hair\n");
sleep(1);
printf("The barber has finished cutting hair.\n"); // Release the customer when done cutting...
sem_post(&CWait);
}
else {
printf("The barber is going home for the day.\n");
}
}
}

Answer 1

Using memory mapped files to share entirely within a single processes is a bit strange, but is certainly doable.
Let's say you need to share a read-write variable of type some_type_t named var_name.
First use the shm_open call:
var_fd = shm_open("var_name", O_CREAT, S_IRUSR | S_IWUSR)
This creates a new file descriptor for our variable.
Next we allocate the space for the variable:
some_type_t *var_ptr;
var_ptr = mmap(NULL, sizeof(some_type_t), PROT_READ | PROT_WRITE, MAP_PRIVATE, var_fd, 0);
You can now access the variable through *var_ptr; e.g. *var_ptr = 42
You can even skip the shm_open call and just do:
var_ptr = mmap(NULL, sizeof(some_type_t), PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, 0, 0)
I left out error checking and deallocating the variable once you are done.