The counting house beside the customs shed had a rule that outsiders always found strange.

The real books lived in an iron cabinet in the back room. The cabinet belonged to the master, and no one was allowed to write on anything while it sat there. To record a figure, you sent Xiaoman, the runner, into the back room to fetch the sheet — the whole sheet, carried out and carried back whole. Never torn, never a line copied out on its own. You only wanted to change one number? You still moved the entire sheet.

Two desks in the front room. Li on the east side kept the salt accounts. Sang on the west side kept the rope accounts. In all their years neither had ever added up a single figure belonging to the other.

And one more rule, the important one: several copies of the same sheet could lie open on several desks at once — as long as nobody picked up a pen. The moment someone wanted to write, Xiaoman rang his little bell and went round collecting every other copy of that sheet and tearing it up. From then on, that sheet existed only in the writer’s hands. When the writing was done the sheet went back to the cabinet, and anyone else who wanted it had to send for it again.

That summer the counting house slowed to a crawl.

The master assumed someone was idling. He stood in the doorway and watched, and what he saw was two people who never sat still — except that most of their motion was waiting. Li would set down a figure, and before his pen was fully at rest the bell rang; the sheet Sang had just smoothed flat was pulled off his desk, and he had to stop and wait while Xiaoman ran to the back room and fetched it again. It came back. Sang wrote one number. The bell rang again, and this time it was Li’s copy that went. The two of them were like men on opposite sides of a wall, each pulling the roof off the other’s house. By closing, neither had filled half a page.

The master asked them each in turn: have you been touching his accounts? Both said no. Both were telling the truth.

Then he laid out two days of fetch records and counted. Xiaoman had made over a thousand trips in those two days, and more than eight hundred of them had been for the same sheet — number seven.

Sheet seven carried salt on its top four lines and rope on its bottom four. An ink rule ran between them, perfectly clear, never once crossed.

But the cabinet did not recognize that ink rule. The cabinet only recognized sheets. And so did the bell.

Having seen it, the master did two things. The first was crude and worked: he moved the four rope lines onto a fresh sheet and left the bottom half of sheet seven blank forever. The clerks winced at the waste of paper. Paper, said the master, is cheaper than legs. The second was easier still: he put a small slate on each desk. All day the odd figures went onto your own slate, disturbing nobody; at closing, each clerk sent for his sheet once, wrote the day’s total in a single stroke, and sent it back.

That month’s books were, as always, correct to the last figure. They had never been anything else. It was only that Xiaoman now ran seven hundred fewer errands a day.

— By now you have probably recognized it: sheet seven is a cache line, Xiaoman’s bell is invalidation in a cache coherence protocol, and what Li and Sang ran into is false sharing.

What it is

The smallest unit of data moved between CPU and memory is not a byte and not a variable — it is a cache line, typically 64 bytes on mainstream x86_64 and aarch64. Each core has its own L1 cache. A given cache line may be held simultaneously by many cores for reading, but any core that wants to write it must first acquire exclusive ownership (Exclusive / Modified in the MESI protocol) and invalidate every other copy.

False sharing is what happens when two threads read and write completely unrelated variables that happen to land on the same cache line. The hardware’s granularity is the line, not the variable, so every write knocks out the other side’s copy and the two cores bounce ownership of one line back and forth across the interconnect — cache line ping-pong.

Why it matters

• It produces no wrong answers, only lost throughput. The logic is right, the tests pass, it is simply slow — and it gets slower on machines with more cores, so it masquerades as “our threading just doesn’t scale”.
• Classic sites: a counters[thread_id] array, two hot fields sitting adjacent in a struct where one is read-mostly and one is write-heavy, per-thread statistics sharded but not aligned, a lock packed next to the data it protects.
• Diagnosis: on Linux, perf c2c record / perf c2c report points straight at HITM events (a line hit in modified state in another core’s cache). Also suspect it when L1d hit rates look fine but IPC is inexplicably low.
• Common fixes: align and pad hot fields to a cache line (alignas(64) in C, a _ [64]byte filler in Go, @Contended in Java); accumulate into per-CPU or thread-local counters and merge once at the end; reorder struct fields so read-mostly and write-heavy data live on separate lines.
• The counterweight: padding trades memory for bandwidth. Do not sprinkle it over every struct. Measure first, then pad.

Metaphor mapping

• The books in the iron cabinet → main memory
• The copy on each clerk’s desk → each core’s private L1 cache
• Fetched whole, returned whole → the cache line is the minimum transfer unit between cache and memory (usually 64 bytes)
• Sheet number seven → a single cache line
• Salt on the top lines, rope on the bottom → two unrelated variables that happen to share one cache line
• Many copies allowed while nobody writes → the Shared state in MESI; concurrent read-only access across cores
• Ringing the bell to collect every other copy before writing → a write must acquire exclusivity and invalidate all other copies
• Each ring forcing the other to stop and re-fetch → stalls and line refills caused by invalidation
• Neither filling half a page all day → throughput collapse from cache line ping-pong
• The ink rule down the middle of the sheet → the logical boundary between variables, which the hardware does not honor
• Books correct but slow → false sharing costs performance, never correctness
• Xiaoman’s fetch records → cache coherence profiling, e.g. perf c2c
• Rope moved to a fresh sheet, half a sheet left blank → cache line alignment plus padding
• The slates on the desks, totalled once at closing → per-CPU / thread-local accumulation, merged at the end