Operating Systems Exam Revision Guide

An Operating System is a software program that connects end users to computer hardware, functioning as a translator between high-level and low-level languages. It acts as an intermediary between the user and computer hardware, providing a user-friendly interface. The OS manages computer hardware and software resources, enabling users to execute applications without needing detailed knowledge of the underlying hardware operations. It serves as both a resource manager and an extended machine, making complex hardware operations transparent to users.

The fundamental goals of an Operating System are:

1. To execute user programs and make tasks easier for users
2. To manage and control the entire set of computer resources effectively
3. To provide convenience for clients through a user-friendly interface
4. To ensure efficient operation of the computer system by optimizing resource utilization

These goals enable the OS to act as both a resource manager (allocating CPU, memory, I/O devices) and an extended machine (hiding hardware complexities from users), ensuring smooth operation and maximizing system efficiency.

The different types of Operating Systems are:

1. Batch Operating System - Processes jobs in groups with minimal manual intervention
2. Multitasking Operating System - Allows multiple tasks to run seemingly simultaneously
3. Time Sharing OS - Shares CPU time among multiple users for interactive computing
4. Multiprocessing OS - Utilizes multiple CPUs or processor cores for improved performance
5. Real Time OS - Processes data within guaranteed time constraints for critical applications

Each type serves specific computing needs, from large-scale data processing (Batch) to interactive user environments (Time Sharing) and mission-critical systems (Real Time).

a) Program: A program is a well-organized set of instructions written in a programming language, stored on secondary storage devices like hard drives. It is a passive entity containing the code that directs the computer to perform specific tasks.

b) Process: A process is the active execution of a program. It represents a program that is currently running, including its code, data, current activity, and the state of processor and memory allocated to it. The OS manages processes, allocating resources for their execution.

Demand Paging is a common Virtual Memory Management technique where pages of a process that are used the least are stored in secondary memory. Pages are only loaded into main memory when they are requested by the CPU or when a page fault occurs. Various page replacement algorithms determine which pages should be swapped in or out. This technique allows systems to run processes larger than physical memory by loading only necessary parts, improving memory utilization and enabling higher multiprogramming.

The three primary File Access methods are:

1. Sequential Access: Records are accessed in a pre-defined order, one after another. Information is processed sequentially from the beginning of the file. This is the most common method for accessing files like text files or compiler input.
2. Random Access (Direct Access): Records can be accessed directly using a unique address or key, without going through preceding records. This allows reading or writing any record immediately.
3. Index Sequential Access: Combines features of sequential and random access. An index is created for the file containing pointers to record locations. The index is searched (often sequentially) to find the pointer, which then allows direct access to the desired record.

Definition / Introduction:

A computer system consists of five integrated components working together to process and manage information. Understanding these components is essential for grasping how an Operating System functions as a resource manager.

Key Points / Explanation:

1. Hardware: Provides basic computing resources including CPU, memory (RAM), and I/O devices (keyboard, monitor, disk drives). The hardware forms the physical foundation of the system.
2. Operating System: Acts as both a resource manager (managing hardware and software resources) and an extended machine (providing a user-friendly interface that hides hardware complexities).
3. Utilities: Helper programs that supplement OS capabilities, handling critical tasks like disk optimization and anti-virus protection.
4. Application Programs: Software designed to perform specific user tasks, such as word processors, web browsers, or games.
5. End Users: People who interact with the computer system to achieve specific goals, either directly with applications or through the OS.

Examples / Applications:

When a user (End User) types a document in Microsoft Word (Application Program), the OS manages loading the program into RAM (Hardware), handles keystrokes from the keyboard (Hardware), stores the document on the hard disk (Hardware), and uses utility programs for tasks like spell-checking (Utilities).

Conclusion:

These five components work in harmony to form a complete computer system. The hardware provides the foundation, the OS manages resources and provides an interface, utilities offer supplementary services, application programs fulfill user needs, and end users drive the system's purpose.

Definition / Introduction:

A Multiprogramming Operating System is an approach where multiple programs (jobs) reside in main memory simultaneously, and the CPU executes them concurrently. It is designed to maximize CPU utilization by ensuring the processor remains busy.

Key Points / Explanation:

1. Multiple Programs in Memory: More than one program or job is kept in the main memory at any given time.
2. CPU Utilization Focus: When one job requires I/O operations (during which the CPU would otherwise be idle), the OS switches to another job that needs CPU processing.
3. Mechanism: The OS selects a job from memory and starts its execution. If that job needs I/O, the OS switches to another ready job, continuing this process to keep the CPU active.
4. Resource Management: Requires memory management to hold multiple jobs and CPU scheduling to determine execution order.

Examples / Applications:

Consider a system where a user program (Job P1) is performing calculations and then needs to read data from a disk. Instead of letting the CPU sit idle during the disk read, the multiprogramming OS switches to execute another user program (Job P2) that is ready for CPU processing. Once the disk read for P1 completes, P1 might regain the CPU.

Advantages and Disadvantages:

Advantages: High CPU utilization (CPU rarely idle), efficient memory utilization, high CPU throughput.

