Thread: producer consumer deadlock

For an assignment I am writing a program for the producer consumer problem.

As per the assignment specs I have written 3 programs with a shared memory
The shared memory contains the buffer and the semaphores in a struct.
The parent initialises the semaphores, shared memory and pointers, runs the programs and catches the return codes
The reader reads from a file, decrypts the data, places it into the buffer
The writer reads from the buffer, and prints output to the screen

Currently I have 2 readers and 1 writer.

Everything compiles fine but I keep getting a deadlock and I am hoping someone can point out the fault in my logic

Here is the relevant code.
reader

Code:

	while (fgets(read_buffer, BUFFER_SLOT_SIZE, fp) != '\0') 
	{		
		/* Decrypt data. Item produced */
		for (i = 0; i < BUFFER_SLOT_SIZE; i++) 
		{
			read_buffer[i] = decrypt(read_buffer[i]);
			if (read_buffer[i] == '\n') { break; }
		}
		sem_wait(&smp->empty);				        /* Decrement empty count */
		sem_wait(&smp->mutex);			                /* Enter critical region */
		strcpy(smp->buffer[smp->head], read_buffer); 	/* Add item to buffer */
		smp->head = (smp->head + 1) % BUFFER_SIZE;	/* Increment head pointer */
		sem_post(&smp->mutex);			                /* Exit critical reagion */
		sem_post(&smp->full);				                /* Increment full count */
		nanosleep(&tv, NULL);			                       /* Sleep for random time */
	}
	/* Increment completed counter. Use mutex to ensure exclusion */
	sem_wait(&smp->mutex);
	smp->completed++;
	sem_post(&smp->mutex);

writer

Code:

	/* Continue while data in the buffer */
	while (smp->completed < 2 && value != 0)
	{
		sem_wait(&smp->full);                                    /* Decrement full count */
		sem_wait(&smp->mutex);	                        /* Enter critical region */
		strcpy(write_buffer, smp->buffer[smp->tail); 	/* Read item from the buffer */
		smp->tail = (smp->tail + 1) % BUFFER_SIZE;	/* Increment tail pointer */
		sem_post(&smp->mutex);				/* Exit critical region */
		sem_post(&smp->empty);				/* Increment empty count */
		printf("%s", write_buffer);				/* Perform action on item */
		nanosleep(&tv, NULL);					/* Sleep for random time */
		sem_getvalue(&smp->empty, &value);			/* Get value of empty */
	}

cheers

Strider1974

Since posting the above I have read through numerous webpages and a couble of different books and I still cannot see the logical fault in my code. Everyone gives the same basic outline on how to resolve this issue which I feel I have implemented, but I cannot get this work. I think I might go and beat my head against a wall...it would be more fun.

Sorry I have may have confused the issue with the terminolgy used in the specs

The reader reads from the file and places the data into the buffer
The writer reads from the buffer and writes to the screen

Full has been initialised to o
Empty has been initialised to BUFFER_SIZE - which is 8

The program runs, normally until the buffer has been filled and then printed to the screen before deadlocking, although sometimes it will lock before that.

Code:

if (read_buffer[i] == '\n') { break; }

.
Its not necessary that read_buffer will always contain a '\n', should be looking for '\0' instead, especially when there are excess characters in the input stream,fgets won't read all of them.

bithub
The mutex semaphore has been initialised to 1

Code:

sem_init(&smp->full, 0, 0);
sem_init(&smp->empty, 0, BUFFER_SIZE);
sem_init(&smp->mutex, 0, 1);

zalezog
We are allowed to assume that each line of the file willl be less than 255 characters

Using some print statements it seems that the readers are in fact stuck waiting for the full semaphore to be incremented.

Isn't a semaphore supposed to release any processes waiting on it when is incremented above 0

How can I get around this problem?

sorry

I meant the readers(producers) are waiting on the semaphore named full