Skip to content
Tutorials Center
My learning

Topics

Lesson 5 of 67 ยท Big Picture

Issues in Computer Design

Understand the trade-offs every computer designer faces: performance, cost and yield, power, compatibility, reliability and security, with Python models of die cost and design choices.

Building a computer is not a search for the "best" design. It is a search for the best compromise. Making a CPU faster usually makes it hotter, bigger and more expensive. Keeping old programs running limits what you can change. Making it secure can cost speed. A designer works inside a set of competing constraints, and the architecture you see in a real machine is the result of those negotiations.

This lesson names the main issues and shows how each one pushes on the others. It sets the scene for the rest of the track, and it relies on the vocabulary from Measuring Performance and Components of a Computer.

The main design issues

flowchart TD
  D["Computer design"] --- P["Performance"]
  D --- C["Cost"]
  D --- W["Power and heat"]
  D --- K["Compatibility"]
  D --- R["Reliability"]
  D --- S["Security"]
  D --- I["Infrastructure and software"]

Each corner pulls against the others.

Performance

Users want programs to run faster. Performance is instructions per second, but also latency (how long one task takes) and throughput (how many tasks per hour). Designers raise it through a faster clock, more work per cycle (pipelining, superscalar execution, caches) or more cores. Each step has a cost. A deeper pipeline raises the clock but makes mispredicted branches more expensive. A bigger cache removes misses but is slower and occupies silicon. And performance is only as good as its slowest part: see Amdahl's law.

Cost

A chip is cut from a round wafer of silicon. The wafer has a fixed price, so the cost of one chip is the wafer price divided by the number of working chips. Two things matter: how many dies fit on a wafer (smaller dies, more dies) and the yield, the fraction without defects. Defects land at random, so big dies are hit more often. Doubling the area more than doubles the cost per good chip. This is why architects count every transistor.

Other costs are design time (a modern CPU takes years and hundreds of engineers), testing, packaging, and the software ecosystem around it.

Power and heat

Dynamic power is roughly C x V^2 x f (capacitance, voltage squared, frequency). Raising the frequency raises power, and higher frequency also needs higher voltage, so power grows much faster than speed. Since about 2005 chips have been limited by what they can cool, not by what they can build. That is why clock speeds stalled near 3-5 GHz and the industry turned to multiple cores, specialized accelerators and aggressive power gating. See Power, Energy and Thermal Limits.

Compatibility

Existing software is worth far more than any chip. An instruction-set architecture (ISA) is a promise: code written for it will keep running. x86 carries instructions from 1978 because breaking compatibility would break the world's software. Compatibility is the reason x86 decoders are complicated, why new ISAs fail unless they offer a clear benefit, and why emulation and binary translation exist. There are several levels: binary compatibility (the same machine code runs), source compatibility (recompile and it works) and API/ABI compatibility for libraries and operating systems.

Reliability and availability

Chips can fail from manufacturing faults, wear, heat, or soft errors (a cosmic ray flips a bit). Designers add parity and ECC memory, redundant hardware and checkpointing. Servers and spacecraft pay for this; phones mostly do not. The bigger the system, the more often something fails, so large data centres must be built to keep running with broken parts.

Security

Features that make hardware fast, such as speculative execution, caches and shared resources, leak information through timing. The Spectre and Meltdown vulnerabilities (2018) showed that a correct ISA can still have insecure microarchitecture. Modern designs add privilege levels, memory protection, memory encryption, secure boot and hardware isolation, and some mitigations cost performance.

Infrastructure and software

A processor needs compilers, an operating system, debuggers, drivers and libraries. A faster chip with no software is worthless; a modest chip with a great toolchain can win. The design of the ISA, ABI and memory model must be friendly to compiler writers.

Trade-offs in numbers

The next model shows how die size affects cost. It uses a simple defect model: the yield of a die of area A with defect density D is exp(-A x D) (a Poisson model).

Python Cost of a good die as the area grows

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Notice that 800 mm2 is 16 times the area of 50 mm2, but the cost per good die is much more than 16 times larger. This is why chips are often split into chiplets: several small dies on one package are cheaper than one giant die.

Choosing under constraints

Design choices rarely have a single score. A common approach is to define a figure of merit and check candidates against hard limits (maximum power, maximum cost). The model below picks the best option that satisfies the limits.

Python Picking a design under power and cost limits

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

The result changes with the market: the phone budget leaves room only for the small in-order core, while the laptop and desktop budgets both favour the many-core design, because it delivers the most performance inside the limits. The high-clock design loses everywhere: it has the worst performance per watt. Change the limits or the numbers and watch the winner change; real teams do the same exercise with far more data.

Check your understanding

Quick check ยท 5 questions

of 5 answered You scored / 5 ยท perfect!

  1. 1. Why does the cost per good chip rise faster than its area?

    Both the die count per wafer and the yield fall as area grows, so the cost per good die grows superlinearly.
  2. 2. Why did clock speeds stop climbing around 2005?

    Dynamic power rises with V^2 x f and higher frequencies need higher voltage, so chips hit a cooling limit and designers moved to multiple cores.
  3. 3. What is the main reason x86 keeps instructions from the 1970s?

    Binary compatibility protects the huge existing software base, so old instructions remain.
  4. 4. Which is an example of a performance feature that created security problems?

    Speculative execution leaves traces in caches that can be measured, which was exploited in Spectre-style attacks.
  5. 5. What does ECC memory address?

    Error-correcting codes let memory recover from single-bit (soft) errors.

Summary

  • Computer design is a set of trade-offs: performance, cost, power, compatibility, reliability, security and software infrastructure.
  • Cost per good chip grows faster than area because of fewer dies per wafer and lower yield; chiplets are one response.
  • Dynamic power grows roughly as C x V^2 x f, so clock speed hit a thermal wall and multi-core designs took over.
  • Compatibility protects existing software and shapes ISAs for decades.
  • Reliability features (parity, ECC, redundancy) and security features (privilege levels, isolation) cost hardware and sometimes speed.
  • The best design depends on the market: a phone, a laptop and a server pick different points among the same options.

Next: Number Systems and Conversions, where the next chapter starts with data representation.