---
title: "Many Cores and the Limit on Speedup"
description: "When one core stops getting faster, machines add cores, and the gain then depends on how much of the work can actually run at the same time. The serial fraction sets a ceiling that no number of cores "
canonical: https://lightmysky.com/learn/computing/many-cores-and-the-limit-on-speedup-mt_dy3-K9dV19
source: https://lightmysky.com/learn/computing/many-cores-and-the-limit-on-speedup-mt_dy3-K9dV19.md
retrieved: 2026-09-12
---

> **Agent view.** This is the Markdown twin of the page, for tools and assistants.
> When to use this site, and the call that answers each job: https://lightmysky.com/agent-instructions.md
> API description (OpenAPI 3.1): https://lightmysky.com/openapi.json · Authentication: https://lightmysky.com/auth.md
> Pricing: https://lightmysky.com/pricing.md · Catalog: https://lightmysky.com/llms.txt · Full catalog: https://lightmysky.com/llms-full.txt
> Every machine-readable file on this domain: https://lightmysky.com/.well-known/ai-catalog.json
> Ask for Markdown with `Accept: text/markdown`, a `.md` address, or `?mode=agent`.

# Many Cores and the Limit on Speedup

When one core stops getting faster, machines add cores, and the gain then depends on how much of the work can actually run at the same time. The serial fraction sets a ceiling that no number of cores can lift.

Subject: Computing · Area: Computer Systems · Ages 19 to 20
Page: https://lightmysky.com/learn/computing/many-cores-and-the-limit-on-speedup-mt_dy3-K9dV19

## Ready when they can

- Compute the best possible speedup for a program that is one tenth serial
- Distinguish work that splits across cores from work that splits across data lanes
- Explain why adding cores can make a program slower

## Lesson: Why ten cores cannot always mean ten times

Pipelining overlapped steps inside one core, but one core still stops getting faster, so machines add cores. But the part that must run in order caps the gain. With a tenth of the work serial, even endless cores top out at ten times: one divided by one tenth.

**Example.** Take that tenth-serial program on nine cores. The serial tenth stays, and the rest splits nine ways: one tenth plus nine tenths over nine, which is two tenths. One divided by two tenths is five, so nine cores buy five times, not nine.

Cores and lanes are different tools. Cores split separate tasks that run on their own. Data lanes march many numbers through one step together. Code that splits across cores may still stall inside one lane.

More cores can even slow a program. Splitting, syncing, and sharing caches cost steps, and fights over one lock can dwarf the parallel gain. Measure before you buy.

**Recap.** The serial tenth caps you at ten times, lanes differ from cores, and overhead can bite.

## Practice

8 questions on this page, each with its working shown.

## Needs first

- [Pipelining and the Cost of a Hazard](https://lightmysky.com/learn/computing/pipelining-and-the-cost-of-a-hazard-mt_GI_fPY9d6s)

## Opens up

- [What an Operating System Is: Privilege and System Calls](https://lightmysky.com/learn/computing/what-an-operating-system-is-privilege-and-system-calls-mt_0kMavEKxpX)
- [Deep Learning: Convolution, Sequence and Scale](https://lightmysky.com/learn/computing/deep-learning-convolution-sequence-and-scale-mt_karzGN5JnI)