Summary
This comprehensive course introduces fundamental operating system concepts, starting with the definition and roles of an OS. It covers process management, CPU scheduling, deadlock handling, and memory management. The course emphasizes the distinction between programs and processes, explaining how programs in storage become executable processes in memory. It details the structure of a process memory layout (text, data, heap, stack) and the crucial concepts of user mode versus kernel mode operation, including dual-mode processing and mode shifting. The importance of system calls for transitioning between these modes and interacting with hardware is highlighted. The material also touches upon multiprogramming, its advantages in CPU utilization, and the differences between preemptive and non-preemptive systems, alongside architectural requirements for operating systems like DMA compatibility and address translation.
Key Insights
Operating system: Interface between user and computer.
An OS acts as a bridge, translating user commands into machine language and managing hardware resources.
Stored Program Concept: Programs reside in main memory for execution.
Any program to be executed must first be loaded from secondary storage (like a hard disk) into the main memory.
OS as Resource Manager: Manages hardware and software resources.
The OS allocates, deallocates, and manages both hardware (CPU, memory, I/O) and software (files, semaphores) resources.
OS acts like a government managing and providing services.
The OS is analogous to a government, managing resources (ministries) and providing services to users (citizens).
Primary goal varies: convenience vs. efficiency/reliability.
For general-purpose OS, convenience is primary. For real-time systems (missile control, air traffic), efficiency and reliability are paramount.
Multiprogramming: Multiple programs in memory for better CPU utilization.
Multiple ready-to-run programs are loaded into memory. If one program waits for I/O, the CPU can switch to execute another, minimizing idle time and increasing efficiency and throughput.
A program in execution is called a process.
A program becomes a process when it is loaded into memory and actively being executed by the CPU.
Address Translation: Logical to Physical address conversion for security.
The Memory Management Unit (MMU) translates logical addresses generated by programs into physical addresses in memory, providing security and isolation between processes.
Dual Mode Operation: User Mode and Kernel Mode.
CPUs support two modes: Kernel (privileged, mode bit 0) for OS operations and User (non-privileged, mode bit 1) for applications. This prevents user programs from corrupting the OS or hardware.
Mode shifting process: User -> Kernel (SVC -> ISR -> Mode Bit Change).
When a system call like `fork()` is encountered (compiled as SVC), it generates a software interrupt at runtime. An Interrupt Service Routine (ISR) handles this by changing the mode bit to 0 (kernel mode) and finding the OS routine's address.
Program vs. Process: Program is static, Process is dynamic execution.
A program is a set of instructions stored on disk. A process is an instance of a program currently executing in main memory, utilizing system resources.
Process Memory Layout: Text, Data, Heap, Stack.
A process in memory consists of: Text (code), Data (global/static variables), Heap (dynamic memory allocation), and Stack (function call information, local variables).
Sections
Introduction to Operating Systems
Course overview and structure.
The course covers fundamental and advanced OS concepts over 25 hours, divided into seven parts: Introduction, Process Management, CPU Scheduling, Process Synchronization, Deadlock, Memory Management, and File Management.
Learning methodology: theory, numericals, revision.
The learning approach involves understanding concepts with real-life examples (theory), solving numerical problems to test comprehension, and regular revision to retain knowledge. Revision is crucial as notes may seem new after some time.
Course offerings include extensive content and notes.
The course provides 25 hours of content and 400 pages of lecture notes, with advice to create personal short notes. Notes can be downloaded from a website.
Target audience includes students, gate aspirants, and job seekers.
Suitable for university students for semester exams, GATE aspirants, and anyone wanting solid OS fundamentals or preparing for job interviews. Over 100 numericals from standard textbooks and GATE exams are included.
Active learning is emphasized over passive watching.
Viewers are advised to take notes during theory, pause and attempt numericals before viewing solutions, and revise regularly to actively engage with the material.
Prerequisites include basic computer organization and programming exposure.
A little knowledge of computer hardware, architecture, and programming exposure (C or Java) is required. These concepts will be briefly reviewed if needed.
Operating system: Interface between user and computer.
An OS acts as a bridge, translating user commands into machine language and managing hardware resources.
Hardware components: CPU, Memory, Input/Output.
The fundamental hardware components are the CPU (Control Unit, ALU), Memory (primary and secondary), and Input/Output devices.
Control Unit directs operations and executes micro-operations.
The Control Unit manages timing signals and ensures sequential execution of micro-operations, which are operations on data stored in registers.
ALU performs arithmetic and logical computations.
The Arithmetic Logic Unit (ALU) is the functional unit responsible for calculations and logical operations.
Primary memory is fast, expensive, volatile, and smaller.
Primary memory (RAM, ROM, cache, registers) is faster but volatile; its contents are lost when power is off.
Secondary memory is slower, cheaper, non-volatile, and larger.
Secondary memory (hard disk, pen drives) retains data even when power is off and is used for long-term storage.
Von Neumann architecture essentials: CPU, Memory, I/O.
The Von Neumann architecture includes CPU, primary memory, and I/O devices. Secondary memory is typically considered part of I/O.
Stored Program Concept: Programs reside in main memory for execution.
Any program to be executed must first be loaded from secondary storage (like a hard disk) into the main memory.
CPU executes instructions sequentially after loading from memory.
The CPU fetches and executes instructions of a loaded program one after another sequentially from the main memory.
OS modules combine to form the kernel.
The OS kernel is composed of modules like process manager, memory manager, file manager, device manager, and protection manager.
OS as Resource Manager: Manages hardware and software resources.
The OS allocates, deallocates, and manages both hardware (CPU, memory, I/O) and software (files, semaphores) resources.
OS as Control Program: Manages all computer operations.
The OS controls all operations of the computer, acting as a central coordinator.
OS simplifies application development by creating a platform.
The OS handles hardware complexities, allowing developers to focus on writing high-level code.
OS acts like a government managing and providing services.
The OS is analogous to a government, managing resources (ministries) and providing services to users (citizens).
Goals of OS: Convenience, efficiency, reliability, robustness, scalability, portability.
Key goals include making the system easy to use (convenience), utilizing resources effectively (efficiency), performing as designed (reliability), withstanding errors (robustness), ability to evolve (scalability), and work on different platforms (portability).
Primary goal varies: convenience vs. efficiency/reliability.
For general-purpose OS, convenience is primary. For real-time systems (missile control, air traffic), efficiency and reliability are paramount.
Functions of OS: Processor, memory, device, security, file management.
Core functions include managing the CPU, detecting memory errors, ensuring security, and handling file operations.
Multiprogramming and System Architecture
Batch vs. Multiprogramming OS evolution.
Early computers lacked OS. Batch OS managed jobs sequentially. Multiprogramming emerged with disks, allowing multiple programs in memory to improve CPU utilization.
Uniprogramming: Single program in memory, leads to CPU idleness.
In uniprogramming, only one program resides in memory. If it needs I/O, the CPU becomes idle, reducing efficiency and throughput (programs completed per unit time). Example: MS-DOS.
Multiprogramming: Multiple programs in memory for better CPU utilization.
Multiple ready-to-run programs are loaded into memory. If one program waits for I/O, the CPU can switch to execute another, minimizing idle time and increasing efficiency and throughput.
At most one program runs on CPU at any given time.
Even in multiprogramming, a single CPU can only execute instructions from one program at a time. The OS rapidly switches between programs.
Multitasking is preemptive multiprogramming.
Multitasking is essentially preemptive multiprogramming, where 'task' is used synonymously with 'program', common in Windows.
A program in execution is called a process.
A program becomes a process when it is loaded into memory and actively being executed by the CPU.
Schematic of Multiprogramming: Secondary storage to main memory.
Programs reside in secondary storage (hard disk) and are loaded into main memory (system/user areas). If one process waits for I/O, others continue execution, improving CPU utilization.
Multiprogramming improves CPU utilization and reduces idleness.
By keeping the CPU busy with available programs when one process is waiting for I/O or other services, overall system efficiency is enhanced.
Preemptive vs. Non-preemptive Multiprogramming.
Preemptive allows forceful removal of a process from CPU for higher priority tasks or time limits. Non-preemptive allows a process to run until it voluntarily releases the CPU (completion, I/O, system call).
Drawbacks of Non-preemptive Multiprogramming: Starvation, poor interactivity.
Long-running or I/O-bound low-priority processes can block higher-priority processes indefinitely (starvation), reducing responsiveness.
Modern OS use preemptive multiprogramming for better responsiveness.
Operating systems like Windows, Linux, and macOS are preemptive, ensuring fair CPU time allocation and preventing starvation.
Time-sharing OS is a type of preemptive multiprogramming based on time slices.
In time-sharing, processes are allocated CPU time in short intervals. Preemption can also be based on task priority.
Architectural requirements for OS: DMA, Address Translation, Dual Mode.
Key hardware requirements include DMA-compatible storage for efficient data transfer, memory systems supporting address translation for security, and CPU support for dual-mode operation (user/kernel).
DMA allows direct data transfer between devices and memory.
Direct Memory Access (DMA) enables efficient data transfer between secondary storage and main memory without constant CPU intervention.
Address Translation: Logical to Physical address conversion for security.
The Memory Management Unit (MMU) translates logical addresses generated by programs into physical addresses in memory, providing security and isolation between processes.
Dual Mode Operation: User Mode and Kernel Mode.
CPUs support two modes: Kernel (privileged, mode bit 0) for OS operations and User (non-privileged, mode bit 1) for applications. This prevents user programs from corrupting the OS or hardware.
Mode bit in PSW register indicates current mode.
A mode bit within the Processor Status Word (PSW) register in the CPU indicates whether the system is in user mode or kernel mode.
Mode shifting from User to Kernel is necessary for OS services.
When a user application needs to access OS services (e.g., file I/O, process creation), a mode shift from user to kernel mode is required.
Kernel mode has unrestricted hardware access; User mode is restricted.
Kernel mode allows full access to hardware and any memory address. User mode code must use system APIs and cannot directly access hardware.
User mode crashes are recoverable; Kernel mode crashes are catastrophic.
Crashes in user mode typically don't affect the OS. Kernel mode crashes often lead to system halts (e.g., Blue Screen of Death).
Process Management and Mode Shifting
Mode shifting from User to Kernel via APIs/System Calls.
Mode shifting is facilitated by Application Programmer Interfaces (APIs) or System Call Interfaces (SCI), which act as intermediaries to OS services.
User-defined and predefined functions run in User Mode.
Functions written by users or predefined library functions (like printf) execute in user mode, even if their implementation resides in compiler libraries.
System calls and OS kernel routines run in Kernel Mode.
Only specific OS kernel routines or system calls (like `fork`, `read`, `write`) are executed in the privileged kernel mode.
`fork()` system call creates a child process.
The `fork()` system call is an OS routine implemented in the kernel that duplicates the calling process, creating a child process.
Mode shifting process: User -> Kernel (SVC -> ISR -> Mode Bit Change).
When a system call like `fork()` is encountered (compiled as SVC), it generates a software interrupt at runtime. An Interrupt Service Routine (ISR) handles this by changing the mode bit to 0 (kernel mode) and finding the OS routine's address.
Dispatch Table locates OS routines in Kernel Mode.
The OS maintains a dispatch table in memory that maps system call identifiers to the addresses of the corresponding kernel routines.
Execution in Kernel Mode is atomic and privileged.
Once in kernel mode, the OS routine executes without interruption (atomically) and has full access to hardware.
Mode shifting back: Kernel -> User (Mode Bit Change).
After the kernel routine completes, the mode bit is changed back to 1 (user mode) without generating an interrupt, returning control to the user program or OS.
Program vs. Process: Program is static, Process is dynamic execution.
A program is a set of instructions stored on disk. A process is an instance of a program currently executing in main memory, utilizing system resources.
Process Memory Layout: Text, Data, Heap, Stack.
A process in memory consists of: Text (code), Data (global/static variables), Heap (dynamic memory allocation), and Stack (function call information, local variables).
Static data allocated at load time; dynamic data at run time.
Static data (like global variables, instruction code) is allocated at load time. Dynamic data is allocated at run time, often using functions like `malloc`.
Activation Records store local variables and return addresses on the stack.
When a function is called, an activation record is pushed onto the stack, containing space for its local variables and the return address to resume execution after the function finishes.
Privileged instructions (e.g., interrupt control) only in Kernel Mode.
Instructions like enabling/disabling interrupts, context switching, and clearing memory are privileged and can only be executed in kernel mode.
The `fork()` system call creates multiple copies of the process.
Each `fork()` call duplicates the calling process. Three `fork()` calls result in 2^3 = 8 copies of the subsequent print statement execution.
Ask a Question
*Uses 1 Wisdom coin from your coin balance
![Learn C Programming and OOP with Dr. Chuck [feat. classic book by Kernighan and Ritchie]](https://i.ytimg.com/vi/PaPN51Mm5qQ/hqdefault.jpg)
