Operating System | Unit-1 | Detailed Oneshot | Sem-5 | With PYQs | GGSIPU

Main ideas and lessons conveyed

What an Operating System (OS) is and why it’s needed

• Multiple applications/devices need shared hardware resources (CPU, RAM, storage, network).
• The OS acts as an interface between users/applications and hardware.
• The OS manages resources so tasks can run without conflicts and to improve efficiency.

OS as a “household” model

• CPU = a worker/person that performs work.
• RAM = work area/kitchen space where tasks operate.
• Storage = cupboards/fridge to keep items/programs.
• Process = the currently executing task.
• Program = instructions/recipe.
• Interrupt = an external event (e.g., doorbell) that temporarily interrupts current work.
• Input = data/ingredients needed to proceed.
• Resources = tools needed for work.
• PCB = an “information card” containing per-process details for OS management.
• IPC = communication between processes (e.g., coordination/asking someone).
• Context switching = pausing one task and switching to another urgent task, then resuming.

---

Methodology / structure used in the session (topic flow)

Start-up plan

• Announce Unit-1 syllabus structure.
• Emphasize key exam components: definition, types, real-life examples, advantages, disadvantages.

Core lecture progression

1. Definition of OS
2. Types of Operating Systems
3. Resource management role of OS
4. Processes and PCB
5. Process states
6. Interrupts + interrupt handling + types
7. Inter-process communication (IPC)
8. Threads (process vs thread, thread states, operations)
9. CPU scheduling
   • scheduling goals/criteria
   • algorithms (FCFS, SJF, SRTF, Round Robin, Priority, etc.)
   • starvation, aging
   • multi-level queue / feedback queue
   • demand scheduling
10. Real-time operating systems - hard vs soft real time - EDF and RMS
11. End with key sheets/PYQs and revision guidance.

---

Detailed bullet list: Types of Operating Systems (with concepts + pros/cons)

1) Batch Operating System

• Idea
  • Collect jobs in batches and run them sequentially.
  • No interaction during execution.
• Advantages
  • High CPU utilization (CPU keeps executing continuously).
  • Efficient for large jobs.
  • No manual intervention → automatic execution.
  • Better throughput for repetitive tasks.
• Disadvantages
  • No direct user interaction → difficult to know progress or errors.
  • Long waiting time for a job (later batches wait).
  • Not suitable for interactive applications.
  • If a job fails, it can stop or affect subsequent jobs.

2) Multiprogrammed Batch OS

• Idea
  • Keep multiple programs in memory.
  • If one program waits for I/O/resources, the CPU switches to another.
  • Goal: avoid CPU idling.
• Advantages
  • Better CPU utilization.
  • Higher throughput.
  • Reduced idle CPU time.
  • Resource utilization improves.
• Disadvantages
  • Memory management becomes difficult (many programs).
  • CPU scheduling becomes complex.
  • Deadlock is possible due to circular waiting for resources.
  • OS design complexity increases.

3) Time-Sharing OS

• Idea
  • Multiple users/processes share CPU using time quantum.
  • OS rapidly switches among processes → appears simultaneous.
• Key mechanism
  • Time quantum = fixed short time slice given to each process.
• Advantages
  • Faster user response (interactive feel).
  • Supports multiple users.
  • Fair CPU allocation.
  • Good overall CPU utilization.
• Disadvantages
  • High overhead due to frequent context switching.
  • Security concerns increase (many users).
  • Scheduling is complex.
  • Performance can degrade with many processes/users.
  • Requires more resources for smooth operation.

4) Personal Computer (PC) OS

• Idea
  • OS for single-user “friendly environment” for apps and devices.
• Responsibilities
  • Hardware management: CPU, memory (RAM), storage, input/output devices.
  • Application management: run installed programs.
  • File management
  • User interface (GUI)
  • Security protections
  • Device/driver management (e.g., pendrive, external devices).

5) Parallel OS

• Idea
  • Uses multiple processors/cores to execute parts of a program simultaneously.
  • Requires coordination among processors.
• Requirements
  • Processor management
  • Task distribution
  • Scheduling suitable processor assignment
  • Load balancing (avoid idle processors)
  • Synchronization across tasks
  • Resource management + optimization
• Advantages
  • Faster execution; increased performance.
  • Better resource utilization.
  • Higher throughput.
• Disadvantages
  • Complex programming and system design.
  • Synchronization overhead.
  • Load balancing problems (uneven work → idle time).
  • Higher cost.

6) Distributed OS

• Idea
  • Manages multiple interconnected computers as if they were one system.
  • Coordinates processes, communication, load balancing, and fault handling.
• Key points
  • Communication is essential (network dependency).
  • Transparency to users (single-system view).
  • Fault management: work continues even if a node fails.
