Open-source project
xoreaxeaxeax/asm-hall-of-shame avatar
xoreaxeaxeax/asm-hall-of-shame

Assembly Hall of Shame: the champion is a 62 second instruction achieved by a mobile part on a consumer chipset

Racing to the bottom of CPU performance

995 stars19 forksCMIT

At a glance

What is it?
A leaderboard for the slowest single instruction in the x86 architecture, with a C file per entry and a make target that runs them all. The current champion times one FPU state restore at nearly two hundred billion cycles by starving the interconnect with a fleet of hammer cores, and the ranked board mixes two processors so the cycle order and the time order disagree.
Who is it for?
Read Assembly Hall of Shame if you want to understand how much of a modern processor is microcode and interconnect rather than logic, because that is what the board measures. Four things to know first.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 101 days ago.
What is it written in?
Mainly C, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • xoreaxeaxeax/asm-hall-of-shame995 ★ · +17
Star history
Repository2026-09-182026-11-15
xoreaxeaxeax/asm-hall-of-shame978995

17 Stars in the last 58 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The champion is a fleet, not an instruction

The current x86 champion times a single floating point state restore, loading 512 bytes of FPU and vector state from a memory-mapped region inside the PCIe fabric. On its own that would be slow but not extraordinary. The strategy section explains what else happens: a fleet of other cores pounds a different memory-mapped register with tight four-byte reads, saturating the root complex and the endpoint with non-posted traffic, so the timed load has to queue behind all of that.

asm
; CPU 0 — timed instruction
movl $0xfcc68830, %rsi
fxrstor64 %rsi

; CPUs 1..N — hammer loop against a different high-latency location
movl 0xfcc68858, %eax

The score is 198,002,498,236 cycles, or 62 seconds, on a mobile eight-core laptop part. The rules allow unlimited setup and count only one instruction, so this is legal by the board's own standard, and the three hammer directories in the repository are the same technique in three variants.

The rules forbid trapped instructions, and the TLB entry traps

Five rules govern the board. Setup may use whatever it needs but only one instruction is scored. Trapped, emulated and virtualised instructions may only have the trap timed, never the handler. Instructions must not be interruptible, which is what disqualifies the repeatable string and pause prefixes. Times are normalised to the processor's base clock. And every platform must be in its factory stock configuration with no hardware modification. The register-move entry sits directly against that third and fourth rule: writing the page table base is privileged, so from user space it raises a fault rather than doing the work the label implies. Its own strategy text says nothing for now, just check how long it takes to invalidate the translation cache. It is the most honest line in the leaderboard, and it is the entry that scores a trap.

The board ranks by cycles and prints a time, and the two disagree

Each entry reports a cycle score and a wall-clock figure, and the second is derived from the first using the base clock, so they are one measurement in two units. That matters at rank eighteen. The memory fence above it scores 326 cycles and 120 nanoseconds. The register move below it scores 352 cycles and 110 nanoseconds: more cycles, less time. The reason is visible in the contender lines. Everything from rank 27 down to rank 19 was measured on one Intel laptop processor, and ranks 18 and below were measured on a different AMD part on a different machine. So the ordering by cycles and the ordering by time invert exactly where the hardware changes, and the board presents both columns as if they were measured on one comparable system.

The lower board is a catalogue of microcode assists

Read the strategies from the bottom up and the theme is unmistakable. A no-op scores one cycle and opens the board. A longer multi-byte no-op scores twenty. A timestamp read is included purely to get bearings. Then the entries start constructing operands that force the processor to leave its fast path: a 128-bit dividend that pushes the integer divide quotient past the sign-extension ceiling, a display-pipe instruction at maximum nesting depth, a denormal loaded from memory, a dirty line flushed out of the last-level cache, a floating point sine with the special-value exponent, a fence behind sixteen non-temporal stores, a subnormal added to a subnormal, a locked read-modify-write aligned to straddle a cache line, a subnormal divisor, and a processor identification leaf chosen because a separate tool found it was the slowest one. Every technique is the same idea: make the operand illegal-looking enough to call the helper.