Disadvantages: CPU scheduling becomes mandatory (many jobs compete for CPU), users cannot interact directly with executing jobs, and programmers cannot modify a program while it's running.

Definition / Introduction:

The Process Life Cycle describes the various states a process transitions through from creation to termination within an Operating System. Understanding these states is fundamental to process management.

Key Points / Explanation:

1. New: The process is created by the OS but not yet admitted to the ready queue for execution.
2. Ready: The process is loaded into main memory and waiting to be assigned to a CPU for execution.
3. Running: The process is currently being executed by the CPU (only one process can be in this state per CPU).
4. Blocked (Waiting): The process cannot execute further because it's waiting for an event (e.g., I/O completion).
5. Exit (Terminated): The process has finished execution or was terminated; OS releases its resources.

Diagram Description:

The cycle begins with the New state. The process moves to Ready state, then to Running when scheduled. While Running, it can transition to Blocked if waiting for an event, or directly to Exit if completed. A Blocked process returns to Ready once the awaited event occurs. Finally, all processes reach the Exit state.

Examples / Applications:

When you open a web browser (New → Ready → Running), it pauses while waiting for a webpage (Blocked), resumes once loaded (Ready → Running), and closes when you exit (Exit). This demonstrates the complete life cycle in action.

Definition / Introduction:

First-Come, First-Served (FCFS) is a non-preemptive CPU scheduling algorithm where processes execute in the order they arrive in the ready queue, following a FIFO (First In, First Out) approach.

Key Points / Explanation:

• Principle: Jobs execute on a first-come, first-served basis
• Nature: Non-preemptive scheduling algorithm
• Mechanism: Processes enter the ready queue upon arrival; CPU executes the head process until completion
• Gantt Chart Representation:
  • P1 arrives at time 0, runs for 15ms (finishes at time 15)
  • P2 arrived at time 2, runs from time 15 for 10ms (finishes at time 25)
  • P3 arrived at time 4, runs from time 25 for 5ms (finishes at time 30)
  • P4 arrived at time 8, runs from time 30 for 8ms (finishes at time 38)

Calculation Table:

Process	Arrival Time (AT)	Burst Time (BT)	Completion Time (CT)	Turnaround Time (TAT = CT - AT)	Waiting Time (WT = TAT - BT)
P1	0	15	15	15 - 0 = 15	15 - 15 = 0
P2	2	10	25	25 - 2 = 23	23 - 10 = 13
P3	4	5	30	30 - 4 = 26	26 - 5 = 21
P4	8	8	38	38 - 8 = 30	30 - 8 = 22

Conclusion / Evaluation:

• Average Turnaround Time: (15 + 23 + 26 + 30) / 4 = 94 / 4 = 23.5 ms
• Average Waiting Time: (0 + 13 + 21 + 22) / 4 = 56 / 4 = 14 ms
• Evaluation: FCFS is simple to implement but can lead to poor performance with high average waiting time. The "convoy effect" occurs when longer processes arrive early, causing shorter processes arriving later to wait unnecessarily. It's suitable for batch systems but not optimal for time-sharing environments.

Definition / Introduction:

Paging is a fixed-size partitioning memory management scheme where both logical memory (program) and physical memory (RAM) are divided into equal-sized blocks.

Key Points / Explanation:

1. Fixed-Size Partitioning: Paging uses a fixed-size partitioning approach for memory management.
2. Terminology:
   • Pages: Fixed-size blocks of logical memory (secondary storage)
   • Frames: Fixed-size blocks of physical memory (RAM)
   • Page size always equals frame size
3. Mechanism: Process pages are stored in available main memory frames. The OS maintains a page table for each process to map logical page numbers to physical frame numbers.
4. Non-Contiguous Allocation: Allows processes to be allocated physical memory frames scattered throughout RAM.

Examples / Applications:

Consider a system with 16 KB main memory and 1 KB frame size. Memory is divided into 16 frames. A 4 KB process is divided into 4 pages (1 KB each). These pages can load into any 4 available frames regardless of adjacency. If pages 2 and 4 of another process are deallocated, creating 2 free frames, a new process's pages can occupy these scattered free frames.

Advantages and Disadvantages:

Advantages: Simplifies memory allocation; eliminates external fragmentation; allows efficient use of non-contiguous memory; supports virtual memory effectively.

Disadvantages: Suffers from internal fragmentation (unused space in last page/frame); requires page table overhead; can increase memory access time (though mitigated by TLB).

Definition / Introduction:

Deadlock is a situation where a set of processes are blocked indefinitely because each process holds a resource and waits for another resource held by another process in the set.

Key Points / Explanation:

1. Blocking: Processes involved cannot proceed as they wait for resources held by others.
2. Mutual Dependency: Creates a circular chain where each process holds a resource needed by another process.
3. Necessary Conditions: Four conditions must simultaneously hold for deadlock:
   • Mutual Exclusion: Resources cannot be shared; only one process uses a resource at a time.
   • Hold and Wait: A process holds at least one resource while waiting for additional resources.
   • No Pre-emption: Resources cannot be forcibly taken from a process; must be released voluntarily.
   • Circular Wait: A circular chain exists where each process waits for a resource held by the next process.

