Question

Hi Sorry for posting a big dump of code but I’m very new at C code, Basically I’m doing an assignment for college and and I have to implement a “pthread_barrier”, now I understand the concept of the barrier (or at least I think I do) But I am just not sure exactly where I should put it. The assignment states:

“Use pthread_barrier_init and pthread_barrier_wait to ensure that all producer/consumer threads begin producing/consuming at the same time.”

This is the extra credit part of the assignment by the way

#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>

#define SIXTY_SECONDS 60000000
#define ONE_SECOND 1000000
#define RANGE 10
#define PERIOD 2

typedef struct {
  int *carpark;
  int capacity;
  int occupied;
  int nextin;
  int nextout;
  int cars_in;
  int cars_out;
  pthread_mutex_t lock;
  pthread_cond_t space;
  pthread_cond_t car;
  pthread_barrier_t bar;
} cp_t;

/* Our producer threads will each execute this function */
static void *
producer(void *cp_in)
{    
  cp_t *cp;
  unsigned int seed;
  /* Convert what was passed in to a pointer to a bounded buffer */
  cp = (cp_t *)cp_in;

    /* Loop */
    while (1) {
    /* Sleep for up to 1s */
    usleep(rand_r(&seed) % ONE_SECOND);
    /* Acquire the lock */
    pthread_mutex_lock(&cp->lock);
    /* While full wait until there is room available */
    while (cp->occupied == cp->capacity) {
      pthread_cond_wait(&cp->car, &cp->lock);
    }
    /* Insert an item */
    cp->carpark[cp->nextin] = rand_r(&seed) % RANGE;
    /* Increment counters */
    cp->occupied++;
    cp->nextin++;
    cp->nextin %= cp->capacity;
    cp->cars_in++;
    /* Someone may be waiting on data to become available */
    pthread_cond_signal(&cp->space);
    /* Release the lock */
    pthread_mutex_unlock(&cp->lock);
  }

  return ((void *)NULL);
}

/* Our consumer threads will each execute this function */
static void *
consumer(void *cp_in)
{

  cp_t *cp;
  unsigned int seed;
  /* Convert what was passed in to a pointer to a bounded buffer */
  cp = (cp_t *)cp_in;

  while (1) {
    /* Sleep for up to 1s */
    usleep(rand_r(&seed) % ONE_SECOND);
    /* Acquire the lock */
    pthread_mutex_lock(&cp->lock);
    /* While empty wait until there is data available */

    while (cp->occupied == 0) {
      pthread_cond_wait(&cp->space, &cp->lock);
    }

    /* Increment counters */
    cp->occupied--;
    cp->nextout++;
    cp->nextout %= cp->capacity;
    cp->cars_out++;
    /* Someone may be waiting on room to become available */
    pthread_cond_signal(&cp->car);
    /* Release the lock */
    pthread_mutex_unlock(&cp->lock);
  }

  return ((void *)NULL);
}

/* Our monitor thread will each execute this function */
static void *
monitor(void *cp_in)
{

  cp_t *cp;
  /* Convert what was passed in to a pointer to a bounded buffer */
  cp = (cp_t *)cp_in;

  while (1) {
    /* Pause */
    sleep(PERIOD);
    /* Acquire the lock */
    pthread_mutex_lock(&cp->lock);
    printf("Delta: %d\n", cp->cars_in - cp->cars_out);
    /* Release the lock */
    pthread_mutex_unlock(&cp->lock);
  }

  return ((void *)NULL);
}

/* Initialisation */
static int
init(cp_t *cp, int capacity)
{

  /* Set up the bounded buffer internals */
  cp->occupied = cp->nextin = cp->nextout = cp->cars_in = cp->cars_out = 0;
  cp->capacity = capacity;
  /* Initialise our data structure */
  cp->carpark = (int *)malloc(cp->capacity * sizeof (*cp->carpark));
  /* Check malloc succeeded */

  if (cp->carpark == NULL) {
    perror("malloc()");
    exit(EXIT_FAILURE);
  }

  /* Initialise lock and condition variables */
  pthread_mutex_init(&cp->lock, NULL);
  pthread_cond_init(&cp->space, NULL);
  pthread_cond_init(&cp->car, NULL);  
  /* Seed random number generator */
  srand((unsigned int)getpid());

  return (0);
}

int
main(int argc, char *argv[])
{

  pthread_t p, c, m;
  cp_t cp;
  /* Check usage */

  if (argc != 2) {
    printf("Usage: %s buffer_size\n", argv[0]);
    exit(EXIT_FAILURE);
  }

  /* Initialise */
  init(&cp, atoi(argv[1]));
  /* Create our threads */
  pthread_create(&p, NULL, producer, (void *)&cp);
  pthread_create(&p, NULL, producer, (void *)&cp);
  pthread_create(&c, NULL, consumer, (void *)&cp);
  pthread_create(&c, NULL, consumer, (void *)&cp);
  pthread_create(&m, NULL, monitor, (void *)&cp);
  /* Wait for our threads */
  pthread_join(p, NULL);
  pthread_join(p, NULL);
  pthread_join(c, NULL);
  pthread_join(c, NULL);
  pthread_join(m, NULL);

  return (0);
}

Answer 1

I could probably give you the full answer but I am afraid of Lasse V. Karlsen. So I’ll give you hints.

• The barrier object bar is already accessible in your struct cp_t
• Initialize it with pthread_barrier_init, like you initialized the mutexes. There is a correspondence between countand the number of actors.
• Both the producers and consumers need to wait before starting to produce / consume. Get it ?