Operating Systems
One Brain Wasn't Enough
How computing learned to think in parallel.
Operating SystemsMulticoreConcurrenceParallelismShared Resources
1. The Single-Core Assumption
Historically, a CPU was a singular brain. To run multiple programs at the same time, the operating system had to perform a delicate illusion of multitasking. It sliced CPU execution time into tiny fragments, switching rapidly between processes so that human eyes perceived simultaneous behavior.
Our Previous Assumption: The Single-Core Timeline
➔
Active CPU Core
P1 RUNNING
Executing...
For decades, the goal of systems engineering was to make this single brain run faster.
2. The Physical Ceiling
We scaled computing power by increasing the clock frequency (gigahertz) of single processors. But around the mid-2000s, this approach hit a physical ceiling:
* The Thermal Wall: Higher speeds generate exponentially more heat. A single silicon chip running at 10 GHz would consume as much energy and generate as much heat as a small cooking surface, melting its own silicon structure.
* The Voltage Boundary: We could no longer decrease transistor operating voltage without causing electric leakage (quantum tunneling) across microscopic gates.
To continue making computers faster, engineers could no longer make the single brain run quicker. Instead, they had to pack multiple distinct processor cores onto a single silicon chip.
3. Parallel Minds
The transition to multicore architectures changed the rules of software execution. In a multicore system, true physical parallelism replaces the time-shared illusion of multitasking.
Single Core
SEQUENTIAL TIME-SHARING
Core State
CORE 0: P1 [RUNNING]
Ready Queue
One active Process at a time. The operating system must perform context switches to rotate core execution.
Multi-Core
SIMULTANEOUS PROCESSING
Multiple Processes executing simultaneously. Parallel cores execute instruction streams independently.
4. The Shared Frontier
In a single-core environment, processes execute one by one, isolated by the operating system.
But in a multicore system where processes run side-by-side, we face a new engineering bottleneck: collaborative processing. Processes often need to work together on parts of the same application.
Imagine two parallel cores processing a single task: Core 0 computes a sensor state value, and Core 1 must read that state value to control an actuator.
The Collaborative Dilemma: Shared Resources
CORE 0 (P1)
Writes: X = 42
Because Core 0 and Core 1 execute independently, how can P2 safely read X only after P1 has finished writing it, without accessing corrupted or stale memory?
5. Reflection
We have broken the single-processor assumption. Processes now run side-by-side across parallel cores.
But this independence breeds a new coordination puzzle.
How do Processes running at the same time exchange information?
Current Exploration
One Brain Wasn't Enough
