Summary

Write a program using thread functions to create, synchronize and terminate threads.

What To Do

Assume that you have the following functions:

initque$()$;

int enque$($data$\_$t $*$ dt$)$;

double proc$($char $*$ ar$)$;

where data$\_$t is a structure:

struct data$\_$t

$\{$

double val;

pthread$\_$t id;

int index;

$\}$;

Function val $=$ proc$($char $*$ ar$)$ receives an array of $128$ bytes and returns one

double value val. This function may be used by several threads at the same time.

Function enque$($struct data$\_$t $*$ dt$)$ creates a new element, copies into it the data

from the structure pointed by dt and enques it into a queue which has been created by a

call to initque$().$ Function enque$()$ may only be used by one thread at a time.

Write the C code for the main thread function main$()$ and the C code for two identical

worker threads called work$().$ You do not have to write the code for initque$(),$

enque$()$ or proc$().$

The program has a global variable count and two functions main$()$ and work$().$

int count;

int main $($int argc, char $**$ argv$)$

$\{$

$\}$

void $*$work $($void $*$ arg$)$

$\{$

$\}$

The main thread should work as follows:

$$ it is called with two arguments like

$$ test abc xyz

$$ the two arguments are names of files in the current directory

$$ it initializes count to $0$ and initializes the queue

$$ it opens the two files for reading

$$ it creates two threads, both running function work$(),$ and gives to each thread $($as

an argument$)$ the file descriptor of one of the two open files

$$ the first thread gets the file descriptor of the first file and the second thread

gets the file descriptor of the second file

$$ it waits for the two threads to terminate, prints the value of count and then exits

$$ it closes the corresponding file when a thread terminates

Each of the threads should work as follows:

$$ it reads $128$ bytes from the open file

$$ it calls function proc$()$ which returns a value in some variable

$$ it increments global variable count

$$ it stores in a variable of type struct data$\_$t the value returned from the call to

proc$(),$ its own thread id and the value of global variable count obtained from the

increment just performed

$$ it calls function enque$()$ to enque the new information

$$ notice that enque$()$ copies the information from the variable of type struct

data$\_$t to a new element in the queue, so that you can reuse the variable

$$ it repeats the above steps until it encounters end of file

$$ it terminates if it reads fewer than $128$ bytes or it encounters end of file