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.

Your reader is waiting on the empty semaphore, and the writer is waiting on the full semaphore. Unless these semaphores were initialized with a value greater than zero, you have a deadlock with your initial conditions. What are the initial states of your semaphores?

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.

What is the mutex semaphore initialized to?

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

One possible issue is that if empty semaphore equals zero, the writer will break out of the loop while the readers are stuck waiting on the that semaphore. Since the readers will work faster than the writers (there are 2 readers vs 1 writer), this is a very real possibility. The first thing I would check is if the writer ever exits that loop.

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?

Originally Posted by strider1974

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?

I don't see how that's possible. Your readers never wait on the full semaphore -- they only post to it.

sorry

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

Originally Posted by strider1974

sorry

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

I'm still confused. Do you mean the writer?