Assignment Details

There are two source files you need to complete. parta.c contains the scheduling code, and is testing using the unit test file test$\_$a$.$cpp$.$ parta$\_$main.c contains the command$-$line interface, and should be done after parta.c is complete.

parta.c

Debugging

Try to use printf debugging, where you insert print statements at strategic locations. You can also use the debugger in VSCode. Click the "bug" icon in the "Testing" tab.

The functions in this file are tested by tests$/$test$\_$a$.$cpp

Init

struct pcb$*$ init$\_$procs$($int$*$ bursts, int blen$)$;

The first function you should complete is init$\_$procs. This function takes an array of CPU bursts, and returns an array of PCBs$.$ The PCBs should be created in the heap, and each object contains the PID, burst$\_$left, and the total wait this process has experienced so far.

Scheduling

double fcfs$\_$avg$\_$wait$($int$*$ bursts, int blen$)$;

double rr$\_$avg$\_$wait$($int$*$ bursts, int blen, int quantum$)$;

You are given an array of CPU bursts $($and the time quantum for round$-$robin$).$ Create the array of PCBs using init$\_$procs, and then start scheduling. You can keep track of each process' wait time by looking at the PCB array's wait variable.

First$-$come$-$first$-$serve scheduling will start from index $0$ and run each process until completion.

Round$-$robin scheduling will take an additional parameter $($quantum$).$ Each process will run until it runs out of CPU burst or the time quantum $($whichever comes first$).$

Assume that all processes arrived that the same time, but in the order listed in bursts.

Next Process

int fcfs$\_$next$($int current, struct pcb$*$ procs, int plen$)$;

int rr$\_$next$($int current, struct pcb$*$ procs, int plen$)$;

A helper function called next is provided to make it easier to develop the scheduler. These functions return the next process to run. For example, let's say there are $2$ processes total. If the current process is P$0,$ under FCFS the next process would be P$1.$ If the current process is P$1,$ this would be the end, so return $-1.$

Under round robin, if the current process is P$0,$ next is p$1$; if current is P$1,$ next is P$0.$ If all the processes are complete $($burst$\_$left is $0),$ then return $-1.$

parta$\_$main.c

You are to process the command$-$line arguments. The first argument is the algorithm to use: $"$fcfs$"$ or $"$rr$".$ If using fcfs$,$ then remaining values are the array of CPU bursts. If using rr$,$ the immediate next value is the time quantum, and the CPU bursts follow that.

After identifying the algorithm to use, print the current setting and then print the average wait time $($up to $2$ decimal points$).$ For example, if we want fcfs with $3$ processes:

$ $./$build$/$src$/$parta$\_$main fcfs $459$

Using FCFS$.$

Accepted P$0$: Burst $4$

Accepted P$1$: Burst $5$

Accepted P$2$: Burst $9$

Average wait time: $3\mathrm{.}33$

If we want round$-$robin with time quantum $2,$ with $3$ processes:

$ $./$build$/$src$/$parta$\_$main rr $2459$

Using RR$(2).$

Accepted P$0$: Burst $4$

Accepted P$1$: Burst $5$

Accepted P$2$: Burst $9$

If the command$-$line arguments are not correctly provided, print a usage message and exit with status $1$ immediately. For example:

$ $./$build$/$src$/$parta$\_$main rr $2$

Usage:

parta$\_$main fcfs$|$rr BURSTS

$ $./$build$/$src$/$parta$\_$main first$-$come$-$first$-$serve $10$

Usage:

parta$\_$main fcfs$|$rr BURSTS

You may use any function from stdlib.h$,$ stdio.h$,$ string.h$,$ or ctype.h$.$ For example, strcmp or atoi can be used.

To test this part, run the following command in the terminal:

$./$run$.$sh testa