Examples / Applications:

Consider two processes, P1 and P2. P1 holds Resource R1 and requests R2 (held by P2), while P2 holds R2 and requests R1 (held by P1). Both processes are deadlocked, waiting for each other indefinitely. This often occurs in database systems when transactions lock different records in conflicting orders.

Conclusion:

Deadlock is a problematic state in multiprogramming systems causing processes to be perpetually blocked, wasting resources and reducing throughput. Understanding and managing deadlock is crucial for system stability, with prevention, avoidance, and detection/recovery being primary management strategies.

Definition / Introduction:

Virtual Memory is a memory management technique creating the illusion of having more main memory available than physically installed, allowing processes larger than RAM to execute.

Key Points / Explanation:

1. Illusion of Large Memory: Makes secondary storage (like a hard disk) appear as part of main memory.
2. Mechanism: Loads only necessary parts (pages or segments) of processes into main memory; the rest resides on disk.
3. Implementation: Uses techniques like Demand Paging (loading pages only when needed, triggered by page faults) or Demand Segmentation.
4. Goal: Enables execution of processes larger than physical RAM, increasing multiprogramming and CPU utilization.

Examples / Applications:

Consider a computer with 4GB RAM running a program requiring 6GB memory. Virtual memory allows this by keeping 4GB in RAM and 2GB on disk. When the program needs data from disk-stored parts, the OS swaps it with less-used RAM data. Modern OS like Windows and Linux use this extensively for large applications.

Advantages and Disadvantages:

Advantages: Executes processes larger than physical memory; increases multiprogramming and CPU utilization; enables running large applications with less RAM; avoids immediate physical memory upgrades.

Disadvantages: Slows system due to page fault handling time; involves overhead for address translation using page tables; can cause "thrashing" if too many page faults occur.

Definition / Introduction:

File Access Methods define how records within a file are accessed, read, or written by programs or users. Different methods suit different application requirements and data retrieval patterns.

Key Points / Explanation:

1. Sequential Access:
   • Records accessed in pre-defined sequential order, one after another
   • Information processed from beginning to end
   • Most common for text files or compiler input
   • Requires reading all preceding records to reach a specific record
   • Simple implementation but inefficient for random record access
2. Random Access (Direct Access):
   • Records accessed directly using unique addresses or keys
   • No need to traverse preceding records
   • Each record has a unique address for immediate reading/writing
   • Ideal for database applications requiring quick record retrieval
   • More complex implementation than sequential access
3. Index Sequential Access:
   • Combines sequential and random access features
   • Creates an index with direct pointers to memory blocks
   • Index searched sequentially to find pointer, then direct access to record
   • Improves access efficiency and reduces single-record access time
   • Multiple indexing levels can be used for large files
   • Balances performance between sequential scanning and direct record access

Examples / Applications:

• Sequential: Reading a log file line by line from start to finish
• Random: Accessing a specific customer record using their unique ID in a database
• Index Sequential: Using an index (like a book's index) to quickly locate specific entries in a large data file

Conclusion / Evaluation:

Choosing the appropriate file access method is crucial for application performance. Sequential access is simple for batch processing but inefficient for random access. Random access provides immediate record retrieval but may be complex to implement. Index sequential access offers a balanced approach, providing reasonable performance for both sequential scanning and direct record access, making it suitable for many database applications. The optimal choice depends on the specific data access patterns required by the application.

Definition / Introduction:

File Access Methods define how records within a file are accessed, read, or written by programs or users. Different methods suit different application requirements and data retrieval patterns.

Key Points / Explanation:

1. Sequential Access:
   • Records accessed in pre-defined sequential order, one after another
   • Information processed from beginning to end
   • Most common for text files or compiler input
   • Requires reading all preceding records to reach a specific record
   • Simple implementation but inefficient for random record access
2. Random Access (Direct Access):
   • Records accessed directly using unique addresses or keys
   • No need to traverse preceding records
   • Each record has a unique address for immediate reading/writing
   • Ideal for database applications requiring quick record retrieval
   • More complex implementation than sequential access
3. Index Sequential Access:
   • Combines sequential and random access features
   • Creates an index with direct pointers to memory blocks
   • Index searched sequentially to find pointer, then direct access to record
   • Improves access efficiency and reduces single-record access time
   • Multiple indexing levels can be used for large files
   • Balances performance between sequential scanning and direct record access

Examples / Applications:

• Sequential: Reading a log file line by line from start to finish
• Random: Accessing a specific customer record using their unique ID in a database
• Index Sequential: Using an index (like a book's index) to quickly locate specific entries in a large data file

Conclusion / Evaluation:

Choosing the appropriate file access method is crucial for application performance. Sequential access is simple for batch processing but inefficient for random access. Random access provides immediate record retrieval but may be complex to implement. Index sequential access offers a balanced approach, providing reasonable performance for both sequential scanning and direct record access, making it suitable for many database applications. The optimal choice depends on the specific data access patterns required by the application.