pthread synchronization modeled as train station - c

Question

I'm modeling a train station with pthreads. Each train gets its own thread and its own condition variable that monitors its access to the main track. Train information is read from a file and is of the format:
(direction):(loading time):(crossing time)
Only one train can be on the main track at a time. Trains can't be on the main track unless they are loaded and ready.
There is a seperate dispatcher thread responsible for coordinating access to the main track between all the trains. The dispatcher thread also decides which train gets access based on various rules such as which direction the train is going in. Right now I would be happy if I could get the trains reaching the main track in the order they are ready.
Here is my code so far:
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <readline/readline.h>
#include <unistd.h>
struct Train{
pthread_t thread;
pthread_cond_t granted;
int train_number;
int loading_time;
int crossing_time;
int priority;
char direction;
char state;
}*newTrain;
struct Train *trains[3];
pthread_mutex_t track = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t dispatcher = PTHREAD_COND_INITIALIZER;
char *loading = "L";
char *ready = "R";
char *granted_t = "T";
char *gone = "G";
char *acknowledged_gone = "X";
void *dispatcher_function(void *train_count) {
int count = *((int *) train_count);
int trains_remaining = count;
/* Check for ready trains until all trains have left the station */
while (trains_remaining > 0) {
pthread_mutex_lock(&track);
int t_granted = 0;
int next = -1;
for(int i = 0; i < count; i++){
if (strcmp(&trains[i]->state, "T") == 0)
t_granted = 1;
if (strcmp(&trains[i]->state, "R") == 0)
next = i;
if (strcmp(&trains[i]->state, "G") == 0){
trains_remaining--;
trains[i]->state = *acknowledged_gone;
}
}
/* Train was granted access to station wait for it to leave */
if (t_granted) {
pthread_cond_wait(&dispatcher, &track);
}
/* No trains in station. Wait for train */
if (next == -1) {
pthread_cond_wait(&dispatcher, &track);
}
/* Train ready in station grant next train track permission*/
else{
trains[next] -> state = *granted_t;
pthread_cond_signal(&(trains[next] -> granted));
}
pthread_mutex_unlock(&track);
}
pthread_exit(0);
}
void *train_function(void* train) {
struct Train *self = (struct Train*)train;
/* Each train has its own cond var */
pthread_cond_init(&self->granted, NULL);
/* Load train */
usleep(self -> loading_time);
/* Lock track */
pthread_mutex_lock(&track);
/* Train ready */
self -> state = *ready;
printf("Train %d is ready to go %c\n", self -> train_number, self -> direction);
/* Signal dispatcher */
pthread_cond_signal(&dispatcher);
while(strcmp(&self->state, "T") != 0)
pthread_cond_wait(&(self->granted), &track);
/* Use the track */
printf("Train %d is ON the main track going %c\n", self -> train_number, self -> direction);
usleep(self -> crossing_time);
self -> state = *gone;
printf("Train %d is OFF the main track after going %c\n", self -> train_number, self -> direction);
pthread_cond_signal(&dispatcher);
pthread_mutex_unlock(&track);
pthread_exit(0);
}
int main() {
FILE *ptr_file;
char buff[10];
int train_count = 0;
char *train;
char line[15];
pthread_t train_threads[3];
pthread_t dispatcher_thread;
ptr_file = fopen("./trains.txt", "r");
if (!ptr_file)
{
perror("fopen for trains.txt failed");
exit(EXIT_FAILURE);
}
/* Create train for each line of file */
while (fgets(buff,10, ptr_file)!=NULL) {
train = (char*)malloc(10 * sizeof(char));
/* Build train string */
sprintf(line, "%d:", train_count);
strcat(line, buff);
strcpy(train, line);
/* Parse train information */
int line_number = atoi(strtok(train, ":,"));
char *direction = strtok(NULL,":,");
int loading_time = atoi(strtok(NULL, ":,"));
int crossing_time = atoi(strtok(NULL, ":,"));
/* Create trains */
newTrain = (struct Train *) malloc(sizeof(struct Train));
newTrain -> train_number = line_number;
newTrain -> crossing_time = crossing_time;
newTrain -> loading_time = loading_time;
newTrain -> direction = *direction;
newTrain -> state = *loading;
if(pthread_create(&train_threads[train_count], NULL, &train_function, (void *) newTrain))
{
perror("pthread create failed");
exit(EXIT_FAILURE);
}
trains[line_number] = newTrain;
train_count++;
}
fclose(ptr_file);
/* Create dispatcher */
if(pthread_create(&dispatcher_thread, NULL, &dispatcher_function, (void *) &train_count))
{
perror("pthread create failed");
exit(EXIT_FAILURE);
}
/* Wait for dispatcher to finish */
pthread_join(dispatcher_thread, NULL);
printf("all done");
free(train);
for (int i = 0; i < train_count; i++) {
free(trains[i]);
}
exit(EXIT_SUCCESS);
}
Here is the trains.txt input file:
e:10,6
W:5,7
E:3,10
And this is the output I get when I run it:
Train 0 is ready to go e
Train 0 is ON the main track going e
Train 0 is OFF the main track after going e
Train 2 is ready to go E
Train 1 is ready to go W
Train 2 is ON the main track going E
Train 2 is OFF the main track after going E
Train 1 is ON the main track going W
Train 1 is OFF the main track after going W
The program is now hanging after all trains have left the station. So close I must be missing something.

