Question

Assume that there are 4 Processors and a total of 20 processes. Those processes should be distributed across those Processors evenly(5 process for each Processor) and they should be run until they finish.

The important thing is not to run just a single process until the process finishes, but inside of each processor run the processes concurrently for 1 Unit Time(UT). This means that we run a process for 1 UT then move on with the next process and run that one for 1 UT and move on with the next process...

The Process_Ets integer array should consist of 20 proccesses. Each element of the processor structure array have 5 processes(proc_ETs) waiting to be completed and an integer number which shows the processor(proc_id) that process belongs to. You should form a loop so that you run those 5 processes that are assigned to a Processor, so you will be using 4 different threads(excluding main) for 4 different Processors. To sum up, after running a process for 1 UT then you should move on with the next process until all processes complete their Execution Times(ET).

#define total_processes 20

#define processor_count 4

struct processor{

int proc_ETs[5];

int proc_id;

};

void* process (void *args){

…

…

}

int main(void){

…

…

}

Assigning Execution Time values :

for(int i = 0; i < 20; i++){

process_ETs[i] = (i % 4)+1; }

SAMPLE RUN:

$resim_2021-05-01_224554.png$

Answer 1

#include <pthread.h>

#include <stdlib.h>

#include<semaphore.h>

#include <stdio.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/wait.h>

#include<time.h>

#define total_processes 20

#define processor_count 4

pthread_mutex_t mutex;

struct processor

{

    

    int proc_ETs[5];

    int proc_id;

};

void *process(void *P)

{   

    struct processor temp = *((struct processor*)P);

    

    for(int i=0;i<5;i++){ 

        

        

        int remain = temp.proc_ETs[i];

        while(remain>=0){

            // mutex lock on cout out so that any other thread can execute this part

            

            pthread_mutex_lock(&mutex);

            printf("Process %d from Processor %d has Remaining %d ET.\n", (i+1),(temp.proc_id),remain);

            

            pthread_mutex_unlock(&mutex);

            

            if(remain)

                sleep(1);

            remain--;

        }

        

        

        

        

        

        

    }

    printf("Processor %d has completed all assigned processes\n",(temp.proc_id) );

    

}

int main()

{   

    srand(time(0));

    struct processor P[processor_count];

    pthread_t pro[processor_count];

    

    pthread_mutex_init(&mutex, NULL);

    

    

    

    //assigning execution times to the processes

    for (int i=0;i< processor_count;i++)

        {

            P[i].proc_id = i+1;

            for (int j=0;j<5;j++)

                P[i].proc_ETs[j] = ((i*5+j)%4)+1;

            

        }

    

    

    

    

    for(int i = 0; i < processor_count; i++) 

        {

            pthread_create(&pro[i], NULL, process, (void *)&P[i]);

        }

    

    

    

    for(int i = 0; i < processor_count; i++) {

        pthread_join(pro[i], NULL);

    }

    

    

    pthread_mutex_destroy(&mutex);

    

    return 0;

    

}