We’ve been practicing sharing variables between child processes, but when there are some processes trying to access a shared resource, we need a mutex to make it safer. This time to implement the mutex we’ll use semaphores. This semaphores must be also shared variables to work properly.
Related Articles
First, think about semaphores as variables which can be 0 or 1. So if the semaphore is 1, it’s open and we will close (0 value) it after we pass; if it is 0, we’ll wait until it goes 1 (it’s not like a while (semaphore==0); because the operating system will deactivate the process and reactivate it when the semaphore is open and we can use our system resources for anything else).
But, let’s go further, semaphore’s value can be whatever, not just 0 or 1, but if it’s positive, and we want to pass, we will decrement it and it won’t block our process, but if it’s zero or less, our process will block. So we can say a mutex is a semaphore with 1 and 0 values, used to protect a resource.
To use semaphores we must have in mind three basic functions (there are some more):
- sem_init(semaphore, pshared, value): Initialize the semaphore with a known value, pshared can be 0 if we want it to be shared between threads of the process, or another value if we want it to be shared between processes. In this case we will put a 1 here.
- sem_post(semaphore): Increment the semaphore, it’s what we do to free the resource
- sem_wait(semaphore): Decrement the semaphore, if its value is less than zero, blocks the process until we have a value greater or equal than zero. We’ll use this to check if the resource is locked.
In the next example, we’ll increment a number, but to make it a bit more difficult, it will be stored in a string, each increment must be done by a different child process. The final value of x must be 20. On the other hand, I’ve inserted some random waits to simulate a heavy process and provoke a race condition.
We can change SEMAPHORES constant value from 1 to 0 to see how this program behaves in each case:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 | #include <unistd.h> #include <stdlib.h> #include <stdio.h> #include <stdint.h> #include <sys/mman.h> #include <semaphore.h> #include <string.h> #define SEMAPHORES 1 int main() { char *x = mmap(NULL, sizeof(char)*10, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); strcpy(x, "0"); int i; int child; sem_t *semaphore = mmap(NULL, sizeof(sem_t), PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); int temp; sem_init (semaphore, 1, 1); for (i=0; i<10; ++i) { child = fork(); if (child==0) { usleep(rand()%20000); if (SEMAPHORES) sem_wait(semaphore); printf("[%d] Trying to access the resource\n", getpid()); temp=atoi(x); printf("[%d] Using the resource\n", getpid()); temp++; sprintf(x, "%d", temp); if (SEMAPHORES) sem_post(semaphore); printf("[%d] Just used the resource\n", getpid()); usleep(rand()%20000); if (SEMAPHORES) sem_wait(semaphore); printf("[%d] Trying to access the resource\n", getpid()); temp=atoi(x); printf("[%d] Using the resource\n", getpid()); temp++; sprintf(x, "%d", temp); if (SEMAPHORES) sem_post(semaphore); printf("[%d] Just used the resource\n", getpid()); printf("[%d] EXITING\n", getpid()); exit(1); } } while (wait(NULL)>=0); printf("x is: %s\n", x); munmap(x, sizeof(int)); munmap(semaphore, sizeof(sem_t)); return 0; } |
Each time a process wants to enter our critic section, it will be written on screen by its process Id, so we can see when a process is accessing the resource, and we can detect if two or more processes are accessing simultaneously (and we don’t want it). Remember, then final x value must be 20 and without semaphores we may or may have not this value, it isn’t under our control.
Note: To compile the example, include pthread:
$ gcc -o example example.c -lpthread
Photo: Paul Albertella (Flickr) CC-by
