Bounded buffer sharing with Pthread and mutex locks busy waiting

Question

I am trying to create a producer consumer queue, using mutex locks, creating busy waiting between threads. My Main file takes X amount of integer arguments, pushes them onto a BOUNDED BUFFER of size 50. I am using a while loop to do this since you do not know the amount before hand. I am not sure when and where to create my producer thread. NOTE: Main is a "producer" in the sense it fills the buffer, but my actual producer function is going to pass onto my consumer function later in my code, so disregard the names. Main is going to "Produce" numbers by pushing and producer is going to pop those numbers for later use. My question is where and when do I make my Pthread_create in my code for producer and am I using the Mutex locks correctly to have synchronization between the two threads?

#include <pthread.h>
#include <stdlib.h>
#include <math.h>
#include <stdio.h>
#define BUFFER_SIZE (50)

typedef struct {
        int buffer[BUFFER_SIZE];
        int count;
        int top;
        int next;
        pthread_mutex_t count_lock;
} prodcons;

void pc_init(prodcons *pc);
int pc_pop(prodcons *pc);
void pc_push(prodcons *pc, int val);

void factor2pc(prodcons *pc, int number);
void *producer(void *data);
void *consumer(void *data);

int main(int argc, char *argv[])
{
        int index = 1;
        int num;
        prodcons pc_nums;



        //pthread_t tid[argc - 1];
        pthread_t tid;
        pthread_attr_t attr;

        if (argc <  2) {
                fprintf(stderr, "usage: No arguments\n");
                return -1;
        }
        if (atoi(argv[1]) <= 0)
        {
                fprintf(stderr, "%d not > 0 or you must provide a positive integer.\n", atoi(argv[1]));
                return -1;
        }


        pthread_attr_init(&attr);


        pc_init(&pc_nums);


        //DO I PUT THIS HERE or WHILE LOOP?
        pthread_create(&tid, &attr, *producer, &pc_nums);

        while (index < argc)
        {
                num = atoi(argv[index]);
                pc_push(&pc_nums, num);
                index++;
        }

}

void *producer(void *data)
{
        prodcons *dataStruct = data;







        while (dataStruct->count < BUFFER_SIZE)
        {
                number = pc_pop(data);
                //This print is just here to make sure I am correctly "poping" from buffer
                printf("%d\n", number);
        }
}

void pc_init(prodcons *pc)
{
        pc->count = 0;
        pc->top = 0;
        pc->next = 0;
        if (pthread_mutex_init(&pc->count_lock, NULL) != 0)
        {
        printf("\n mutex init has failed\n");
        }
}


int pc_pop(prodcons *pc)
{
        int val;
        pthread_mutex_lock(&pc->count_lock);

        if (pc->count > pc->top)
        {
                val = pc->buffer[pc->count];
                printf("%d\n", val);
                pc->buffer[pc->count] = 0;
                pc->count--;
        }

        pthread_mutex_unlock(&pc->count_lock);
        return val;
}

void pc_push(prodcons *pc, int val)
{
        pthread_mutex_lock(&pc->count_lock);

        if (pc->count < BUFFER_SIZE)
        {
                pc->buffer[pc->count] = val;
                pc->count++;
        }

        pthread_mutex_unlock(&pc->count_lock);
}

Armali Armali · Accepted Answer · 2019-10-22T07:27:20

My question is where and when do I make my Pthread_create in my code for producer and am I using the Mutex locks correctly to have synchronization between the two threads?

As long as all is properly initialized and synchronized, you can put the pthread_create() call wherever you want, including where it's placed in the given program. But at least two things are wrong:

pc_pop() behaves undefined (by return of an uninitialized value) if there is no number in the buffer to pop.
Since dataStruct->count is accessed by producer() without locking, the declaration should be _Atomic(int) count;.

Bounded buffer sharing with Pthread and mutex locks busy waiting

1 Answers