Operating System

Explain how a user program becomes an executable, is loaded by the operating system into a process, and stores static/global variables and a stack, clarifying the program–process distinction.

Identify and manage a process by its attributes, including properties, program counter for the next instruction, process state, priority, general purpose registers, devices, and protection in the process control block.

Explore the seven states a process traverses from creation to completion—new, ready, execution, completion, termination, blocked, and suspended—and how memory and secondary storage shape transitions.

Follow how the state transition diagram maps new, ready, running, blocked, suspended, and terminated states, with scheduling, preemption or non preemption, and degree of multiprogramming.

Understand how long-term, short-term, and medium-term schedulers govern process flow, from new to ready to run, including context switching, dispatching decisions, and swapping between main and secondary memory.

Examine how an operating system manages processes via creation, scheduling, execution, and killing to free memory for later use.

Explore how scheduling queues manage process transition from creation to ready, running, waiting, blocked, and suspended states, using round-robin time slices, priority timers, and IO events.

This lecture explains various cpu scheduling times—burst time, completion time, turnaround time, waiting time, and response time—and how they relate to process states.

Explore cpu scheduling basics, distinguishing long-term and short-term schedulers, the ready-to-run state, context switching, and various scheduling algorithms that decide which process runs next.

Learn first come first serve scheduling, based on arrival time, and understand how pre-emptive and non-pre-emptive modes affect time sharing and CPU allocation.

Analyze the first-come, first-served scheduling algorithm with an example, calculating completion, turnaround time, and waiting times for processes. Explore non-preemptive execution and the convoy effect.

Examine the convoy effect in cpu scheduling: a long burst delays following processes, increasing average waiting time, with examples and charts, contrasting with eventual shift toward shortest job first.

Master non-preemptive shortest job first scheduling by selecting the arrived process with the smallest burst time, compare with first-come-first-served, and compute completion, waiting, and turnaround times.

Analyze the shortest job first scheduling algorithm, its min-heap data structure and time complexity. Note high throughput and minimum average waiting and turnaround times, plus starvation and unpredictable burst times.

Explore static and dynamic burst time prediction techniques, using process size or process data as barometers, and distinguish system versus user, interactive, foreground, and background processes.

Explore dynamic prediction techniques for process burst times, including simple averaging and exponential aging, with formulas for the next prediction and smoothing factor alpha.

Compute process burst times using exponential averaging with alpha 0.5 to predict next CPU bursts and illustrate aging within a scheduling algorithm.

Explore the shortest remaining time first preemptive scheduling algorithm, with arrival and burst times, Gantt chart analysis, and calculations of completion, turnaround, and waiting times.

Examine the shortest remaining time first (SRTF) scheduling algorithm, noting that convoy effects are not possible and its comparison to FCFS and CFS, with unit-time preemption.

the lecture introduces the round robin scheduling algorithm, using a fixed time quantum to run each process in turn, pre-emptively switching when the quantum expires and rechecking for completion.

Explore the round robin scheduling example, focusing on time quantum, ready queue dynamics, process completion, and calculating average turnaround and waiting times.

Analyze how the round robin algorithm behaves as time quantum varies, noting that infinity makes it first come first served and small quanta increase context switching but reduce response time.

Explore the longest job first scheduling algorithm, opposite of shortest job first, with a multi-process example showing completion, turnaround, and average waiting times.

Explore longest remaining time first scheduling, a preemptive algorithm selecting the largest remaining burst, contrasting with fcfs and rr, and covering completion, turnaround, and waiting time.

Explore the highest response ratio next scheduling algorithm (hr rn), a non-preemptive method using waiting time and service time to select the next process, illustrated with a multi-process example.

Classify process priority into static and dynamic, noting static priority remains fixed for problem solving while dynamic priority can change; explore non pre-emptive and pre-emptive scheduling approaches.

Apply non-preemptive priority scheduling by using arrival and burst times to compute completion, turnaround, and waiting times. Understand that priority values may invert, with higher numbers sometimes indicating higher priority.

Explain preemptive priority scheduling, where a running process yields after one time unit to the highest priority ready process. Compare this with shortest remaining time strategies under preemption.

Explore multilevel queue scheduling across four levels, applying different algorithms to system, interactive, and batch processes while addressing starvation with multilevel feedback queues.

Explore synchronization techniques that resolve inconsistency in inter-process communication on a single computer. Learn how networking enables communication between processes on different machines and prevents chaos.

Examine how two processes share a counter and, when executed interleaved, can cause a race condition, producing inconsistent final counts due to unsynchronized increments and decrements.

Explore the critical section concept, where two processes share memory and resources, risking race conditions. Learn synchronization mechanisms that manage the order of execution to ensure correct results.

The four requirements for synchronization mechanisms are mutual exclusion and progress, with bounded waiting and architectural neutrality to prevent starvation and hardware dependence.

