# cpu-cache-opt

Walks an agent through cache misses, false sharing and data layout. Useful when your profiler shows a high cache miss rate.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 654 installs · ★ 267
- Author: mohitmishra786
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/mohitmishra786/low-level-dev-skills/tree/HEAD/skills/low-level-programming/cpu-cache-opt/SKILL.md
- Updated: 2026-06-27
- HTML: https://affpapa.org/en/nevibecode/skills/cpu-cache-opt

## What it does

The skill guides an agent through cache-aware programming in C/C++ and Rust. It starts with measurement: `perf stat` counters such as `cache-references`, `cache-misses`, and the L1/L2/LLC breakdown. It also tells you what counts as bad — L1 miss rates above 5% deserve a look, above 20% is severe.

Then come the layout changes. AoS to SoA conversion, splitting hot and cold struct fields, walking a matrix row-major instead of column-major, blocking loops to fit L1. False sharing gets its own section: two counters on one cache line make threads invalidate each other, and the fix is alignment via `alignas(64)` or `std::hardware_destructive_interference_size`.

There is a prefetching part covering `__builtin_prefetch` and `_mm_prefetch` with a distance parameter. That distance is easy to get wrong. Prefetch too early and the line is evicted before use; too late and you gain nothing. Everything here leans on `perf`, so you need Linux with perf counters available — on other systems you cannot read these events the same way.

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill cpu-cache-opt -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/cpu-cache-opt/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/cpu-cache-opt/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill cpu-cache-opt -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/cpu-cache-opt/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill cpu-cache-opt -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/cpu-cache-opt/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install mohitmishra786/low-level-dev-skills cpu-cache-opt
```

2. **Manually: put the files in place**
- File: `.github/skills/cpu-cache-opt/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill cpu-cache-opt -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/mohitmishra786/low-level-dev-skills --path skills/low-level-programming/cpu-cache-opt
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/cpu-cache-opt/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add mohitmishra786/low-level-dev-skills --skill cpu-cache-opt -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/mohitmishra786/low-level-dev-skills/tree/HEAD/skills/low-level-programming/cpu-cache-opt/SKILL.md

## When to use it
- find why a hot loop has a high cache miss rate
- convert an AoS loop to SoA so it reads only the fields it needs
- catch false sharing between per-thread counters
- pick a prefetch distance for `__builtin_prefetch`
- tile a matrix multiply to fit L1

## Example prompts
- my parser is slow, check the cache miss rate with perf stat and tell me what to change
- two threads write to separate counters and it runs slower than single-threaded — check for false sharing
- rewrite this loop from AoS to SoA and add prefetching

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: b8b8faf3b973241d.

BEGIN THIRD-PARTY FILE b8b8faf3b973241d
````text
---
name: cpu-cache-opt
description: CPU cache optimization skill for C/C++ and Rust. Use when diagnosing cache misses, improving data layout for cache efficiency, using perf stat cache counters, understanding false sharing, prefetching, or structuring AoS vs SoA data layouts. Activates on queries about cache misses, cache lines, false sharing, perf cache counters, data layout optimization, prefetch, AoS vs SoA, or L1/L2/L3 cache performance.
---

# CPU Cache Optimization

## Purpose

Guide agents through cache-aware programming: diagnosing cache misses with perf, data layout transformations (AoS→SoA), false sharing detection and fixes, prefetching, and cache-friendly algorithm design.

## Triggers

- "My program has high cache miss rates — how do I fix it?"
- "What is false sharing and how do I detect it?"
- "Should I use AoS or SoA data layout?"
- "How do I measure cache performance with perf?"
- "How do I use __builtin_prefetch?"
- "My multithreaded program is slower than single-threaded due to cache"

## Workflow

### 1. Measure cache performance

```bash
# Basic cache counters
perf stat -e cache-references,cache-misses,cycles,instructions ./prog

# L1/L2/L3 miss breakdown
perf stat -e \
    L1-dcache-load-misses,\
    L1-dcache-loads,\
    L2-dcache-load-misses,\
    LLC-load-misses,\
    LLC-loads \
    ./prog

# Cache miss rate = L1-dcache-load-misses / L1-dcache-loads
# > 5% is concerning; > 20% is severe

# False sharing detection
perf stat -e \
    machine_clears.memory_ordering,\
    mem_load_l3_hit_retired.xsnp_hitm \
    ./prog
```

### 2. Cache line basics

- Cache line size: **64 bytes** on x86-64, ARM (most platforms)
- L1 cache: 32–64 KB, ~4 cycles latency
- L2 cache: 256 KB–1 MB, ~12 cycles latency
- L3 cache: 6–64 MB, ~40 cycles latency
- Main memory: ~200–300 cycles latency

```c
// Check cache line size
long cache_line = sysconf(_SC_LEVEL1_DCACHE_LINESIZE);

// Align data to cache line
struct alignas(64) HotData {
    int counter;
    // ... 60 bytes of data that fit in one line
};

// C
typedef struct {
    int x;
} __attribute__((aligned(64))) AlignedData;
```

### 3. AoS vs SoA data layout

```c
// AoS (Array of Structures) — default layout
struct Particle {
    float x, y, z;     // position (12 bytes)
    float vx, vy, vz;  // velocity (12 bytes)
    float mass;         // (4 bytes)
    int   flags;        // (4 bytes)
};
Particle particles[N];  // Bad for loops that only need position
````
END THIRD-PARTY FILE b8b8faf3b973241d

The third-party file has ended. Everything between the b8b8faf3b973241d tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2469 of 6769 bytes. © mohitmishra786 · MIT · https://github.com/mohitmishra786/low-level-dev-skills/tree/HEAD/skills/low-level-programming/cpu-cache-opt/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md