• Advantages
  • High resource sharing.
  • Reliability, availability, scalability.
  • Load balancing and performance benefits.
• Disadvantages
  • More complex design.
  • Network dependency (communication affects performance).
  • Many security challenges.
  • Debugging becomes harder.
  • Synchronization issues can occur.

7) Real-Time Operating System (RTOS)

• Idea
  • Must complete tasks by a deadline.
  • Output must be correct and timely.
• Hard vs Soft real-time
  • Hard RTOS
    • Missing deadline is catastrophic/system failure.
  • Soft RTOS
    • Missing deadline degrades performance but may not fail the system.
• Scheduling mentioned
  • EDF (Earliest Deadline First)
  • RMS (Rate Monotonic Scheduling)

---

Detailed bullet list: OS Resource Management methodology (process lifecycle + scheduling concepts)

How OS allocates resources

• A process requests a resource (CPU time, memory, I/O, file, network).
• OS checks availability (free/not used; policy-based decision).
• OS allocates the resource to the process.
• Process uses the resource and later releases it.
• Cycle repeats.

OS resource types managed

• CPU scheduling: decides which process runs.
• Memory management: decides memory allocation (RAM).
• Storage management
• I/O management: manages devices (keyboard, mouse, printer, etc.).
• Network management and communication support.
• File management
• OS coordinates multiple applications (e.g., browser + IDE + downloads).

Process vs Program

• Program: a set of instructions/recipe stored on disk.
• Process: program in execution with resources + an execution context.

---

Detailed bullet list: Process Control Block (PCB)

• Meaning
  • PCB = “information card” used by OS to manage and track a process.
• What PCB stores (key fields)
  • Process ID (unique identifier)
  • Process state (new/ready/running/waiting/terminated)
  • Program Counter (address of next instruction)
  • CPU register values
  • Scheduling/priority info, time slice/time quantum
  • Memory management info (base/limit, page/segment tables)
  • I/O status and allocated devices
  • File/resource info and pending requests
  • CPU usage statistics (start time, execution time, total CPU time)
  • User ID/accounting data
• Where PCBs live
  • In process table (in main memory).

---

Detailed bullet list: Process states + transitions (as taught)

Main states

• New
  • Process created; resources allocated.
• Ready
  • Waiting in ready queue for CPU.
• Running
  • Currently executing on CPU.
• Waiting / Blocked
  • Waiting for I/O or an event.
• Terminated (Exit)
  • Process completed and removed.

Transitions (high level)

• New → Ready (placed in ready queue)
• Ready → Running (CPU scheduler dispatches)
• Running → Waiting/Blocked (I/O/event wait)
• Waiting/Blocked → Ready (event/I/O completes)
• Running → Terminated (completion)
• Ready → Running may be preempted (in preemptive scheduling)

---

Detailed bullet list: Interrupts and interrupt handling

What is an interrupt

• A signal/event requiring immediate attention that temporarily pauses current execution.

Why OS needs it

• CPU must respond without losing context.

Interrupt handling steps (as described)

• CPU is executing an instruction.
• Interrupt occurs.
• CPU saves context of current process.
• CPU identifies the interrupt source/cause.
• OS transfers control to the appropriate ISR (Interrupt Service Routine).
• ISR runs; then context is restored and original process resumes.

Types

• Hardware interrupts (keyboard/mouse/timer/disk/network)
• Software interrupts (internal OS mechanisms like system calls; antivirus notification idea mentioned)

Maskable vs Non-maskable

• Maskable interrupts
  • Can be enabled/disabled; typical device events.
• Non-maskable interrupt (NMI)
  • Cannot be disabled; for critical events.

---

Detailed bullet list: Inter-Process Communication (IPC)

Why IPC exists

• Coordination and data sharing across processes.
• Synchronization of order/timing when processes depend on each other.
• Resource sharing scenario: two processes may need the same data.

Two major approaches

• Shared Memory
  • Processes share the same memory region.
  • One writes data; another reads.
• Message Passing
  • Processes communicate by sending and receiving messages through OS-managed mechanisms.
  • Examples/analogies used: WhatsApp message, shout-request-to-mother, letter via mail service.

---

Detailed bullet list: Threads (process vs thread + thread states/operations + models)

Process vs Thread

• Process
  • Heavyweight unit of execution with separate address space/resources.
• Thread
  • Lightweight unit of execution inside a process.
  • Shares the same address space, code/data, open files with other threads in the same process.
  • Each thread has its own execution context (PC, registers).

Thread advantages/implications (as taught)

• Threads are cheaper to create than processes.
• Faster context switching than processes.
• But isolation is weaker: if one thread fails, shared memory can cause broader impact.