Answer 1

You have several errors that need to be corrected before your program can be reasoned about:
trains.state is a single char object - it's not a string, because it's not necessarily followed by a null terminator. This means that you can't pass the address of it to strcmp() like you do in several places - instead of this:
if (strcmp(&trains[i]->state, "T") == 0)
use:
if (trains[i]->state == 'T')
(note single quotes for a character constant instead of a string constant).
You can't free(train) at the end of the train_function(), because the dispatcher keeps running and needs to access all the train structures. Instead, free them all in main() after the dispatcher exits.
The train condition variable granted is not ever initialised. You can't copy around pthread_cond_t variables - instead use pthread_cond_init:
void *train_function(void* train)
{
struct Train *self = (struct Train*)train;
/* Each train has its own cond var */
pthread_cond_init(&self->granted, NULL);
The start of train_function() modifies self->state without holding the lock, and this means it can race with the dispatcher reading the same object. You need to hold the lock around the modifications:
/* Load train */
pthread_mutex_lock(&track);
self -> state = *loading;
pthread_mutex_unlock(&track);
usleep(self -> loading_time);
/* Lock track */
pthread_mutex_lock(&track);
/* Train ready */
self -> state = *ready;
printf("Train %d is ready to go %c\n", self -> train_number, self -> direction);
(you can avoid the first lock by initialising state to "loading" for all trains in main(), before the other threads are started).
In addition, you cannot assume that the condition you were waiting for is true just because pthread_cond_wait() has woken up. pthread_cond_wait() is allowed to return even if it hasn't been signalled; it returning just means that it might have been signalled. This means that, for example in the train_function, you need to loop around the pthread_cond_wait() using while instead of if:
while (self->state != 'T')
pthread_cond_wait(&self->granted, &track);
You need to do something similar for the case in the dispatcher where you find that there's a train on the track.
This is actually the heart of your problem - when you get woken up at this point:
if (t_granted) {
pthread_cond_wait(&dispatcher, &track);
trains_remaining--;
}
You assume it's because the train you saw on the tracks has now finished. But that's not necessarily true - you might have been signalled by the next train finishing loading. This means you'll go around the loop and see the same train on the tracks again, and decrement trains_remaining too many times.
So you can't just adjust trains_remaining when you see a train on the track, because you might see the same train twice - or not at all, if it sets itself to "gone" very quickly.
Instead, you should decrement trains_remaining the first time that you see a given train in the "gone" state. You could achieve this by adding a new state that the dispatcher sets the train to after it has seen it was "gone", something like:
for (int i = 0; i < count; i++) {
if (trains[i]->state == 'T')
t_granted = 1;
if (trains[i]->state == 'R')
next = i;
if (trains[i]->state == 'G') {
trains_remaining--;
trains[i]->state = 'X'; /* acknowledged gone */
}
}