Operating Systems from scratch - Part 1

Define a computer system as hardware, software, and data that solve human problems, and explain how the CPU fetches programs from RAM for fast processing and permanent storage.

Understand how CPU, RAM, hard disk, and compiler enable high level programs to become machine code. The CPU fetches from RAM; otherwise copies from the hard disk.

Discover how operating systems act as resource managers, allocating RAM and CPU. Learn how long-term schedulers move programs from disk to memory and short-term schedulers assign the CPU.

Explore how the operating system manages memory and I/O by coordinating RAM, OS code space, and user space, with buffering and CPU I/O interaction.

A program on disk becomes a process in RAM when opened; multiple instances can exist, and a process moves through new, ready, running, input/output, blocked, terminated, and suspend states.

Compute the degree of multiprogramming as the maximum number of processes that fit in RAM, illustrated by 4 GB RAM and 4 KB process, giving 2^20 processes.

Compare batch, multiprogramming, and multiprocessing operating systems, highlighting degree of multiprogramming, CPU efficiency, and parallel versus concurrent processing to maximize CPU and I/O utilization.

Demonstrate the three OS types—batch OS, multiprogramming OS, and multi-processing OS—and explain that the course defaults to multiprogramming OS, with a single CPU and multiple processes in RAM.

Learn how a program becomes a process, explore the process control block, stack and heap, program counter, and basic scheduling concepts like first come first served and shortest job first.

Explain how a process context and PCB define execution, and how long, medium, and short term schedulers use swapping and preemption to manage context switching.

Explore the difference between point-in-time and duration-in-time in process timing, including arrival, completion, and turn-around time, with examples of preemption, ready state, waiting, and input/output time.

Explore preemptive and non-preemptive scheduling algorithms, and learn how ready, running, and I/O states affect CPU decisions, ensuring you choose processes in the RAM efficiently.

Explore the shortest job first scheduling algorithm, a non-preemptive, priority-based method that selects the arrived process with the least burst time, and learn to interpret its Gantt chart.

Compute completion times for P1 through P5 and derive turnaround time, waiting time, schedule length, and throughput under a no IO assumption in a shortest job first scheduling example.

Demonstrates a non-preemptive SJF scheduling with five processes, using a Gantt chart to compute completion, turnaround, and waiting times, then determine the schedule length and throughput.

Explore the shortest remaining time first (SRTF) preemptive scheduling algorithm, its relation to SJF, how arrivals trigger preemption, and key metrics like completion, turnaround, waiting time, and throughput.

Explore how response time is calculated in SJF and SRTF with a step-by-step example, distinguishing response time from waiting time and highlighting non-preemptive versus preemptive behavior.

Apply the SRTF scheduling algorithm to an arrival-based set of processes, construct a Gantt chart, compute completion times and turnaround times, and derive the average waiting time.

Compute response time for four processes by comparing arrival to RAM with CPU start: P1, P2, and P4 wait zero, P3 waits 7 units; average response time is 7/4 units.

Learn to solve an SRTF scheduling problem by building a Gantt chart, calculating completion times, turn around times, and waiting times, and deriving the average waiting time.

Learn the first come first served scheduling algorithm, a non-preemptive policy that schedules by arrival time, and analyze completion, turnaround, waiting, and response times with a Gantt chart.

Learn how FCFS scheduling with a 1 time unit context switching overhead affects completion times, CPU efficiency, and waiting, turnaround, and response times in non-preemptive, multi-process systems.

Explore FCFS, SJF, and SRTF scheduling, highlighting starvation and waiting indefinitely, and show why FCFS avoids starvation while SJF and SRTF risk it.

The convoy effect occurs when a small burst waits for a big burst under FCFS or non-preemptive SJF, raising waiting and turnaround times; SRTF avoids this by preemption.

Explore the practical implementation of SJF, SRTF, and FCFS, and compare throughput, noting that SJF and SRTF offer higher throughput but are hard to implement due to burst time prediction.

Explore throughput as the rate of processes completed per time unit and compare FCFS, SJF, and SRTF, highlighting preemption and shortest remaining time principles.

Explains the longest job first scheduling algorithm, a non-preemptive, priority-based approach opposite to shortest job first; highlights starvation, convoy effects, low throughput, and burst-time prediction challenges.

Explore the longest job first non-preemptive scheduler using a Gantt chart to compute completion times, turnaround times, waiting times, response times, and throughput for five processes.

Explore the longest remaining time first scheduling algorithm, a preemptive variant of longest job first, and its drawbacks like starvation, convoy effects, and throughput issues.

Explore the longest remaining time first scheduling algorithm, with tie-breaking by arrival time and process id, illustrated through a step-by-step Gantt chart of three processes.