One C file per entry, and make run executes all of them

The repository is a directory of small independent programs, one directory per leaderboard row, each with its own makefile. The top-level makefile discovers them rather than listing them: it finds every C file in the tree, turns each into a binary path, excludes two directory prefixes, and then the run target iterates over the result and executes each binary expecting a cycle count on standard output. There is a specific error message for a binary that prints nothing, and it guesses the cause, asking whether a module is not loaded. So the run target's contract is that every discoverable C file is a benchmark. A helper file placed anywhere outside the two excluded prefixes would be executed as though it were an entry.

Some entries need a kernel module inserted as root

The makefile excludes files with a kernel module suffix from the binary list and then provides two targets that find those modules and load or unload every one of them, each with a sudo call. That is how an experiment gets to touch hardware it could not reach from user space, and it is why the error message above asks about a module. It is also the sharp edge of running the whole board at once: the target sweeps the tree and inserts whatever it finds, as root, before executing anything. The privileged experiments and the unprivileged ones are separated only by filename convention, so the safe way to try a single entry is the per-entry target, which builds one directory and runs one binary.

The champion sits outside the ranked board

The page has two separate structures. A champions section at the top presents the current record holder with its full strategy narrative, and a ranked leaderboard below it, numbered downward from 27 at the bottom, where the fastest entries sit. The champion is not one of the numbered rows, and the visible part of the board stops partway through, with rank 13 cut off mid-sentence. So the entry with a 62 second score and a written strategy is presented outside the list, and the top of the list is the part you cannot see. Two companion projects by the same author are referenced for context: one for the unaligned vector load in the honourable mentions, which is described as breaking the design of a system management mode, and one as the tool used to pick the slowest processor identification leaf.

Editorial conclusion

Read Assembly Hall of Shame if you want to understand how much of a modern processor is microcode and interconnect rather than logic, because that is what the board measures. Four things to know first. The current champion is not a single-instruction property of one core. It is one instruction on one core made slow by other cores on the same system generating enough memory traffic to occupy the fabric, so the result describes a system under self-inflicted contention as much as an instruction. The ranked board mixes an Intel part and an AMD part, and the two columns disagree on order where the processor changes, so treat the rank as a property of the pair. Several entries need a kernel module loaded as root, and the make target that runs everything executes every C file in the tree. And the top of the board is not in the ranked list at all; it sits in its own section, with the numbered board running the other way.

Frequently asked questions

What is the current Assembly Hall of Shame champion?

A floating point state restore instruction, scored at 198,002,498,236 cycles or 62 seconds on an AMD Ryzen 7 5800H, made slow by other cores saturating the memory fabric while the timed load is in flight.

What are the rules for an Assembly Hall of Shame entry?

Setup may use anything but only one instruction is scored, trapped or virtualised instructions may only have the trap timed, the instruction must not be interruptible, times are normalised to base clock, and the platform must be in its factory stock configuration with no hardware modification.

How are Assembly Hall of Shame entries built and run?

One C file per entry. The top-level makefile discovers every C file in the tree, builds each into a binary, and the run target executes each one expecting a cycle count, with per-entry targets available for a single experiment.

Why do some Assembly Hall of Shame scores need root?

The build system finds kernel module sources by filename convention and provides targets that insert and remove every module it finds using sudo, which is how certain experiments reach hardware user space cannot touch.

Which processors were used for the Assembly Hall of Shame leaderboard?

Most entries were measured on one Intel laptop processor, while the lower ranked entries including the register move were measured on an AMD part, which is why the cycle order and the time order disagree where the hardware changes.

Official sources

  1. Issues
  2. License: MIT
  3. README
  4. xoreaxeaxeax/asm-hall-of-shame on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/xoreaxeaxeax-asm-hall-of-shame.svg)](https://hysenlabs.com/projects/xoreaxeaxeax-asm-hall-of-shame)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/xoreaxeaxeax-asm-hall-of-shame.svg)](https://hysenlabs.com/projects/xoreaxeaxeax-asm-hall-of-shame)

Was this useful?