Threads in C : Producers Consumers Deadlock Error - c

Question

i'm working on the producer consumer problem in C where i get the producers and consumers as input and i have to produce/consume 8192 elements.
My code is :
#include <pthread.h>
#include <semaphore.h>
#include <stdio.h>
#include <stdlib.h>
pthread_mutex_t mutex;
sem_t empty;
sem_t full;
int prod=0;
int cons=0;
int buffer[8];
int in=0;
int out=0;
void producer(void* x)
{
int z=1;
while(z)
{
int item=rand();
sem_wait(&empty);
pthread_mutex_lock(&mutex);
if (prod!=8192){
buffer[in]=item;
prod+=1;
printf("Prod %d:item ins %d at %d\n",*((int *)x),buffer[in],in);
in=(in+1)%8;
}
if(prod==8192){z=0;}
pthread_mutex_unlock(&mutex);
sem_post(&full);
for (int i=0; i<10000; i++);
}
}
void consumer(void*x)
{
int z=1;
while(z)
{
sem_wait(&full);
pthread_mutex_lock(&mutex);
if (cons!=8192){
int item = buffer[out];
cons+=1;
printf("Cons %d:item rm %d at %d\n",*((int *)x),item,out);
out =(out+1)%8;
}
if(cons==8192){z=0;}
pthread_mutex_unlock(&mutex);
sem_post(&empty);
for (int i=0; i<10000; i++);
}
}
int main(int argc, char const *argv[])
{
int nbProd=atoi(argv[1]);
int nbCons=atoi(argv[2]);
pthread_t produc[nbProd],conso[nbCons];
pthread_mutex_init(&mutex,NULL);
sem_init(&empty,0,8);
sem_init(&full,0,0);
int idP[nbProd];
for (int i=0; i< nbProd;i++){
idP[i]=i;
}
int idC[nbCons];
for (int i=0; i< nbCons;i++){
idC[i]=i;
}
for(int i=0;i<nbProd;i++){
pthread_create(&produc[i],NULL,(void *)producer,(void*)&idP[i]);
}
for(int i=0;i<nbCons;i++){
pthread_create(&conso[i],NULL,(void *)consumer,(void*)&idC[i]);
}
for(int i=0;i<nbProd;i++){
pthread_join(produc[i],NULL);
}
for(int i=0;i<nbCons;i++){
pthread_join(conso[i],NULL);
}
pthread_mutex_destroy(&mutex);
sem_destroy(&empty);
sem_destroy(&full);
printf("prod:%d,-cons:%d",prod,cons);
return 0;
}
I tried the different input as :
./main 3 3
./main 1 3
Most case of equals producers/consumers everything is fine
Case of inequals producers/consumers there is a deadlock situation.
I tried to find where does it come from with helgrind.
The output was talking about "Possible data race Locks held: none"
But i couldnt find the answer to this.
I expect my program to execute the producers/consumers problem for equals and inequals producers/consumers.

Answer 1

Case of inequals producers/consumers there is a deadlock situation.
Running the program under GDB with ./a.out 1 3 arguments shows that there are 3 threads: the main thread blocked in pthread_join and two consumer threads blocked on sem_wait(&full).
With that info the problem becomes immediately obvious: you start full at 0, you increment it nbProd times, and you decrement it nbCons times.
When nbCons > nbProd, the decrements can not proceed and wait forever.
To fix this, you need to increment full nbCons - nbProd times to account for imbalance.