Hello, i am having trouble with editing a program in C. I included the things I am having trouble with below as well as the code I have so far. Can you help me?

Problems:

1. Initialize the global variable buffer: occupied = 0; nextin = 0;, nextout = 0; initialize the mutex and condition variable fields in the structure as well.

2. Write runner functions for the producer and consumer threads. These runner functions will call producer and consumer functions given in oracle.c respectively.

The producer thread will randomly generate an item, which is a character, and call the producer function void producer(buffer_t *b, char item) to put the character in the buffer.

The consumer thread will call char consumer(buffer_t *b) to remove an item, a character, from the buffer, and display the character to screen.

3. Create two producer threads and a consumer thread.

4. The main thread will wait for the new threads to terminate.

5. The main thread will destroy the mutex and condition variables.

You may define the buffer size as 10, and let the producer threads to generate 20 items each, and the consumer thread to remove 40 characters from the buffer.

pthreads_cond.c:

#include #include #include

#define NUM_THREADS 3 #define TCOUNT 10 #define COUNT_LIMIT 12

int count = 0; int thread_ids[3] = {0,1,2}; pthread_mutex_t count_mutex; pthread_cond_t count_threshold_cv;

void *inc_count(void *t) { int i; long my_id = (long)t;

for (i=0; i

/* Check the value of count and signal waiting thread when condition is reached. Note that this occurs while mutex is locked. */ if (count == COUNT_LIMIT) { pthread_cond_signal(&count_threshold_cv); printf("inc_count(): thread %ld, count = %d Threshold reached. ", my_id, count); } printf("inc_count(): thread %ld, count = %d, unlocking mutex ", my_id, count); pthread_mutex_unlock(&count_mutex);

/* Do some "work" so threads can alternate on mutex lock */ sleep(1); } pthread_exit(NULL); }

void *watch_count(void *t) { long my_id = (long)t;

printf("Starting watch_count(): thread %ld ", my_id);

/* Lock mutex and wait for signal. Note that the pthread_cond_wait routine will automatically and atomically unlock mutex while it waits. Also, note that if COUNT_LIMIT is reached before this routine is run by the waiting thread, the loop will be skipped to prevent pthread_cond_wait from never returning. */ pthread_mutex_lock(&count_mutex); while (count

int main (int argc, char *argv[]) { int i, rc; long t1=1, t2=2, t3=3; pthread_t threads[3]; pthread_attr_t attr; /* Initialize mutex and condition variable objects */ pthread_mutex_init(&count_mutex, NULL); pthread_cond_init (&count_threshold_cv, NULL); /* For portability, explicitly create threads in a joinable state */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&threads[0], &attr, watch_count, (void *)t1); pthread_create(&threads[1], &attr, inc_count, (void *)t2); pthread_create(&threads[2], &attr, inc_count, (void *)t3);

/* Wait for all threads to complete */ for (i=0; i

/* Clean up and exit */ pthread_attr_destroy(&attr); pthread_mutex_destroy(&count_mutex); pthread_cond_destroy(&count_threshold_cv); pthread_exit(NULL);

}

Oracle.c:

typedef struct { char buf[BSIZE]; int occupied; int nextin; int nextout; pthread_mutex_t mutex; pthread_cond_t more; pthread_cond_t less; } buffer_t;

buffer_t buffer;

void producer(buffer_t *b, char item) { pthread_mutex_lock(&b->mutex);

while (b->occupied >= BSIZE) pthread_cond_wait(&b->less, &b->mutex);

assert(b->occupied < BSIZE);

b->buf[b->nextin++] = item;

b->nextin %= BSIZE; b->occupied++;

/* now: either b->occupied < BSIZE and b->nextin is the index of the next empty slot in the buffer, or b->occupied == BSIZE and b->nextin is the index of the next (occupied) slot that will be emptied by a consumer (such as b->nextin == b->nextout) */

pthread_cond_signal(&b->more);

pthread_mutex_unlock(&b->mutex); }

char consumer(buffer_t *b) { char item; pthread_mutex_lock(&b->mutex); while(b->occupied <= 0) pthread_cond_wait(&b->more, &b->mutex);

assert(b->occupied > 0);

item = b->buf[b->nextout++]; b->nextout %= BSIZE; b->occupied--;

/* now: either b->occupied > 0 and b->nextout is the index of the next occupied slot in the buffer, or b->occupied == 0 and b->nextout is the index of the next (empty) slot that will be filled by a producer (such as b->nextout == b->nextin) */

pthread_cond_signal(&b->less); pthread_mutex_unlock(&b->mutex);

return(item); }