Characteristics of Multiprocessors

Computer Organization & Embedded System — Input-Output Organization and Multiprocessor, NEC licence examination syllabus (Nepal Engineering Council).

Characteristics of Multiprocessors: many CPUs, one system

More cores means more decisions about how they share memory.

The phone/laptop you're reading this on almost certainly has 4-8 CPU cores inside — and every one of those cores had to be designed around the two questions below.

🔗 Tightly-coupled vs Loosely-coupled

Tightly-coupledShare a common main memory, communicating through it. Fast, but memory-access conflicts must be managed.

Loosely-coupledHave their own local memory and communicate via message passing (e.g. over a network). Scales further, but communication is slower.

⏳ UMA vs NUMA

UMAUniform Memory Access — every processor takes the same time to access any part of shared memory.

NUMANon-Uniform Memory Access — processors access their "nearby" memory faster than "far" memory. Common in large multicore/multi-socket systems.

💡 Short-answer trap: UMA vs NUMA is about memory ACCESS TIME uniformity, not about whether memory is shared at all — both can have shared memory.

The problem shared memory creates

Tightly-coupled processors share main memory — but each has its own cache, and that is where the difficulty starts.

Core 1 reads x (= 5) → its cache now holds x = 5 Core 2 reads x (= 5) → its cache also holds x = 5 Core 1 writes x = 6 → its cache holds 6 Core 2 now reads x → gets 5 from its own cache Two cores, same variable, different answers.

This is the cache coherence problem, and it is what makes shared memory hard. The hardware must ensure that a write by one core becomes visible to the others — most commonly by snooping, where each cache watches the shared bus and invalidates its copy of any address another core writes to.

💡 Coherence is also why adding cores has diminishing returns beyond the obvious. Every core added means more snoop traffic and more contention for the shared bus, so the interconnect becomes the bottleneck — which is the argument for the more elaborate interconnection structures covered later in this section.

What more cores cannot fix

Doubling the cores does not halve the runtime, and the limit is severe. Amdahl's law (developed fully in ACtE0802) says the speedup is bounded by the fraction of the program that is not parallelisable.

If 90% of a program can be parallelised: 2 cores 1.82x 8 cores 4.71x 1000 cores 9.91x ───────────────────── ceiling 10.0x — no number of cores exceeds this Even at 99% parallel, the ceiling is 100x.

The serial 10% never gets faster however many cores exist, so it comes to dominate the total. This is why the practical question is never "how many cores" but "how much of this work is genuinely parallel" — and why a problem with a large serial fraction gains almost nothing from a multiprocessor.

Which coupling to choose

⚖️ Shared memory against message passing

Tightly-coupledCommunication is a memory write — fast and easy to program. Limited in scale, because the shared bus and coherence traffic saturate. This is a multi-core CPU.

Loosely-coupledCommunication is an explicit message — slower and harder to program, with no shared state to keep coherent. Scales to thousands of nodes. This is a cluster or supercomputer.

💡 The trade-off is convenience against scale. Shared memory is easier because any core can simply read a variable; message passing scales because there is nothing to keep coherent. Every large system is loosely coupled at the top level and tightly coupled within each node — the two are combined rather than chosen between.

Syllabus points

Tightly- vs loosely-coupled
Shared (UMA) vs distributed (NUMA) memory

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.