Thread states (pattern analogized with assignment/library/internet)

• New/Created
• Ready
• Running
• Blocked/Waiting (e.g., waiting for input/I/O/network)
• Terminated

Thread operations (mentioned)

• Thread creation (new thread initialized and added to ready queue)
• Thread blocking (resource/I-O wait)
• Thread synchronization (coordination for shared resources)
• Thread termination (completes execution)

Multi-threading

• Definition
  • Multiple threads execute concurrently within a process.
• Benefit
  • Improves responsiveness/performance (e.g., UI doesn’t block during downloads).

Threading models

• Many-to-One
  • Many user threads map to one kernel thread.
  • If one blocks, entire process blocks.
• One-to-One
  • User thread maps to a kernel thread.
  • If one blocks, others can continue.
• Many-to-Many
  • User threads map to a pool of kernel threads.
  • Balances flexibility and performance.

---

Detailed bullet list: CPU Scheduling (objectives + algorithms + metrics + starvation)

Scheduling objectives/criteria (as stated)

• Maximize CPU utilization
• Minimize turnaround time
  • Total time from submission to completion.
• Minimize waiting time
  • Reduce time spent in ready queue.
• Minimize response time
  • Time from submission/arrival until first CPU response.
• Ensure fairness
  • Each process should get a reasonable chance.

Scheduling metrics formulas (as taught)

• Completion time
  • When process finishes execution.
• Turnaround Time (TAT)
  • TAT = Completion time − Arrival time
• Waiting Time
  • Waiting = Turnaround time − Burst time
• Response Time
  • For non-preemptive algorithms: essentially first start delay
  • For preemptive: time until CPU first responds minus arrival time

Starvation

• Meaning
  • Low-priority process may never get CPU due to continuous higher-priority arrivals.
• Aging (solution)
  • Increase priority gradually for waiting processes so they eventually run.

---

Detailed bullet list: CPU scheduling algorithms covered (behavioral rules)

Non-preemptive vs Preemptive

• Non-preemptive
  • Once CPU is given, it runs until completion.
• Preemptive
  • CPU can be taken away when a higher-priority/condition process arrives.

FCFS (First Come First Served)

• Non-preemptive
• Execution order strictly by arrival time.
• If CPU idle occurs (no process ready), CPU remains idle until next arrival.
• Average waiting/turnaround computed using sums/number of processes.

SJF (Shortest Job First)

• Non-preemptive
• Among ready processes, run the one with shortest burst time.
• If equal arrival times, choose by burst time (as discussed via examples).

SRTF (Shortest Remaining Time First)

• Preemptive version of SJF
• At each arrival or scheduling point, choose process with least remaining time.
• If tie, prefer earlier arrival (as described).

Priority Scheduling

• Priority assigned to processes; smaller or larger number indicates higher priority depending on the convention (explained).
• Non-preemptive priority
  • CPU runs current process to completion.
• Preemptive priority
  • If a higher-priority process arrives, it preempts the running one.

Round Robin (time-sharing scheduling)

• Uses time quantum
• Processes run for at most the quantum, then return to ready queue if unfinished.
• Includes ready queue behavior (processes cycle).

Multi-level Queue

• Separate queues for different process types (e.g., interactive vs batch).
• Each queue uses different scheduling algorithm (e.g., RR for one, FCFS for another, priority for another).
• Queue selection depends on priority/class of process.

Multi-level Feedback Queue

• Processes can move between queues based on CPU behavior and waiting time.
• If a process uses full quantum → demote to lower priority queue.
• If it waits too long → promote to higher priority queue (aging-like behavior).

Demand Scheduling (demand-based)

• Chooses processes based on current demand/workload needs and system conditions (CPU/memory/I/O availability).
• Real-time-like decision concept explained.

---

Detailed bullet list: Real-time scheduling

Key idea

• Must meet deadlines: correct result and completion time.

Hard vs Soft real time

• Hard real time
  • Missing deadline → system failure/unacceptable consequences.
• Soft real time
  • Missing deadline → performance degradation only.

EDF (Earliest Deadline First)

• Dynamic priority scheduling
• Choose process with the earliest deadline first.

RMS (Rate Monotonic Scheduling)

• Fixed priority scheduling
• Higher priority to tasks with shorter period (more frequent tasks).

---

Speakers / sources featured

• Speaker: Unspecified (lecture host/YouTube instructor; first person narration: “I am your …” / “Let’s dove in …”, “I will explain …”, “I hope …”).
• Source/brands mentioned as examples: Chrome, VS Code, WhatsApp, Windows/Linux/Android, Web browser/IDE, Burger King, WhatsApp messaging, airbag system, flight control, industrial robots, sensors.