Producer/Consumer problem

Hello all,

I have already written the following code which is supposed to take a number MAX as its first argument and then have multiple producers write the values from 1 to MAX to the buffer and have multiple consumers output these values. The producers and consumers are supposed to sleep 0.001 time after they execute.

My code is done but it has one flaw. I create the producers in a for loop and only the 1st producer gets to store values into the buffer. After that the rest of the producers are created but there is no work for them. The same happens with the consumers as well.

I am wondering if someone out there has a solution to my problem.

I would greatly appreciate it!

Here is the code:

#include <sys/types.h>
#include <sys/shm.h>
#include <sys/times.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#define MAX_BUF_SIZE      255
#include <semaphore.h>
#include <time.h>

int ** Buffer;
int maximum;
int buffer_pos = 0;
int output_pos = 0;
int times_written = 0;
sem_t mut;
sem_t empty;
sem_t full;
void *producer(void *thread_num);
void *consumer(void *thread_num);

int main(int argc, char *argv[])
{
      int i, x;
      int bufLength = atoi(argv[2]), max = atoi(argv[1]), pno = atoi(argv[3]), cno = atoi(argv[4]);
      pthread_t tid1[pno];
      pthread_t tid2[cno];
      
      if(argc != 5)
                {  
            printf("Wrong number of parameters. Please enter 4 parameters.\n");
            exit(1);
                 }
      maximum = max;
      //printf("max is %d, bufLength is %d, nProducers is %d, nConsumers is %d\n", max, bufLength, pno, cno);
      
      Buffer = (int**) malloc (bufLength * sizeof(int *));
                for (i =0 ; i < bufLength; i++)
            Buffer[i] = malloc (2 * sizeof(int));
      sem_init(&mut, 0, 1);
      sem_init(&full, 0, 0);
      sem_init(&empty, 0, bufLength);
      
      for(i = 0; i < pno; i++)
      {
            //printf("Creating producer %d\n", i+1);
            x = pthread_create(&tid1[i], NULL, producer, (void *)i+1);
            if (x)
            {                                    
                  printf("ERROR; return code from pthread_create() is %d\n", x);
                            exit(-1);
            }
      }

      for(i = 0; i < cno; i++)
      {
            //printf("Creating consumer %d\n", i+1);
            x = pthread_create(&tid2[i], NULL, consumer, (void *)i+1);
      }
      printf("DONE\n");
      //pthread_exit(NULL);
}

void *producer(void *thread_num)
{
      while (1)
      {
            int index = 0;
            //printf("in PRODUCER\n");
            sem_wait(&empty);
            sem_wait(&mut);
            //printf("times_written: %d, maximum: %d\n", times_written, maximum);
            if (times_written < maximum)
            {
                  //printf("in PRODUCER\n");
                  Buffer[buffer_pos][0] = times_written+1;
                  Buffer[buffer_pos][1] = (int)thread_num;
                  buffer_pos++;
                  times_written++;
            }
            else
            {
                  sem_post(&mut);
                  sem_post(&full);
                  pthread_exit(NULL);
            }
            sem_post(&mut);
            sem_post(&full);
            sleep(0.001);
      }
}

void *consumer(void *thread_num)
{
      while (1)
      {
            //printf("in CONSUMER\n");
            sem_wait(&full);
            sem_wait(&mut);
            //printf("in CONSUMER\n");
            if (times_written < maximum || buffer_pos != 0)
            {
                  printf("%d %d %d %d\n", Buffer[output_pos][0], Buffer[output_pos][1], (int)thread_num, output_pos);
                  output_pos++;
                  buffer_pos--;
            }
            else
            {
                  sem_post(&mut);
                  sem_post(&empty);
                  pthread_exit(NULL);
            }
            sem_post(&mut);
            sem_post(&empty);
            sleep(0.001);
      }
      pthread_exit(NULL);
}