Skip to content

Commit fc43cee

Browse files
rdx40rdx40
committed
added the SRTF algorithm
1 parent 9a3ba51 commit fc43cee

File tree

2 files changed

+193
-0
lines changed

2 files changed

+193
-0
lines changed

‎CPU Scheduling Algorithms/README.md

Lines changed: 76 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -199,3 +199,79 @@ The **SJF** scheduling algorithm follows a non-preemptive approach where process
199199
To run this program, you need:
200200
- A C compiler like `gcc`.
201201
- Basic command-line skills for compiling and executing C programs.
202+
203+
204+
205+
206+
# Process Scheduling Simulation in C (Shortest Remaining Time First Algorithm)
207+
208+
## Table of Contents
209+
- [Algorithm Overview](#algorithm-overview)
210+
- [Features](#features)
211+
- [Shortest Remaining Time First (SRTF) Algorithm](#shortest-remaining-time-first-srtf-algorithm)
212+
- [Detailed Explanation of Functions](#detailed-explanation-of-functions)
213+
- [Requirements](#requirements)
214+
- [Installation and Execution](#installation-and-execution)
215+
- [Example Usage](#example-usage)
216+
- [Output Explanation](#output-explanation)
217+
- [Memory Management](#memory-management)
218+
- [Code Structure and Files](#code-structure-and-files)
219+
- [Contributing](#contributing)
220+
- [License](#license)
221+
222+
## Algorithm Overview
223+
224+
This algorithm simulates a **Shortest Remaining Time First (SRTF) scheduling** algorithm for processes in an operating system. In SRTF scheduling, the CPU selects the process with the shortest remaining burst time first, ensuring that processes with shorter remaining burst times are executed first. If a new process arrives with a shorter burst time than the currently running process, the CPU is preempted to execute the new process.
225+
226+
The SRTF algorithm is a **preemptive scheduling algorithm** that is particularly efficient in reducing waiting time, as it prioritizes processes with the least remaining time.
227+
228+
## Features
229+
230+
- **Preemptive Scheduling**: The process with the shortest remaining burst time is executed first. If a new process arrives with a shorter remaining burst time than the current one, it preempts the current process.
231+
- **Calculates Response Time** (time between arrival and first execution).
232+
- **Calculates Turnaround Time** (total time from arrival to completion).
233+
- **Calculates Waiting Time** (time spent waiting in the queue).
234+
- **Displays Results** in a well-formatted table, showing calculated metrics for each process.
235+
236+
## Shortest Remaining Time First (SRTF) Algorithm
237+
238+
The **SRTF** scheduling algorithm works as follows:
239+
240+
1. **Preemptive Execution**: The CPU always executes the process with the shortest remaining burst time. If a new process arrives with a shorter remaining burst time than the current one, the CPU is preempted, and the new process is executed.
241+
2. **Sorting**: Initially, processes are sorted by their arrival time.
242+
3. **Execution**: The system executes processes based on their remaining burst times. At each unit of time, it chooses the process with the shortest remaining burst time.
243+
4. **Metric Calculation**: For each process, the program calculates:
244+
- **Start Time**: The time when the process starts execution.
245+
- **Completion Time**: The time when the process finishes execution.
246+
- **Response Time**: The time difference between the start time and arrival time.
247+
- **Turnaround Time**: The time difference between the completion time and arrival time.
248+
- **Waiting Time**: The time difference between turnaround time and burst time.
249+
250+
## Detailed Explanation of Functions
251+
252+
### 1. `find_response(struct Process* input, int n)`
253+
- Calculates the **response time** for each process.
254+
- Formula: **Response Time** = `start time - arrival time`
255+
256+
### 2. `find_tat(struct Process* input, int n)`
257+
- Calculates the **turnaround time** for each process.
258+
- Formula: **Turnaround Time** = `completion time - arrival time`
259+
260+
### 3. `find_wt(struct Process* input, int* tat, int n)`
261+
- Calculates the **waiting time** for each process.
262+
- Formula: **Waiting Time** = `turnaround time - burst time`
263+
264+
### 4. `schedule(struct Process* input, int n)`
265+
- Simulates the **Shortest Remaining Time First** scheduling.
266+
- The processes are sorted initially by their arrival time.
267+
- At each unit of time, the process with the shortest remaining burst time is executed.
268+
- The start and completion times for each process are calculated dynamically as processes are executed.
269+
270+
### 5. `comp(const void* a, const void* b)`
271+
- Comparison function used by `qsort` to sort processes by arrival time, and by ID if arrival times are equal.
272+
273+
## Requirements
274+
275+
To run this program, you need:
276+
- A C compiler like `gcc`.
277+
- Basic command-line skills for compiling and executing C programs.

‎CPU Scheduling Algorithms/SRTF.c

Lines changed: 117 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,117 @@
1+
#include <stdio.h>
2+
#include <stdlib.h>
3+
4+
// Structure to hold each process's details
5+
struct Process {
6+
int id, bt, at, start, comp, remaining_bt;
7+
};
8+
9+
// Comparison function for sorting processes by arrival time
10+
int comp(const void* a, const void* b) {
11+
struct Process* p1 = (struct Process*)a;
12+
struct Process* p2 = (struct Process*)b;
13+
if (p1->at == p2->at)
14+
return p1->id - p2->id; // If arrival times are the same, sort by ID
15+
return p1->at - p2->at; // Sort by arrival time otherwise
16+
}
17+
18+
// Function to calculate the response time of each process
19+
int* find_response(struct Process* input, int n) {
20+
int* rt = (int*)malloc(n * sizeof(int));
21+
for (int i = 0; i < n; i++) {
22+
rt[i] = input[i].start - input[i].at;
23+
}
24+
return rt;
25+
}
26+
27+
// Function to calculate the turnaround time of each process
28+
int* find_tat(struct Process* input, int n) {
29+
int* tat = (int*)malloc(n * sizeof(int));
30+
for (int i = 0; i < n; i++) {
31+
tat[i] = input[i].comp - input[i].at;
32+
}
33+
return tat;
34+
}
35+
36+
// Function to calculate the waiting time of each process
37+
int* find_wt(struct Process* input, int* tat, int n) {
38+
int* wt = (int*)malloc(n * sizeof(int));
39+
for (int i = 0; i < n; i++) {
40+
wt[i] = tat[i] - input[i].bt;
41+
}
42+
return wt;
43+
}
44+
45+
// Function to simulate the SRTF Scheduling Algorithm
46+
void schedule(struct Process* input, int n) {
47+
qsort(input, n, sizeof(struct Process), comp); // Sort processes by arrival time
48+
49+
int last_time = 0; // Keeps track of the current time
50+
int remaining_processes = n; // Number of remaining processes
51+
int completed = 0;
52+
53+
while (completed < n) {
54+
int min_bt = __INT_MAX__;
55+
int idx = -1;
56+
57+
// Find the process with the shortest remaining burst time
58+
for (int i = 0; i < n; i++) {
59+
if (input[i].at <= last_time && input[i].remaining_bt > 0 && input[i].remaining_bt < min_bt) {
60+
min_bt = input[i].remaining_bt;
61+
idx = i;
62+
}
63+
}
64+
65+
if (idx != -1) {
66+
if (input[idx].remaining_bt == input[idx].bt) {
67+
input[idx].start = last_time; // Set start time for the first execution
68+
}
69+
70+
// Execute the process for 1 unit of time
71+
input[idx].remaining_bt--;
72+
last_time++;
73+
74+
// If the process is completed
75+
if (input[idx].remaining_bt == 0) {
76+
input[idx].comp = last_time; // Set completion time
77+
completed++;
78+
}
79+
} else {
80+
last_time++; // If no process is ready, increment time
81+
}
82+
}
83+
}
84+
85+
// Main program to test the SRTF algorithm
86+
int main() {
87+
int n;
88+
printf("Enter the number of processes: \n");
89+
scanf("%d", &n);
90+
91+
struct Process* input = (struct Process*)malloc(n * sizeof(struct Process));
92+
for (int i = 0; i < n; i++) {
93+
printf("Enter the id, burst time and arrival time of process %d:\n", i + 1);
94+
scanf("%d %d %d", &input[i].id, &input[i].bt, &input[i].at);
95+
input[i].remaining_bt = input[i].bt; // Initialize remaining burst time
96+
}
97+
98+
schedule(input, n);
99+
100+
int* response = find_response(input, n);
101+
int* turntime = find_tat(input, n);
102+
int* waittime = find_wt(input, turntime, n);
103+
104+
printf("%8s %8s %8s %8s %12s %10s %12s %8s\n", "Process", "Burst", "Arrival", "Start", "Completion", "Response", "Turn Around", "Waiting");
105+
for (int i = 0; i < n; i++) {
106+
printf("%8s%d %8d %8d %8d %12d %10d %12d %8d\n",
107+
"P", input[i].id, input[i].bt, input[i].at,
108+
input[i].start, input[i].comp, response[i],
109+
turntime[i], waittime[i]);
110+
}
111+
112+
free(input);
113+
free(response);
114+
free(turntime);
115+
free(waittime);
116+
return 0;
117+
}

0 commit comments

Comments
 (0)