- About
- Getting Started
- Prerequisite
- Running
- Data Structures used
- Algorithm Explanation and Results
- Assumptions
- This is an Operating Systems Course Project where we were required to implement various process management alogirhtms, It's scheduler the processes that there exist in the system
This is a list of instructions to set up the project.
- GCC compiler installed
- Any unix based system
Running program
- build and run the project.
$ Makefile
- compile the project.
$ make build
- run the project.
$ make all
- C Language
| Algorithm | Used DS | Notes |
|---|---|---|
| Highest Priority First (HPF) | Priority Queue | Priority: Priority of the process |
| Shortest Remaining Time (SRTN) | Priority Queue | Priority: Remaining time |
| Round Robin (RR) | Circular Queue | Inside the implementation, when a process arrives, it is inserted into a queue. When it is stopped, it is dequeued and enqueued again. Once it finishes, it is dequeued. |
| First Fit (FF) | List | |
| Buddy | List of lists | The list of lists consists of 11 lists, each representing a specific size that is a power of two starting from 2^0 to 2^10. Each list is implemented as First Fit (FF). |
Note that we have isolated the functions for running, stopping, and continuing in separate functions.
The code first checks if there is no currently running process (RunningProcess is NULL) and the ready queue is not empty (!IsEmpty(ReadyQueue)). If both conditions are met, the highest priority process at the front of the queue is retrieved using the peek(ReadyQueue) function, and its address is assigned to the RunningProcess pointer.
Then, the state of the process is updated to "started" and the runProcess() function is called to execute the process. It is assumed that the runProcess() function takes a process pointer as its parameter and executes the process.
The code first checks if the ready queue is empty using IsEmpty(ReadyQueue). If the queue is empty, the function simply returns and does nothing.
If the ready queue is not empty, the code checks if there is a currently running process (RunningProcess is not NULL) and the process at the head of the ready queue has a shorter remaining execution time than the currently running process by comparing the ids of RunningProcess and the head of ReadyQueue. If this is the case, the function calls preempt() to stop the currently running process and switch to the new process with a shorter remaining execution time.
Finally, the function calls runProcess() to execute the process at the head of the ready queue.
The code first checks if the ready queue is empty by checking if ReadyQueue->head is NULL. If the queue is empty, the function simply returns and does nothing.
If the queue is not empty, the code first retrieves the process at the head of the ready queue using &(ReadyQueue->head->process) and assigns it to a pointer variable p.
Then, the code checks if there is no currently running process (RunningProcess is NULL) and there is a process at the head of the ready queue (p is not NULL). If this is the case, the function assigns the process at the head of the ready queue to RunningProcess and calls runProcess() to execute it.
If there is a currently running process, the code checks if the time quantum has elapsed for the process by comparing the current system time (getClk()) with the last start time of the process (RunningProcess->laststart) plus the time quantum (q). If the time quantum has elapsed, the function stops the currently running process using ReadingProcess() and checks if there is another process in the ready queue to be executed.
If there is another process in the ready queue, the function dequeues the process at the head of the queue using dequeueProcess(ReadyQueue) and saves it in a temporary variable temp. Then, the function inserts temp back into the ready queue using InsertInRR(temp, ReadyQueue, q) to maintain the order of processes in the queue.
Finally, the function assigns the process at the head of the ready queue to RunningProcess and calls runProcess() to execute it.
We have defined a function Allocation that attempts to allocate the process according to the current algorithm by calling the functions below:
For allocating the process:
int allocate_process(List* list, processIn* process)The function first initializes two pointers to nodes in the linked list: curr_hole points to the head of the list, and prev_hole points to NULL. The function then iterates
Aliaa Gheis |
Menna Mohamed |
Mennatallah Ahmed |
Sara Bisheer |