Identify two categories of synchronization mechanisms—busy waiting and without busy waiting approaches—explaining how processes either repeatedly attempt to access the critical section or perform other tasks until it becomes available.

Explore how a simple lock variable fails to guarantee mutual exclusion in critical section access, demonstrating busy waiting, pre-emptive scheduling, and the need for a robust synchronization solution.

Explore the test-and-set lock solution for synchronization in operating systems, showing how an atomic operation ensures mutual exclusion and progress, while noting issues like starvation and priority inversion.

Examine how interrupt disabling enforces mutual exclusion in a critical section, and analyze its effects on progress, bounded waiting, and architectural neutrality within an operating system.

Explore strict alternation approach using a turn variable to enforce mutual exclusion and bounded waiting in critical section, via a software mechanism with done variables and entry and exit sections.

Examine how lock variables and turn variables control access to the critical section, using zero and one signals, and compare mutual exclusion and progress across two or more processes.

Explore the interested variable, a two-flag software mechanism for mutual exclusion that ensures portability and architectural neutrality while handling entry, exit, and busy-wait scenarios in the critical section.

Compare the interested variable and the turn variable for mutual exclusion, showing the interested variable provides both mutual exclusion and progress, with bounded waiting and architecture neutrality.

Peterson's solution is a true two-process mutual exclusion mechanism implemented in user space, architecture neutral, combining approaches to cover primary and secondary synchronization requirements and protect the critical section.

This lecture presents Peterson's solution for two processes, detailing entry and exit sections and the critical section to guarantee mutual exclusion and progress.

Explore synchronization without busy waiting by using sleep and wakeup mechanisms to manage access to the critical section, resolve priority issues, and address the producer-consumer problem.

Understand the producer and consumer problem with a bounded buffer of capacity 100, implemented in C, and learn sleep and wake up coordination for synchronization.

Explore counting semaphore concepts, including how it controls access to critical sections, permits multiple processes, and does not guarantee mutual exclusion, with contrasts to binary semaphores and producer-consumer deadlock handling.

Explore how binary semaphores enforce mutual exclusion and progress for critical sections, using zero/one values, P and V operations, and the counting semaphore concepts to handle deadlock and producer-consumer issues.

Identify deadlock as a situation where two or more processes wait for resources held by others, causing indefinite blocking and potential starvation.

Identify the four necessary conditions for deadlock—mutual exclusion, hold and wait, no pre-emption, and circular wait—and explain how they cause resource contention.

The lecture distinguishes single and multi-instance resources, shows how the operating system allocates resources to processes, and analyzes the minimum resource units needed to prevent deadlock.

Determine the maximum number of processes that can run without deadlock with two units per process and total resources, and identify the minimum that would cause deadlock.

Explore strategies for handling deadlock, including deadlock ignorance, prevention, avoidance, and detection and recovery, with a focus on the ostrich approach used in early operating systems.

explains deadlock prevention by disabling at least one of the necessary conditions, such as mutual exclusion and no preemption, and notes that this approach is not a very good method.

Explore deadlock prevention by disabling the four conditions: pool everything for mutual exclusion, require all resources upfront to avoid hold and wait, and order resources numerically to prevent circular wait.

Identify safe and unsafe states during resource allocation. Apply the Banker's algorithm to keep the system in a safe state and rollback allocations when a state becomes unsafe.

This lecture demonstrates the Banker's algorithm with three resources x, y, z and five units each, computing available resources and a safe sequence for processes b0, b1, and b2.

Explore the banker's algorithm by examining allocation, maximum need, feasibility, and the safe state and safe sequence decisions for multiple processes.

Learn how the resource allocation graph models processes and resources, distinguishing single and multi-instance resources, and how request and assignment edges reveal safe versus unsafe states for deadlock detection.

Analyze the resource allocation graph to see how single-instance resources are allocated and requested, evaluate availability, and identify cycles to assess potential deadlock and backlog in the system.

Explore how a multi-instance resource graph tracks allocation and requests across processes, reveals cycles, and demonstrates that cycles are necessary but not sufficient for deadlock detection.

Explore deadlock detection and recovery in operating systems, covering single-instance and multiple-instance cases, bankers algorithm detection, and recovery methods like preemption, rollback, or killing processes.

Explore the memory hierarchy—from registers to secondary memory—and see how volatile and non-volatile memory affect data retention, while memory management techniques boost CPU efficiency.

Explore fixed partitioning in contiguous memory allocation, learn how memory is divided into fixed spaces, and examine internal and external fragmentation and size limitations.

Explore non-contiguous allocation, including paging and segmentation, to place process pages into frames across memory, reducing fragmentation and increasing memory management flexibility.

Explore memory management through segmentation and the division of a process into pages and memory into frames; compare user and programmer perspectives to understand how grouped pages reveal meaningful information.

Explore memory management concepts, including fixed and dynamic partitions, equal and unequal partitions, internal and external fragmentation, paging and segmentation, and the role of virtual memory in efficient process execution.