GOVERNMENT POLYTECHNIC PUNE

(An Autonomous Institute of Government of Maharashtra)

Microproject
“Shell scripting program & CPU Scheduling algorithm
and program for FCFS and Round Robin”

Submitted by:

Sr. No Enroll. No Name of the Student

1 2307032 Tanvi Ashok Kulkarni

2 2307034 Suvarna Sandip Lashkare

3 2307048 Prachi Babasaheb Rakshe

4 2307052 Sejal Santosh Jadhav

Under the Guidance of:

Dr. D. N. Rewadkar
(Head of Information Technology Department)
Department of Information Technology
Academic Year
(2024-2025)

1
 GOVERNMENT POLYTECHNIC PUNE
(An Autonomous Institute of Government of Maharashtra)

CERTIFICATE

Sr. No Enroll. No Name of the Student

1 2307032 Tanvi Ashok Kulkarni

2 2307034 Suvarna Sandip Lashkare

3 2307048 Prachi Babasaheb Rakshe

4 2307052 Sejal Santosh Jadhav

Has successfully completed the microproject title: “ Shell scripting program & CPU
Scheduling algorithm and program for FCFS and Round Robin” as a partial
fulfillment of requirements of
Second Semester of Second Year Diploma in Information Technology for the
academic year 2024-25

(Lecturer) (Head of Department) (Principal)

Dr. D. N. Rewadkar Dr. D. N. Rewadkar Dr. R. K. Patil
____________ ____________ ______________

2
 INDEX

[Link]. TOPIC PAGE NO.

1. Cover Page 01

2. Certificate 02

3. Index 03

4. Acknowledgment 04

5. Abstract 06
Brief introduction of Project
6. 07

7. Aim of Project 08

Shell Scripting & CPU

8. 11
Scheduling
References & Conclusion
9. 25

3
 Acknowledgment

I would like to express my sincere gratitude to everyone who contributed to the

successful completion of this project on Shell Scripting and CPU Scheduling
Algorithms.
First and foremost, I extend my heartfelt thanks to my mentor/professor
Dr. D. N. Rewadkar Head of Department of Information Technology for their
invaluable guidance, encouragement, and insightful feedback throughout the
development of this project. Their expertise and support played a crucial role in
shaping my understanding of shell scripting and CPU scheduling algorithms.
I also express my appreciation to my institution, Government Polytechnic Pune and
the faculty members of the Information Technology for providing the necessary
resources and a conducive learning environment.
A special thanks to my peers and friends for their continuous support and
collaboration in problem-solving and brainstorming ideas. Their feedback and
discussions have been instrumental in refining the project.
Lastly, I am grateful to my family for their unwavering support and motivation
throughout this journey.
This project has been a great learning experience, and I hope it serves as a valuable
contribution to understanding shell scripting and CPU scheduling algorithms.

Course Outcomes Addressed

CO 3 : Executive process management commands

CO 4 : Apply process scheduling algorithms and deadlock handling techniques

4
 Abstract

This project focuses on Shell Scripting and CPU Scheduling Algorithms, exploring
their significance in system automation and process management. Shell scripting is
a powerful tool used for automating repetitive tasks in operating systems,
improving efficiency, and reducing human intervention. The project includes the
implementation of various shell scripts for system administration, file handling,
and process management.
Additionally, the project delves into CPU Scheduling Algorithms, which are
crucial for optimizing process execution in operating systems. The study covers
First-Come, First-Served (FCFS) and Round Robin (RR) scheduling algorithms,
analyzing their working principles, advantages, and drawbacks. The FCFS
algorithm follows a non-preemptive approach, executing processes in the order
they arrive, whereas the Round Robin algorithm ensures fair process execution by
allocating a fixed time quantum to each process.
The project includes implementations of FCFS and Round Robin scheduling
algorithms inC to demonstrate their efficiency in handling multiple processes.
Performance comparisons based on metrics like turnaround time, waiting time, and
CPU utilization are also presented.
Through this project, we aim to provide a clear understanding of shell scripting's
automation capabilities and the role of CPU scheduling algorithms in enhancing
system performance. The findings contribute to the efficient management of
computational resources in modern operating systems.
Keywords: Shell Scripting, CPU Scheduling, First-Come, First-Served (FCFS),
Round Robin (RR), Operating Systems, Process Management

