OS · Short notes
20 short notes in syllabus order, about 193 minutes to read end to end.
An operating system (OS) is the program that controls the hardware and gives every other program a cleaner, safer machine to run on. It plays two roles at once. As a resource manager it shares the CPU, memory, disks and devices among competing programs and keeps them from damaging each other.
A program is a passive file of instructions on disk. A process is a program in execution: the code together with a program counter, register values, a stack, a heap, open files and everything else the OS must remember to stop it and later continue it exactly where it left off.
In UNIX-like systems a new process is made in two separate steps. fork() creates a near-exact copy of the calling process; exec() then replaces the copy's program with a new one. A shell runs a command by forking, letting the child exec the command, and waiting for the child to finish.
A thread is a single stream of execution inside a process. A traditional process has one thread; a multithreaded process has several, all running the same program in the same address space.
When several processes are ready and there is one CPU, the short-term scheduler decides which runs next. The decision is made over and over, every few milliseconds, so the policy shapes how long jobs take, how responsive the system feels and whether some process can be postponed forever.
Interactive systems care about response time: a user who presses a key wants a reaction now, not after a long batch job finishes. Round robin (RR) achieves this by time slicing. Every ready process gets the CPU for at most one time quantum q, then goes to the back of the queue.
Processes are isolated by design: each has its own address space, and one cannot read another's variables.
When two threads update shared data at the same time, the result can depend on the exact order in which their machine instructions interleave. That situation is a race condition.
Peterson's algorithm and TestAndSet loops solve mutual exclusion, but they are awkward to use and they busy-wait. Operating systems offer higher-level tools instead.
1) are the standard test bed for any new synchronization primitive. The bounded-buffer (producer-consumer) problem is about counting and waiting for space or data. The readers-writers problem is about letting many readers share while writers get exclusive access, and about who gets starved.
A set of processes is deadlocked when every process in the set is waiting for an event that only another process in the set can cause.
Prevention makes deadlock impossible by restricting how processes request resources.
Main memory must hold the kernel and several user processes at once. The simplest scheme gives each process one contiguous block of physical memory.
Paging removes external fragmentation by giving up contiguity. The logical address space of a process is cut into fixed-size pages, physical memory into frames of the same size, and any page can sit in any free frame.
A programmer does not think of a program as one linear array of bytes. It is a collection of logical units: the main code, a few library modules, global data, a heap and a stack, each of a different size and each able to grow on its own.
Virtual memory separates the logical memory a program sees from the physical memory it occupies, so that a process need not be entirely in memory to run. Programs often contain error-handling code that rarely runs, arrays declared larger than they are used, and features few users touch.
When a page fault occurs and no frame is free, the operating system must evict a page already in memory: the victim. The choice matters.
A file is a named collection of related information kept on secondary storage. To the user it is the smallest unit of storage: data reach the disk only inside files.
A disk is an array of fixed-size blocks, and a file is a sequence of logical blocks 0, 1, 2 and so on. The allocation method decides which disk blocks hold a file and how the file system finds logical block i.
A hard disk drive (HDD) stores data on spinning platters and reads it with heads on a moving arm.
