Purposes of an Operating System (OS)

An operating system (OS) is the system software that sits between the hardware and the user/applications. Without it, every program would have to control the processor, memory and devices directly.

The OS has two big purposes that this topic focuses on:

1. Maximising the use of resources. Hardware (especially the CPU and memory) is expensive and limited, so the OS works to keep it busy and shared efficiently:

Resource	How the OS maximises its use
CPU	schedules processes (multi-tasking) so the processor isn't idle while one process waits for IO
Memory	manages RAM, and uses virtual memory so programs bigger than RAM can still run
Peripherals	shares devices fairly between processes and uses interrupts instead of wasteful polling

2. Hiding complexity. The user interface lets people and programs make simple requests ('save this file') while the OS deals with the messy hardware detail underneath (see §2).

The user interface is the part of the OS you see — usually a graphical user interface (GUI) with windows, icons and menus, or a command-line interface (CLI) where you type commands.

Its job is abstraction: it hides all the hardware detail the user would otherwise need to handle. A user opening a document never has to:

• work out which disk sectors the file occupies,
• know the memory addresses the file is loaded into,
• send instructions directly to the device drivers that control the disk or screen.

Instead the user makes a high-level request, and the OS translates it into the low-level operations the hardware actually needs:

User: "Open report.docx"
        │
        ▼
OS: find file on disk → load pages into RAM →
    pass data to the application → display via the screen driver

The same idea helps programmers: they call OS services (e.g. "read from file") rather than programming the hardware directly, so software is simpler to write and works across different hardware.

A process is a program that is being executed, along with the data and resources it needs (its register values, its position in the program, and so on). Multi-tasking is when the OS lets several processes appear to run at once on a single CPU, by rapidly switching the processor between them.

A single CPU can only execute one process at a time, so at any instant each process is in exactly one of three states:

• Running — currently being executed by the CPU.
• Ready — able to run, just waiting for the CPU to become free (NOT waiting for any event).
• Blocked — cannot run because it is waiting for an event such as input/output to complete.

The OS moves processes between these states. The arrows below are the only valid transitions:

• Ready → Running: the scheduler dispatches the process (gives it the CPU).
• Running → Ready: the time slice ends (or a higher-priority process is chosen) — the process can still run, so it returns to ready.
• Running → Blocked: the process requests IO / waits for an event, so it gives up the CPU.
• Blocked → Ready: the awaited event completes, so the process can run again — but it must wait for the CPU.

Because there are many ready processes but only one CPU, the OS needs a scheduler to decide which process runs next and for how long. Good scheduling keeps the CPU busy, treats processes fairly, and keeps interactive programs responsive.

The four routines in the syllabus:

Routine	How it works	Key point
Round robin	each process gets a fixed time slice in turn; if not finished it goes to the back of the queue	fair; pre-emptive; good for time-sharing
First come first served (FCFS)	processes run in arrival order, each to completion	simple; non-pre-emptive; suffers the convoy effect
Shortest job first (SJF)	run the process with the shortest total CPU time next	best average waiting time; needs run-times known; can starve long jobs
Shortest remaining time (SRT)	always run the process with the least time left; a shorter new arrival can pre-empt the running one	pre-emptive version of SJF

Round robin example (time slice 2 ms), processes P1=5, P2=3, P3=1 ms: P3 finishes first (at 5 ms), then P2 (8 ms), then P1 (9 ms) — see the worked example.

Pre-emptive vs non-pre-emptive: a pre-emptive routine (round robin, SRT) can interrupt a running process to give the CPU to another; a non-pre-emptive routine (FCFS, basic SJF) lets a process keep the CPU until it finishes or blocks.

The kernel is the core of the OS — the part that does the most critical, low-level jobs, including handling interrupts, scheduling and memory management.

An interrupt is a signal to the processor that an event needs attention. Common sources:

• a timer interrupt (a process's time slice has ended),
• an IO-complete interrupt (a device has finished, e.g. data has arrived from disk),
• a hardware/software error, or a higher-priority request.

How the kernel handles an interrupt:

1. At the end of the current fetch-execute cycle, the CPU checks whether an interrupt is present.
2. If so, control passes to the kernel, which saves the state of the running process (its registers and program counter).
3. The kernel identifies the source and priority of the interrupt and runs the matching interrupt service routine (ISR).
4. Afterwards, the kernel decides which process to run next and either resumes the interrupted process (restoring its saved state) or dispatches a different one.

Link to low-level scheduling. Because key scheduling events arrive as interrupts (the timer ending a slice, IO completing to unblock a process), the kernel's interrupt handling is exactly when scheduling decisions are made. Handling the interrupt and choosing the next process is low-level scheduling.

Real programs can need more memory than the available RAM. Virtual memory solves this by using part of the backing store (disk) as an extension of RAM: only the parts of a program in active use stay in RAM; the rest live on disk and are brought in when needed.

There are two ways to divide memory:

Paging — programs and memory are split into fixed-size blocks called pages; RAM is split into equal page frames. A page table records which pages are currently in RAM and translates the program's logical (virtual) addresses to physical addresses.

Segmentation — a program is split into variable-size blocks called segments, where each segment is a logical division of the program (e.g. the code, a procedure, an array).

The key difference:

	Paging	Segmentation
Block size	fixed	variable
Based on	physical division	logical structure of the program
Fragmentation	possible internal (last page part-empty)	possible external (uneven gaps)

Replacing pages. When RAM is full and a new page is needed, the OS must swap out an existing page to make room. A page-replacement policy chooses which one — for example least recently used (LRU) (replace the page not used for the longest time) or first-in-first-out.

Page fault: when the CPU needs a page that is not in RAM, a page fault occurs and the OS loads it from disk (swapping another page out if necessary).

Disk thrashing is what happens when paging becomes excessive.

The cause: too many processes are running for the amount of RAM available, so the set of pages in active use does not all fit in RAM. Then:

1. Page faults become very frequent because needed pages keep being absent from RAM.
2. Each fault forces a swap out and a swap in.
3. A page that was just swapped out is often needed again immediately, so it has to be swapped straight back.

The result is a vicious cycle in which the OS spends more time moving pages between RAM and the (slow) disk than actually executing instructions. That is the definition of disk thrashing.

Symptoms: the computer becomes extremely slow, the disk is constantly active, yet CPU usage looks low — because the processor is mostly idle, waiting for pages to be swapped in.

How to relieve it: reduce the number of running processes, or add more RAM, so the actively-used pages fit in memory and page faults drop back to a normal level.