104 lines
4.9 KiB
C
104 lines
4.9 KiB
C
|
/************************************************************************
|
||
|
|
* *
|
||
|
|
* file: sem.c *
|
||
|
|
* *
|
||
|
|
* Module implementing semaphores. *
|
||
|
|
* *
|
||
|
|
* All routines should call thread_yield() where reasonable to encourage*
|
||
|
|
* fair execution. *
|
||
|
|
* *
|
||
|
|
* Note that our implementation assumes that threads calling us are not *
|
||
|
|
* subject to arbitrary preemption - if they were, we would need to *
|
||
|
|
* add a protecting spin lock to our semaphore implementation. *
|
||
|
|
* *
|
||
|
|
************************************************************************/
|
||
|
|
|
||
|
|
#include "sem.h"
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <stdio.h>
|
||
|
|
|
||
|
|
/* External stuff defined in thread.c.
|
||
|
|
*/
|
||
|
|
extern Queue ready_queue;
|
||
|
|
extern int thread_block_and_switch(Queue* q);
|
||
|
|
|
||
|
|
/************************************************************************
|
||
|
|
* INTERFACE: sem_create() *
|
||
|
|
* *
|
||
|
|
* Make and return a semaphore (i.e. return a pointer to a Sem struct). *
|
||
|
|
* This will involve allocating a Sem structure using malloc(), *
|
||
|
|
* creating/initialising a queue for threads blocked on the *
|
||
|
|
* semaphore and also initialising the semaphore to the value specified *
|
||
|
|
* by our caller. This value must be validated to be >= 0. The *
|
||
|
|
* function can only fail if malloc() fails - in this case we return *
|
||
|
|
* (Sem *)0. *
|
||
|
|
************************************************************************/
|
||
|
|
Sem* sem_create(int val)
|
||
|
|
{
|
||
|
|
Sem* s;
|
||
|
|
|
||
|
|
if (val < 0 || ((s = (Sem*)malloc(sizeof(Sem))) == (Sem*)0))
|
||
|
|
return (Sem*)0;
|
||
|
|
|
||
|
|
s->val = val;
|
||
|
|
queue_init(&(s->queue));
|
||
|
|
thread_yield();
|
||
|
|
return s;
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************
|
||
|
|
* INTERFACE: sem_destroy() *
|
||
|
|
* *
|
||
|
|
* Destroy a semaphore. *
|
||
|
|
* Forbid destruction (return -1) if the semaphore has waiting threads. *
|
||
|
|
* Otherwise return 1 for success. *
|
||
|
|
************************************************************************/
|
||
|
|
int
|
||
|
|
sem_destroy(Sem* s)
|
||
|
|
{
|
||
|
|
if (!queue_empty(&(s->queue))) return -1;
|
||
|
|
free((void*)s);
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************
|
||
|
|
* INTERFACE: sem_P() *
|
||
|
|
* *
|
||
|
|
* Standard semaphore operation. *
|
||
|
|
* That is, decrement the value of the semaphore and if this takes *
|
||
|
|
* its value below 0 block the calling thread on the semaphore's queue *
|
||
|
|
* using thread_block_and_switch(). *
|
||
|
|
* We know that a semaphore value can't theoretically get less than 0, *
|
||
|
|
* but we internally (hidden from the semaphore user) use the negative *
|
||
|
|
* range of val to record how many threads are currently blocked on the *
|
||
|
|
* semaphore. *
|
||
|
|
************************************************************************/
|
||
|
|
void
|
||
|
|
sem_P(Sem* s)
|
||
|
|
{
|
||
|
|
if (--s->val < 0) thread_block_and_switch(&(s->queue));
|
||
|
|
else thread_yield();
|
||
|
|
}
|
||
|
|
|
||
|
|
/************************************************************************
|
||
|
|
* INTERFACE: sem_V() *
|
||
|
|
* *
|
||
|
|
* Standard semaphore operation. *
|
||
|
|
* That is, increment the value of the semaphore. If there were threads *
|
||
|
|
* blocked on the semaphore (i.e. the value after incrementing the *
|
||
|
|
* semaphore is still <= 0), we get the first thread from the *
|
||
|
|
* semaphore's queue and put it on the thread package's ready queue *
|
||
|
|
* using queue_put(). *
|
||
|
|
* Because the sem module is solely responsible for managing a sem's *
|
||
|
|
* queue, we can guarantee that if (s->val <= 0) there is always an *
|
||
|
|
* item on the sem's queue. *
|
||
|
|
************************************************************************/
|
||
|
|
void
|
||
|
|
sem_V(Sem *s)
|
||
|
|
{
|
||
|
|
if (++s->val <= 0) queue_put(&ready_queue, queue_get(&(s->queue)));
|
||
|
|
thread_yield();
|
||
|
|
}
|
||
|
|
|
||
|
|
/* end file: sem.c */
|