Demonstrates the longest remaining job first scheduling algorithm, with tie-breaking by earliest arrival, illustrated by a step-by-step Gantt chart of P1, P2, and P3 and idle cpu time.

Compute completion times 9, 10, and 11 in a non-preemptive schedule for three processes, derive turnaround times 8 and waiting times 6, 4, and 4, with throughput 3 by 10.

Explore round robin scheduling, a popular operating-system method using a time quantum. Understand first come, first served preemption and how a queue handles rear insertion and front deletion.

Explore round robin scheduling with a time quantum of 2, showing how arrivals enter the ready queue, how the CPU preempts running processes, and how a Gantt chart tracks progress.

Apply round-robin scheduling with a 3 time-unit quantum to a multi-process run, observe process arrivals, queue ordering, preemption, and completion across a detailed Gantt chart.

Increasing time quantum may decrease context switches, but not always, affecting overhead and CPU efficiency. As time quantum grows, the response time increases, reducing interactivity.

Examine round robin scheduling advantages like no starvation and improved response time via a time quantum, while it is less throughput-efficient than SJF/SRTF and based on arrival times.

Analyze non-preemptive priority-based scheduling where higher priority numbers gain time, selecting among arrived processes using arrival, burst times, and priority. Compute completion, turnaround, and waiting times via a Gantt chart.

Analyze preemptive priority scheduling and compare with non-preemptive priority scheduling using a Gantt chart. Track arrivals and highest-priority execution, noting when all processes have arrived and preemption mirrors non-preemption.

Compute completion times, turn around times, waiting times, and response times for a preemptive priority-based scheduling algorithm, highlighting cpu allocation from ram for P1 to P6.

Apply SRTF scheduling to processes with CPU and IO bursts, trace a detailed Gantt chart, and compute CPU efficiency as 14 out of 16 time units.

Apply preemptive priority-based scheduling to a set of processes with CPU and IO bursts, determine highest-priority arrivals, and construct a Gantt chart to analyze CPU idle time and efficiency.

Learn the highest response ratio next (HRRN) non-preemptive scheduling algorithm, and how the response ratio (waiting time plus burst time over burst time) guides throughput and reduces starvation.

Explore the highest response ratio next non-preemptive scheduling example, illustrated with a Gantt chart and calculations of waiting time, burst time, and response ratios.

Explore the process state diagram, detailing new, ready, running, and IO states, plus how scheduling and preemption drive transitions in a multiprogramming operating system.

Explore how the operating system moves processes between RAM and disk via swapping, creating suspend ready and suspend IO states, guided by long term, medium term, and short term schedulers.

Explore how the scheduler and dispatcher orchestrate cpu scheduling and context switching. Understand how register values are saved and restored when switching between processes.

Explore the basics of the binary number system, base 2, and how powers of two determine memory sizes, bit representations, and grouping 2^n numbers into two groups.

Explore the basics of computer memory, distinguishing registers, RAM, and hard disk, and learn how a word, instructions, and data are addressed and transferred from RAM to CPU registers.

Explore memory allocation concepts by distinguishing physical and logical address spaces, and compare contiguous versus non-contiguous allocation of process addresses in RAM.

Explore fixed partitioning, or static partitioning, where RAM is divided into fixed-size partitions; understand its one-process-per-partition rule, internal fragmentation, and limits on process size and multiprogramming.

Explore variable partitioning (dynamic partitioning) as a contiguous RAM allocation that avoids internal fragmentation. It introduces external fragmentation, while multiprogramming remains unlimited and limited only by RAM.

Analyze memory allocation algorithms for variable partitioning, including first-fit, next-fit, best-fit, and worst-fit, to manage holes in RAM using linked lists or bitmaps and optimize process accommodation.

Explore how first-fit can satisfy a sequence of block requests in a variable-partition RAM, while best-fit leads to external fragmentation and unsatisfied requests.

Explore next-fit, first-fit, and worst-fit memory allocation strategies; next-fit starts from the last allocated spot and can cause external fragmentation, while worst-fit uses the largest hole.

Compare first-fit, best-fit, next-fit, and worst-fit memory allocation strategies as they interact with holes, contiguous allocation, and the ordering of requests, highlighting external fragmentation.

Explore best-fit allocation in fixed-partition memory using four partitions of 4KB, 8KB, 20KB, and 2KB, tracing when process P7 completes at time 19.

Explore binary addressing with a city of four streets, showing how bits partition into street, house, and floor, and relate this to paging in a 16-byte, byte-addressable memory.

This lecture explains how to address a 4 gb byte-addressable ram divided into 64 fixed partitions, using a 32-bit address split into 6-bit partition and 26-bit intra-partition.

Explore memory management in operating systems, contrasting fixed and dynamic partitioning, internal and external fragmentation, and the shift to paging and segmentation for non-contiguous allocation.