OS: Process Management Notes

✅ What is a Process?

A process is a program in execution. OS handles processes.

✅ How does OS create a process?

Steps:

Load program & static data into memory.
Allocate runtime stack (for function calls/variables).
Allocate heap (for dynamic memory).
Setup I/O tasks (open files, etc.).
Give control to the main() function.

✅ Process Attributes & PCB (Process Control Block)

Processes Architecture

OS tracks all processes using a Process Table.

Each process has an entry called PCB, storing:

👉 Use-case: During context switch, PCB is updated to save/restore process state.

✅ Process States (Life Cycle)

These are stages of a process:

State	Description
NEW	Process is being created
READY	Loaded into RAM, waiting for CPU
RUNNING	Actively executing on CPU
WAITING	Waiting for I/O
TERMINATED	Finished execution

🔁 Some intermediate actions:

Preemption (from Running to Ready)
I/O request (from Running to Waiting)

✅ Process Queues

Job Queue: NEW processes in disk; managed by LTS (Long Term Scheduler).
Ready Queue: READY processes in RAM; managed by STS (Short Term Scheduler).
Waiting Queue: WAITING processes; doing I/O.

✅ Schedulers in Operating System

Scheduler	Role	Controls
LTS (Long-Term Scheduler)	Loads new processes from disk to RAM	Controls Degree of Multiprogramming
STS (Short-Term Scheduler)	Selects processes from Ready Queue to run on CPU	Controls CPU Assignment
MTS (Medium-Term Scheduler)	Temporarily removes (swaps out) processes from RAM	Controls Memory Usage

Why Schedulers are Needed:

To manage which processes get CPU, memory, and other resources.
To ensure smooth multitasking by the OS.
To improve performance, responsiveness, and efficiency.

Why Different Schedulers:

LTS manages how many processes are in RAM at once (prevents overload).
STS decides which process runs next on the CPU (like a traffic cop).
MTS pauses processes when RAM is full, resuming them later (saves memory).

✅ Swapping (By MTS)

Temporarily swap out a process from RAM to disk to free memory.
Later, swap it back in when needed.

📌 Example: If RAM is full, MTS might suspend a low-priority process and bring it back later.

✅ Context Switching

When CPU switches from one process to another:

Save current process state (in PCB)
Load new process state (from PCB)

Overhead: No actual work is done during switch.

📌 Analogy: Like saving your game before someone else plays.

✅ Process Types

1. Orphan Process

Parent died, child still running.
Adopted by init process (PID 1).

2. 🧟 Zombie Process

A Zombie process is a child process that has finished executing (exit()), but still has an entry in the process table.
This happens because the **parent process has not yet read the child’s exit status** using wait().
It doesn’t use memory or CPU, but it keeps a slot in the process table (wastes resources).

🎯 Real-life Analogy:
A child finishes their exam (child process finishes), but the teacher (parent) hasn’t checked their paper yet. Until the teacher checks it, the child’s name stays on the pending list.

📌 Code Example:

                    int pid = fork();

                    if (pid == 0) {

                        // Child process

                        exit(0);

                    } else {

                        sleep(10); // Parent delays

                        wait(); // Parent finally reads child status

                    }

✅ Until the parent calls wait(), the child becomes a zombie.
✅ If the parent never calls wait(), the zombie stays until the parent exits or is killed.

✅ Preemptive vs Non-Preemptive Scheduling

Type	Description
Non-Preemptive	CPU is not taken forcefully; process runs till done or waits
Preemptive	CPU can be taken anytime for a higher priority process

📌 Example: You're using PC → Urgent system update interrupts → You're paused (Preemptive)

📌 Summary Table

Concept	Keyword/Idea
Process	Program in execution
PCB	Stores process info
Scheduler Types	LTS, STS, MTS
Queues	Job, Ready, Waiting
Context Switch	Save/Restore state
Swapping	Move in/out of RAM
Orphan Process	Parent dead, child alive
Zombie Process	Child dead, waiting to be reaped
Preemptive	Forcefully switch
Non-preemptive	Wait till end
Multiprogramming	Multiple in memory
Multitasking	Time-sharing

🧠 Quick Interview Prep Notes (One-Liner)

Process vs Program – Program is static, process is dynamic.
PCB – Structure storing process details.
Ready Queue – Holds all ready-to-run processes.
Zombie – Dead child process not yet reaped.
Orphan – Child whose parent exited.
Swapping – Temporarily moves process out of RAM.
Context Switch – Save and restore CPU state.
LTS vs STS vs MTS – Controls when to bring, assign, and swap.
Preemptive – Can interrupt running process.
Multiprogramming – Multiple loaded.
Multitasking – Time sharing of CPU.

📘 OS: Process Management (Lec 9, 10, 11)