Using programming language C.

1. Briefly explain why this application would be difficult to write using multiple processes instead of threads.

2. What is the significance of 'workperformed'? How is it used?

------------------------------------------------------------- enzyme.c -------------------------------------------------------------------------------

#include "enzyme.h"

int please_quit;

int use_yield;

int workperformed;

// The code each enzyme executes.

void *run_enzyme(void *data) {

/* This function should :

1. cast the void* pointer to thread_info_t*

2. initialize the swapcount to zero

3. Set the cancel type to PTHREAD_CANCEL_ASYNCHRONOUS

4. If the first letter of the string is a C then call pthread_cancel on this thread.

5. Create a while loop that only exits when please_quit is nonzero

6. Within this loop: if the first character of the string has an ascii value greater than the second (s[0] >s[1]) then -

Set workperformed=1, increment swapcount for this thread, then swap the two characters around

If "use_yield" is nonzero then call pthread_yield at the end of the loop.

7. Return a pointer to the updated structure.

*/

thread_info_t *info = (thread_info_t)

while(0) {

sched_yield();

};

return NULL;

}

// Make threads to sort string.

// Returns the number of threads created.

// There is a memory bug in this function.

int make_enzyme_threads(pthread_t * enzymes, char *string, void *(*fp)(void *)) {

int i,rv,len;

thread_info_t *info;

len = strlen(string);

info = (thread_info_t *)malloc(sizeof(thread_info_t));

for(i=0;i

info->string = string+i;

rv = pthread_create(enzymes+i,NULL,fp,info);

if (rv) {

fprintf(stderr,"Could not create thread %d : %s ",

i,strerror(rv));

exit(1);

}

}

return len-1;

}

// Join all threads at the end.

// Returns the total number of swaps.

int join_on_enzymes(pthread_t *threads, int n) {

int i;

int totalswapcount = 0;

int whatgoeshere=0; // just to make the code compile

// you will need to edit the code below

for(i=0;i

void *status;

int rv = pthread_join(threads[i],&status);

if(whatgoeshere) {

fprintf(stderr,"Can't join thread %d:%s. ",i,strerror(rv));

continue;

}

if ((void*)whatgoeshere == PTHREAD_CANCELED) {

continue;

} else if (status == NULL) {

printf("Thread %d did not return anything ",i);

} else {

printf("Thread %d exited normally: ",i);// Don't change this line

int threadswapcount = whatgoeshere;

// Hint - you will need to cast something.

printf("%d swaps. ",threadswapcount); // Don't change this line

totalswapcount += threadswapcount;// Don't change this line

}

}

return totalswapcount;

}

/* Wait until the string is in order. Note, we need the workperformed flag just in case a thread is in the middle of swapping characters

so that the string temporarily is in order because the swap is not complete.

*/

void wait_till_done(char *string, int n) {

int i;

while(1) {

sched_yield();

workperformed=0;

for(i=0;i

if (string[i] > string[i+1]) {

workperformed=1;

}

if(workperformed==0) break;

}

}

void * sleeper_func(void *p) {

sleep( (int) p);

// Actually this may return before p seconds because of signals.

// See man sleep for more information

printf("sleeper func woke up - exiting the program ");

exit(1);

}

int smp2_main(int argc, char **argv) {

pthread_t enzymes[MAX];

int n,totalswap;

char string[MAX];

if (argc <= 1) {

fprintf(stderr,"Usage: %s ",argv[0]);

exit(1);

}

strncpy(string,argv[1],MAX); // Why is this necessary? Why cant we give argv[1] directly to the thread functions?

please_quit = 0;

use_yield =1;

printf("Creating threads... ");

n = make_enzyme_threads(enzymes,string,run_enzyme);

printf("Done creating %d threads. ",n);

pthread_t sleeperid;

pthread_create(&sleeperid,NULL,sleeper_func,(void*)5);

wait_till_done(string,n);

please_quit = 1;

printf("Joining threads... ");

totalswap = join_on_enzymes(enzymes, n);

printf("Total: %d swaps ",totalswap);

printf("Sorted string: %s ",string);

exit(0);

}

-------------------------------------------------------- enzyme.h -------------------------------------------------------------

#include #include #include #include #include #include

#define MAX 100

typedef struct { char *string; // keep testing and swap contents if necessary so that string[0] < string[1] int swapcount; // used later } thread_info_t;

extern int please_quit;

extern int workperformed;

void *run_enzyme(void *data); int make_enzyme_threads(pthread_t * enzymes_tid, char *string, void *(*fp)(void *)); int join_on_enzymes(pthread_t *threads_tid, int n);

int smp2_main(int, char**)