【読書ノート】linuxシステムはsemaphoreで古典的な生産者-消費者問題を解決する

    typedef struct 
    {
        int * buf;     // buffer array
        int   n;       // maximum number of slots
        int   front;   // buf[(front+1) % n] is first item
        int   rear;    // buf[rear % n] is last item
        sem_t mutex;   // protects accesses to buf
        sem_t slots;   // counts available slots
        sem_t items;   // counts available items
    } sbuf_t;

    // create an empty, bounded, shared FIFO buffer with n slots
    void sbuf_init(sbuf_t * sp, int n)
    {
        sp->buf = calloc(n, sizeof(int));   
        sp->n   = n;                        // buffer holds max of n items
        sp->front = sp->rear = 0;           // empty buffer if front == rear
        sem_init(&sp->mutex, 0, 1);         // binary semaphore for mutex-locking
        sem_init(&sp->slots, 0, n);         // initially, buf has n empty slots 
        sem_init(&sp->items, 0, 0);         // initially, buf has zero data items
    }

    // clean up buffer sp
    void sbuf_deinit(sbuf_t * sp)
    {
        free(sp->buf);
    }

    // insert item onto the rear of shared buffer sp, it's an abstract of producer
    void sbuf_insert(sbuf_t * sp, int item)
    {
         P(&sp->slots);                            // wait for available slot
         P(&sp->mutex);                            // lock the buffer
         sp->buf[(++sp->rear) % (sp->n)] = item;   // insert the item
         V(&sp->mutex);                            // unlock the buffer
         V(&sp->items);                            // announce available ite
    }

    // remove and return the first item from buffer sp,  it's an abstract of consumer
    void sbuf_remove(sbuf_t * sp)
    {
         int item;
         P(&sp->items);                             // wait for available item
         P(&sp->mutex);                             // lock the buffer
         item = sp->buf[(++sp->front) % (sp->n)];   // remove the item
         V(&sp->mutex);                             // unlock the buffer
         V(&sp->slots);                             // announce available slot
         return item;  
    }