5
 Brief introduction of Project

A shell script in an operating system is a script written for the command line
interpreter, or shell, of an operating system. It typically contains a sequence of
commands that can be executed in the shell's environment. Shell scripts are used
for automating repetitive tasks, managing system configurations, and executing
complex commands or sequences of commands. They are widely used in Unix-like
operating systems such as Linux, macOS, and also in Windows environments with
shells like PowerShell.
Scheduling algorithms are fundamental components of operating systems
responsible for managing the allocation of CPU time to processes. These
algorithms ensure efficient utilization of system resources, maximize system
throughput, and maintain responsiveness. By determining the order in which
processes are executed, scheduling algorithms play a crucial role in meeting
performance objectives and optimizing system performance.
Understanding scheduling algorithms is essential for system developers and
administrators to design and configure operating systems that meet the needs of
diverse computing environments. By selecting and implementing appropriate
scheduling strategies, operating systems can deliver optimal performance,
responsiveness, and resource utilization, thereby enhancing the overall user
experience.
• Key Components of Shell Scripting
1. Shebang (#!) – Defines the script interpreter.
2. Variables – Store and manage data.
3. User Input – Accepts input using the read command.
4. Conditional Statements – Executes code based on conditions (if-else).
5. Loops – Repeats commands (for, while, until).
6. Functions – Reusable blocks of code.

6
 7. File Handling – Creates, reads, writes, and deletes files.
8. Process Management – Manages system processes (ps, kill).
9. Exit Status ($?) – Checks command success or failure.
[Link] (#) – Adds explanations without execution.
These components help automate tasks efficiently in shell scripting.

Aim of the microproject

The aim of this microproject is to understand and implement Shell Scripting and
CPU Scheduling Algorithms (FCFS & Round Robin) through practical
programming. This project focuses on:
1. Shell Scripting – Developing automation scripts using shell programming to
perform basic system operations efficiently.
2. First-Come, First-Served (FCFS) Scheduling – Implementing and analyzing
the non-preemptive scheduling algorithm where processes execute in the
order they arrive.
3. Round Robin (RR) Scheduling – Implementing a time-sharing scheduling
algorithm that ensures fair CPU allocation among processes using a fixed
time quantum.

How guess number program in shell scripting works ?

It generates a random number between 0 and 9 using $RANDOM % [Link] sets the
number of attempts allowed to 3.
It starts a loop where the user can input their guess within the given attempts.
Inside the loop, it checks if the user's guess is smaller, greater, or equal to the
generated number and provides appropriate feedback.
If the guess is correct, it prints a congratulatory message and exits the script.
If the loop completes without the correct guess, it prints a message revealing the
correct number.
How to create, write and save to execute the code in a file ?
There are steps given below:

7
[Link] your [Link] nano [Link] and press Enter.
[Link] will open the Nano text editor with a new file named guess_game.sh.
[Link] the Nano editor, write your shell script.
[Link] you've finished writing the script, press Ctrl + X to exit Nano. It will ask
you if you want to save the changes, press Y for yes, and then press Enter to
confirm the filename.

Shell scripting for guessing number between 0 to 10:

Now you've created a shell script file named guess_game.sh. You can run this
script using ./guess_game.sh in the terminal.
Make sure to set execute permissions on the script if needed using chmod +x
guess_game.sh.

8
Output:

9
 Scheduling

• The scheduler (dispatcher) is the module that gets invoked when a context switch
needs to happen and manipulates the queues, moving jobs to and fro.
• The scheduling algorithm determines which jobs are chosen to run next and what
queues they wait on.
• In general, the scheduler runs:
• When a job switches states (running, waiting, etc.)
• When an interrupt occurs
• When a job is created or terminated
• Scheduling algorithms in two contexts as below-
• A preemptive scheduler can interrupt a running job
• A nonprimitive scheduler waits for running job to block
• Many potential goals of scheduling algorithms
• Utilization, throughput, wait time, response time, etc.
• Various algorithms to meet these goals -FCFS/FIFO, SJF, Priority, RR

What is First Come First Serve (FCFS)?

In FCFS Scheduling-
The process which arrives first in the ready queue is firstly assigned the CPU.
• In case of a tie, process with smaller process id is executed first.
It is always non-preemptive in nature.
Jobs are executed on first come, first serve basis.
It is a non-preemptive, pre-emptive scheduling algorithm.
Easy to understand and implement.
Advantages-
It is simple and easy to understand.
It can be easily implemented using queue data structure.

10
 It does not lead to starvation.
Disadvantages-
It does not consider the priority or burst time of the processes.
It suffers from convoy effect i.e. processes with higher burst time arrived
before the processes with smaller burst time.
Terms in First Come First Serve Scheduling
Before moving to the program for first come first serve let's discuss some of
the basic terms of FCFS:
Arrival Time
The arrival time helps the First come First serve (FCFS) scheduling algorithm
to schedule the process or jobs. The task with minimum arrival time appears
in the ready queue first. The task that appears first in the ready queue will
receive CPU processing first. The task with minimum arrival time will receive
the CPU more quickly.
Waiting Time
The period of waiting before a procedure can start the execution process. The
process stays in the queue and waits to be executed.
Completion Time
The completion time determines the time taken to complete the execution. The
completion time is measured from the arrival time until the completion of the
respective process.
Turnaround Time
Turnaround time is the amount of time it takes for a task to arrive in the ready
queue for the first to its execution. It is calculated as the difference between
the completion time and the arrival time of the process.
Burst Time
The Burst Time is the overall amount of time the CPU needs to complete the
entire process. It is a pre-defined value for scheduling a process.

11
Time Quantum
For a specific period of time, the CPU is allotted to the task based on FCFS.
That fixed amount of time is known as time quantum.

First-Come, First-Served (FCFS) Scheduling Algorithm

Step 1: Input Process Details

• Read the number of processes (n).
• Read burst times (BT[]) for each process.
Step 2: Initialize Variables
• Set completion_time[0] = BT[0].
• Initialize total_time = 0.
Step 3: Compute Completion Time (CT)
• For each process i (from 1 to n-1):
o CT[i] = CT[i-1] + BT[i].
Step 4: Calculate Turnaround Time (TAT)
• TAT[i] = CT[i] - Arrival Time (AT[i]).
• Since FCFS assumes all processes arrive at 0, TAT[i] = CT[i].
Step 5: Calculate Waiting Time (WT)
• WT[i] = TAT[i] - BT[i].
Step 6: Compute Averages
• Avg_WT = sum(WT[]) / n.
• Avg_TAT = sum(TAT[]) / n.
Step 7: Output Results
• Display process details with BT, CT, TAT, WT.

12
 • Print average waiting time and turnaround time.

Example:

Consider the given table below and find Completion time (CT), Turn-around time
(TAT), Waiting time (WT), Response time (RT), Average Turn-around time and
Average Waiting time.

Process ID Arrival time Burst time

P1 2 2
P2 5 6
P3 0 4
P4 0 7
P5 7 4

Solution:

For this problem CT, TAT, WT, RT is shown in the given table –

Process Arrival Burst TAT=CT- WT=TAT-

CT RT
ID time time AT BT

P1 2 2 13 13-2= 11 11-2= 9 9

P2 5 6 19 19-5= 14 14-6= 8 8

13
P3 0 4 4 4-0= 4 4-4= 0 0

P4 0 7 11 11-0= 11 11-7= 4 4

Gantt chart :

Average Waiting time = (9+8+0+4+12)/5 = 33/5 = 6.6 time unit (time unit can be
considered as milliseconds)

Average Turn-around time = (11+14+4+11+16)/5 = 56/5 = 11.2 time unit (time unit
can be considered as milliseconds)

FCFS PROGRAM :
#include <stdio.h>

int main() {
int n, i;
int burst_time[10], waiting_time[10], turnaround_time[10],
completion_time[10], arrival_time[10], response_time[10];
float avg_wt = 0, avg_tat = 0, avg_rt = 0;

printf("Enter number of processes: ");

14
scanf("%d", &n);

printf("Enter Arrival Time and Burst Time for each process:\n");

for (i = 0; i < n; i++) {
printf("Process %d (Arrival Time, Burst Time): ", i + 1);
scanf("%d %d", &arrival_time[i], &burst_time[i]);
}

completion_time[0] = arrival_time[0] + burst_time[0];

for (i = 1; i < n; i++) {
if (completion_time[i - 1] < arrival_time[i]) {
completion_time[i] = arrival_time[i] + burst_time[i];
} else {
completion_time[i] = completion_time[i - 1] + burst_time[i];
}
}

for (i = 0; i < n; i++) {

turnaround_time[i] = completion_time[i] - arrival_time[i];
waiting_time[i] = turnaround_time[i] - burst_time[i];
response_time[i] = waiting_time[i];
avg_wt += waiting_time[i];
avg_tat += turnaround_time[i];
avg_rt += response_time[i];

15
 }

avg_wt /= n;
avg_tat /= n;
avg_rt /= n;

printf("\nProcess\tAT\tBT\tCT\tTAT\tWT\tRT\n");
for (i = 0; i < n; i++) {
printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\n", i + 1, arrival_time[i], burst_time[i],
completion_time[i], turnaround_time[i], waiting_time[i], response_time[i]);
}

printf("\nAverage Waiting Time = %.2f", avg_wt);

printf("\nAverage Turnaround Time = %.2f", avg_tat);
printf("\nAverage Response Time = %.2f\n", avg_rt);

printf("\nGantt Chart:\n");
printf("|");
for (i = 0; i < n; i++) {
printf(" P%d |", i + 1);
}
printf("\n0");
for (i = 0; i < n; i++) {
printf(" %d", completion_time[i]);
}

16
 printf("\n");

return 0;
}
Output:

Round Robin Scheduling (RR)

• CPU is assigned to the process on the basis of FCFS for a fixed amount of time.

17
• Then, the processor is assigned to the next arrived process.
• It is always preemptive in nature
• With decreasing value of time quantum,
→ Number of context switch increases
→ Response time decreases
→ Chances of starvation decreases
• Smaller value of time quantum is better in terms of response time
• With increasing value of time quantum,
→ Number of context switch decreases
→ Response time increases
→ Chances of starvation increases
Advantages-
• It gives the best performance in terms of average response time.
• It is best suited for time sharing system, client server architecture and interactive
system
Disadvantages-
• It leads to starvation for processes with larger burst time as they have to repeat
the cycle many times.
• Its performance heavily depends on time quantum.
• Priorities can not be set for the processes.

Round Robin Scheduling Algorithm

Step 1: Input Process Details
• Read the number of processes (n).
• Read burst times (BT[]) for each process.

18
 • Read the time quantum (QT).
• Copy burst times to remaining_burst[].
Step 2: Initialize Variables
• Set total_time = 0 (tracks elapsed time).
• Set completed = 0 (tracks completed processes).
Step 3: Execute Processes in Round Robin Order
• While all processes are not completed:
o For each process:
▪ If remaining_burst[i] > 0:
▪ Execute for QT or remaining burst time.
▪ Update remaining_burst[i] and total_time.
▪ If remaining_burst[i] == 0, mark as completed and store
turnaround time (TAT[i]).
Step 4: Calculate Waiting Time
• WT[i] = TAT[i] - BT[i] for each process.
Step 5: Compute Averages
• Avg_WT = sum(WT[]) / n
• Avg_TAT = sum(TAT[]) / n
Step 6: Output Results
• Display process details with BT, TAT, WT.
• Print average waiting time and turnaround time.

Example:

Given are the three processes P1, P2, and P3 with different arrival times, and burst
time.

Quantum time =2.

19
Process list Arrival Time Burst time

P1 0 4

P2 1 3

P3 2 7

Solution:

Completion Turn
Waiting
Arrival time or Around
Process list Burst time time(TAT-
time closing time time(CT-
BT)
(CT) AT)

P1 0 4 8 8-0=8 8-4=4

P2 2 3 9 9-2=7 7-3=4

P3 4 7 14 14-4=10 10-7=3

GANTT CHART :

20
Completion time is the time period of each process when it completes its execution
successfully and is taken out of the queue, which can be traced using the Gantt chart
provided above.

Average WT = (4+4+3) / 3 = 3.66 units

Average TAT = (8+7+10) / 3 = 8.33 units

ROUND ROBIN PROGRAM :

#include <stdio.h>

int main() {
int no_of_process, i, quantum_time, time = 0, remaining;
int arrival_time[10], burst_time[10], waiting_time[10], turnaround_time[10];
int rem_burst[10], completion_time[10], response_time[10];
float avg_wt = 0, avg_tat = 0, avg_rt = 0;

printf("Enter number of processes: ");

scanf("%d", &no_of_process);
remaining = no_of_process;

printf("Enter Arrival Time and Burst Time of each process:\n");

for (i = 0; i < no_of_process; i++) {
printf("Process %d (Arrival Time, Burst Time): ", i + 1);

21
 scanf("%d %d", &arrival_time[i], &burst_time[i]);
rem_burst[i] = burst_time[i];
response_time[i] = -1;
}

printf("Enter quantum time: ");

scanf("%d", &quantum_time);

while (remaining > 0) {

int done = 1;

for (i = 0; i < no_of_process; i++) {

if (rem_burst[i] > 0 && arrival_time[i] <= time) {
done = 0;

if (response_time[i] == -1) {
response_time[i] = time - arrival_time[i];
}

if (rem_burst[i] > quantum_time) {

time += quantum_time;
rem_burst[i] -= quantum_time;
} else {
time += rem_burst[i];

22
 completion_time[i] = time;
turnaround_time[i] = completion_time[i] - arrival_time[i];
rem_burst[i] = 0;
remaining--;
}
}
}

if (done)
time++;
}
printf("\nProcess\tAT\tBT\tCT\tTAT\tWT\tRT\n");
for (i = 0; i < no_of_process; i++) {
waiting_time[i] = turnaround_time[i] - burst_time[i];
avg_wt += waiting_time[i];
avg_tat += turnaround_time[i];
avg_rt += response_time[i];
printf("%d\t%d\t%d\t%d\t%d\t%d\t%d\n", i + 1, arrival_time[i],
burst_time[i], completion_time[i], turnaround_time[i], waiting_time[i],
response_time[i]);
}

avg_wt /= no_of_process;
avg_tat /= no_of_process;
avg_rt /= no_of_process;

23
 printf("\nAverage Waiting Time = %.2f", avg_wt);
printf("\nAverage Turnaround Time = %.2f", avg_tat);
printf("\nAverage Response Time = %.2f\n", avg_rt);

return 0;
}
Output:

Reference

Sr. Item Quantity Remarks

no
1 Laptop 1 Preparing report

24
2 Operating Syatem - 1 Theory
TechKnowlege(Textbook) preparation
3 Website - Research &
[Link] Development
[Link]
[Link]

Conclusion

Through this microproject, we successfully implemented Shell Scripting and CPU

Scheduling Algorithms (FCFS & Round Robin), gaining practical insights into
operating system functionalities.
1. Shell Scripting: Helped automate basic system tasks, improving efficiency
and understanding of command-line operations.
2. FCFS Scheduling: Demonstrated how processes are executed sequentially
based on arrival time, highlighting its simplicity but potential drawbacks,
such as higher waiting time.
3. Round Robin Scheduling: Showed how time-sharing improves process
fairness, reducing response time but potentially increasing context switching
overhead.
Overall, this project enhanced our understanding of process management,
scheduling techniques, and automation in operating systems, providing a strong
foundation for future studies and applications in system programming.

25