[Threads] Solution 5 : FIFO

This material is part of the course Practical Introduction to Parallel Programming and meant for educational purposes only.

Task

Implement a program in which two threads pass data through a FIFO (First In, First Out) buffer.

That is, one thread - the producer - reads characters from the standard input and puts those characters in the FIFO buffer.

The other thread - the consumer - reads characters from the FIFO buffer and writes them to the standard output.

The producer and the consumer threads should end when they encounter the end of the input stream.

Hints

The main thread initialises the FIFO buffer and spawns both the producer and the consumer thread. It then waits until those threads have finished executing.

Use the function getc to read the next character from the standard input, and use the function putc to write a character to the standard output. INGInious is configured to read the standard input from the file input.txt (i.e. cat input.txt | your_code > output.txt).

Define a struct fifo_t that represents the FIFO buffer. It must contain a mutex, a condition variable and space for storing at least one character. It must also contain one or two integer variables indicating whether the buffer is full or empty.

To simplify your code, you can use a buffer of one character.

If you want to make your code more elegant you can define the functions fifo_init and fifo_destroy that initialise and destroy a buffer, respectively.

The main thread should create an instance of the FIFO buffer and pass its address to both child threads.

Paste this command into your terminal:

The password to connect is

Question 1: FIFO

#include <stdio.h>
#include <pthread.h>

/* ---------------------------------------------------------------------
 * types
 * ------------------------------------------------------------------ */

struct                    fifo
{
  pthread_mutex_t           mutex;
  pthread_cond_t            cond;
  int                       data;
  int                       filled;
};

typedef struct fifo       fifo_t;

/* ---------------------------------------------------------------------
 * fifo_init()
 * ------------------------------------------------------------------ */

void                      fifo_init

  ( fifo_t*                 fifo )

{
  pthread_mutex_init ( &fifo->mutex, NULL );
  pthread_cond_init  ( &fifo->cond,  NULL );
}

/* ---------------------------------------------------------------------
 * fifo_destroy()
 * ------------------------------------------------------------------ */

void                      fifo_destroy

  ( fifo_t*                 fifo )

{
  pthread_mutex_destroy ( &fifo->mutex );
  pthread_cond_destroy  ( &fifo->cond );
}

/* ---------------------------------------------------------------------
 * producer()
 * ------------------------------------------------------------------ */

void*                     producer

  ( void*                   arg )

{
  fifo_t*  fifo = (fifo_t*) arg;
  int      ch   = getc ( stdin );

  while ( 1 )
  {
    pthread_mutex_lock ( &fifo->mutex );

    while ( fifo->filled )
    {
      pthread_cond_wait ( &fifo->cond, &fifo->mutex );
    }

    fifo->data   = ch;
    fifo->filled = 1;

    /* Signal the consumer thread that the buffer contains
     * new data. */

    pthread_cond_signal  ( &fifo->cond );
    pthread_mutex_unlock ( &fifo->mutex );

    if ( ch == EOF )
    {
      break;
    }

    ch = getc ( stdin );
  }

  return NULL;
}

/* ---------------------------------------------------------------------
 * consumer()
 * ------------------------------------------------------------------ */

void*                     consumer

  ( void*                   arg )

{
  fifo_t*  fifo = (fifo_t*) arg;
  int      ch   = 0;

  while ( 1 )
  {
    pthread_mutex_lock ( &fifo->mutex );

    while ( ! fifo->filled )
    {
      pthread_cond_wait ( &fifo->cond, &fifo->mutex );
    }

    ch           = fifo->data;
    fifo->data   = 0;
    fifo->filled = 0;

    /* Signal the producer thread that the buffer is empty
     * and can be filled again. */

    pthread_cond_signal  ( &fifo->cond );
    pthread_mutex_unlock ( &fifo->mutex );

    if ( ch == EOF )
    {
      break;
    }

    putc ( ch, stdout );
  }

  return NULL;
}

/* ---------------------------------------------------------------------
 * main()
 * ------------------------------------------------------------------ */

int                       main

  ( int                     argc,
    char**                  argv )

{
  pthread_t  pid;
  pthread_t  cid;
  fifo_t     fifo;

  fifo_init      ( &fifo );
  pthread_create ( &pid, NULL, producer, &fifo );
  pthread_create ( &cid, NULL, consumer, &fifo );
  pthread_join   (  pid, NULL );
  pthread_join   (  cid, NULL );
  fifo_destroy   ( &fifo );

  return 0;
}

Question 2: Command Line Argument

Specify the command line arguments that should be passed to your program when it is run. Arguments must be given in quotes and separated by commas. Leave this filed empty if you do not want to specify command line arguments.

Example: "1","int","arg=2" is interpreted as three arguments 1, int, and arg=2.

Author(s)	Erik-Jan Lingen, Matthias Möller
Deadline	No deadline
Submission limit	No limitation

Information

Sign in