Concepts of Operating Systems

Define a process as a program loaded into memory and running as an active instance, and outline its creation, management, and scheduling.

Explain how a process image appears in main memory, detailing the code, data, heap, and stack regions and how the program counter and return addresses guide function calls.

Explore the process control table, memory table, and device table, and learn how entries point to a process image in memory, showing how memory, devices, pipes, and processors are managed.

Explore the process control block, a data structure that stores a process's unique id, state, registers, access control, and memory image, guiding process management.

Explore the resource monitor in operating systems, learn how each process has a unique id, and view its memory use, network activity, and port address on your computer.

Explore the five state model of a process, including new, ready, running, waiting, and terminated states, plus transitions, process control blocks, and basic scheduling and preemption concepts.

Explore the roles of long-term, medium-term, and short-term schedulers in deciding which processes enter memory, wait, or run, and how ready, device, and job queues organize states.

Classify processes as independent or cooperating (dependent), and understand how these relationships influence CPU utilization and scheduling.

Interprocess communication in this lecture covers two methods: message passing through the kernel and shadow memory with shared memory.

Explore race condition and how concurrent access to the critical section causes data inconsistency. Discover how mutual exclusion allows only one process to enter the critical section at a time.

Explore how the critical section problem is solved with hardware, software, and operating system approaches, including disabling interrupts to achieve mutual exclusion and prevent race conditions.

Learn how mutex locks and semaphores enforce mutual exclusion and protect the critical section using acquire and release, or wait and signal with binary and counting semaphores.

Explains the readers-writers problem and its semaphore-based solution, using read count and a write lock (w r p) to give readers priority while ensuring writer exclusivity.

Learn how scheduling criteria drive CPU scheduling decisions, from long-term and short-term (CPA) schedulers to algorithms that optimize waiting time, CPU utilization, throughput, turnaround time, and response time.

Explore the first-come, first-served fcfs scheduling algorithm, a non-preemptive cpu scheduler, and learn to compute turnaround and waiting times from gunshot-style snapshots.

This lecture explains the convoy effect in first-come, first-served scheduling: shorter burst-time processes wait longer behind longer bursts, raising average waiting time, as shown by the B1–B3 example.

Explore the shortest job first algorithm and its use of burst time and arrival time to reduce the convoy effect, with an example calculating turnaround and waiting times.

Explore the shortest remaining job first, a preemptive variant of the shortest job first algorithm, illustrated with a process-based example showing preemption, waiting time, and turnaround time.

Explore the round robin algorithm with a fixed 2-second time quantum, learn how cpu time slices are allocated in a preemptive, fair scheduling scheme, and see a step-by-step example.

Explore deadlocks in operating systems, where a process holds a resource and waits indefinitely for another, causing mutual blocking, illustrated with R1 and R2; banker's algorithm is discussed next.

Apply the banker's algorithm to allocate resources safely, using max, allocation, and need matrices against current availability to avoid deadlock and determine a safe execution sequence.

Explore threads as lightweight units of execution within a process, each with its own registers and stack. See how multi-threading enables parallelism, faster responses, with many-to-one, one-to-one, and many-to-many models.

Explore memory management in operating systems by comparing primary memory and secondary memory, and explain how processes and data are stored in RAM, cache, and permanent storage.

Learn how a source program is compiled into object code, linked into a load module, and loaded by the loader to form a process image in memory.

Explore memory management when programs exceed memory space and learn two solutions: overlays and dynamic linking, including loading only the needed parts and unloading unused functions.

This lecture explains how logical addresses, tied to a process, translate to physical addresses in RAM using the memory management unit and base relocation, enabling safe, dynamic memory allocation.

The memory management unit enables relocation, protection, and sharing of memory. It translates logical addresses to physical ones, supports compacting, and prevents fragmentation.

Explore fixed and variable partitioning as memory management techniques, compare equal-sized fixed partitions with unequal variable partitions, and highlight internal fragmentation and the role of displacement algorithms in allocation.

Discover memory placement algorithms that allocate processes to variable partitions while minimizing wasted memory. Compare first fit, best fit, worst fit, and next fit, including how starting points affect allocations.

Learn how paging converts a process's logical address space into physical memory by dividing it into pages and mapping them to frames via a page table, enabling noncontiguous storage.

Analyze implementing page tables with a tlb to speed virtual memory lookups, using associative memory to cache translations and calculate effective access time for hits and misses.

Explore segmentation as the counterpart to paging, dividing the logical space into segments based on user views and mapping them to frames via a segment table, enabling 16-bit address translation.

Explore Linux basics as a Unix-based kernel and learn command-based, text-driven interaction with hardware through a shell. Identify common Unix shells like bash, csh, and zsh.

Explore basic Unix commands in a Linux shell, including pwd, ls, and cd, and learn how to identify files vs. directories and view hidden files.