The XINU Operating System currently implements a Pre-emptive Priority Scheduling Algorithm. It follows the idea: 'At any point in time, the highest priority eligible to run will be scheduled'. As you now know, process priority is part of the process table and this priority is used to order the processes in the ready queue. When it is time to schedule a process to run, the highest priority process from the ready queue is chosen for execution. Even though there may be other processes in the system with higher priorities than the currently running process, they may be waiting for a message, or waiting on a semaphore, and hence are not eligible to run. If an ineligible process becomes eligible, this process is placed in the ready queue according to its priority and the reschedule function is invoked. If the priority of this process is lower than that of the currently executing process, then the current process will continue to run. The XINU Scheduling algorithm is pre-emptive, which means that although the highest priority process could possibly run for a longer time, a regular clock interrupt will pre-empt the process to check if there is any new higher priority process. Note that in such a scenario, the NULLPROC runs only when there are no other process to run, as NULLPROC's priority is the lowest possible priority the system supports.
One major problem with the above scheduling algorithm is that a high priority process may never let a lower priority process run. This is called starvation. The two-level round robin scheduling algorithm is one way to solve this problem.

In the two-level round robin scheme, each process belongs to a paticualar group. As part of the periodic timer interrupt, the scheduler context switches out the existing process and picks a different process to run according to the following algorithm:

step #1: At group level, the scheduler should decide one group via round robin algorithm. It indicates each group should be chosen one after another. If one group has no process in ready queue, the scheduler just skips it.
step #2: Within the group chosed in step #1, the scheduler picks up one process, which is in ready queue, via round robin algorithm. Then this process is scheduled to run.
However, if there is only one process in ready queue, the same process is scheduled to run again. The specific variant of the two-level round robin scheme we will use is detailed below as part of the tasks.

4. What to do ?

Task 1:

Explain and code a simple main program to illustrate starvation in the existing XINU Scheduling algorithm. You need not submit the output of this code, but rather, a text document called "report.txt" with a written explanation of the method and the corresponding code, with an explaination of why your program simulates starvation.

Task 2: Implement Two-level Round Robin Scheme

As part of this task you will incorporate code to implement a a Two-level Round Robin Scheme. The following explains the scheme:

Each process is given a group name when it's created via create system call. Please adding an new argument after argument priority. The group name is a char array defined by users, which is similar as process name. And you could assume the group name is no more than 20 chars. Processes with the same group name belong to one group.
The scheduler chooses the process according to the algorithm above. And only processes in ready queue could be scheduled.
Process priority has no effect. All groups should be given equal importance and all ready processes in the same group should also be given equal importance
Newly created processes should be scheduled after all existing processes which are in the ready queue and belong to the same group.
Newly created group should be chosen after all existing groups.
When a new group or new process is created, you needn't reschedule processes immediately.
There are some default processes (main, null etc.) in XINU system. Please mark them with group name "SYSTEM PROCESS" and then they could be scheduled under our new scheduling policy.
The new algorithm should not replace the exisiting scheme. Rather, maintain a global flag as a boolean variable 'ROUND_ROBIN'. (Do not use #define) If ROUND_ROBIN = true, then the OS should follow Round Robin scheduling scheme. Else, it follows the original scheme. Note that the value of the variable will not change during run time.