Что такое кэш третьего уровня?

L3 Cache (Кэш третьего уровня)

L3 Cache (Last Level Cache, LLC) — это самый большой и медленный уровень кэша процессора, расположенный между главной памятью (RAM) и более быстрыми кэшами L1/L2. В системах с несколькими ядрами L3 кэш часто общий для всех ядер, обеспечивая согласованность данных между ними.

Иерархия памяти процессора

┌─────────────────────────┐
│   CPU Registers (0.5ns) │  64-256 байт, очень быстро
└────────┬────────────────┘
         ↓
┌─────────────────────────┐
│   L1 Cache (3-4ns)      │  32-64 KB (на ядро), быстро
├─────────────────────────┤
│   L2 Cache (10-20ns)    │  256 KB - 1 MB (на ядро)
├─────────────────────────┤
│  L3 Cache (40-75ns)     │  8-32 MB (общий для всех ядер)
└────────┬────────────────┘
         ↓
┌─────────────────────────┐
│   Main Memory (100-300ns)│ 8-256 GB RAM
└─────────────────────────┘

Характеристики L3 Cache

Как работает L3 Cache

CPU ядро 1        CPU ядро 2        CPU ядро 3
  L1              L1              L1
  L2              L2              L2
    ↓               ↓               ↓
    └───────────────┼───────────────┘
                    ↓
            ┌──────────────┐
            │   L3 Cache   │  Общий кэш
            └──────────────┘
                    ↓
            Main Memory (RAM)

Когда одно ядро обращается к данным:

1. L1 miss → ищет в L2
2. L2 miss → ищет в L3
3. L3 miss → ищет в RAM

Влияние на Java приложения

Хотя Java разработчик работает на более высоком уровне абстракции, понимание L3 кэша помогает оптимизировать производительность.

1. Cache Locality

// ❌ Плохо: Cache Misses
public class BadCacheLocality {
    static class Node {
        Node next;
        long data;
    }
    
    public void process(Node head) {
        Node current = head;
        while (current != null) {
            // Каждый current.next — новая область памяти (L3 miss)
            System.out.println(current.data);
            current = current.next;  // Скачок в памяти
        }
    }
}

// ✅ Хорошо: Spatial Locality
public class GoodCacheLocality {
    public void process(long[] data) {
        for (int i = 0; i < data.length; i++) {
            // Последовательный доступ к памяти (L3 hit)
            System.out.println(data[i]);
        }
    }
}

2. False Sharing (Ложное совместное использование)

Когда несколько потоков на разных ядрах обновляют данные в одной L3 cache line (обычно 64 байта), это вызывает invalidation и переперезапись.

public class FalseSharing {
    // ❌ Плохо: x и y в одной cache line
    static class BadCounter {
        long x;
        long y;
    }
    
    // ✅ Хорошо: разные cache lines
    static class GoodCounter {
        long x;
        long padding1, padding2, padding3, padding4, padding5, padding6, padding7;
        long y;
    }
    
    // Ещё лучше: через @jdk.internal.vm.annotation.Contended (JDK 8+)
    @sun.misc.Contended
    static class BestCounter {
        long x;
        @sun.misc.Contended
        long y;
    }
}

Пример проблемы:

public class FalseSharingDemo {
    static class Counter {
        long count;
    }
    
    public static void main(String[] args) throws InterruptedException {
        Counter[] counters = new Counter[4];
        for (int i = 0; i < 4; i++) {
            counters[i] = new Counter();
        }
        
        // 4 потока на 4 ядрах, каждый увеличивает свой счётчик
        long start = System.nanoTime();
        
        Thread[] threads = new Thread[4];
        for (int i = 0; i < 4; i++) {
            final int index = i;
            threads[i] = new Thread(() -> {
                for (int j = 0; j < 100_000_000; j++) {
                    counters[index].count++;
                }
            });
            threads[i].start();
        }
        
        for (Thread t : threads) {
            t.join();
        }
        
        long elapsed = System.nanoTime() - start;
        System.out.println("Time: " + (elapsed / 1_000_000) + " ms");
    }
}

// Вывод:
// Без padding (false sharing): ~3000ms
// С padding (true sharing): ~800ms

3. Working Set Size

Если рабочий набор данных больше L3 кэша, происходит много miss-ей.

// ❌ Плохо: Working Set > L3 Cache (32MB)
public void processLargeArray() {
    int[] data = new int[10_000_000];  // 40 MB > L3
    
    // Много L3 misses
    for (int i = 0; i < data.length; i++) {
        data[i] = data[i] * 2;
    }
}

// ✅ Хорошо: Блочная обработка
public void processLargeArrayInBlocks() {
    int[] data = new int[10_000_000];
    int blockSize = 1_000_000;  // 4 MB < L3
    
    for (int block = 0; block < data.length; block += blockSize) {
        int end = Math.min(block + blockSize, data.length);
        for (int i = block; i < end; i++) {
            data[i] = data[i] * 2;
        }
    }
}

Инструменты для анализа L3 Cache

1. Linux perf

# Собрать статистику L3 cache
perf stat -e LLC-loads,LLC-load-misses,LLC-stores java MyApplication

# Результат:
# LLC-loads           123,456,789
# LLC-load-misses      23,456,789  (18.9% miss rate)
# LLC-stores          34,567,890

2. JMH Benchmark

import org.openjdk.jmh.annotations.*;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
public class CacheBenchmark {
    int[] data;
    
    @Setup
    public void setup() {
        data = new int[10_000_000];
    }
    
    @Benchmark
    public long sequentialAccess() {
        long sum = 0;
        for (int i = 0; i < data.length; i++) {
            sum += data[i];
        }
        return sum;
    }
    
    @Benchmark
    public long randomAccess() {
        long sum = 0;
        for (int i = 0; i < data.length; i++) {
            // Скачут по памяти
            sum += data[(i * 13) % data.length];
        }
        return sum;
    }
}

Результаты:

sequentialAccess:  ~10,000,000 ops/sec
randomAccess:      ~1,000,000 ops/sec  (10x медленнее!)

Практические рекомендации

1. Используй массивы вместо LinkedList для последовательного доступа
2. Избегай false sharing при работе с многопоточностью
3. Рассчитывай рабочий набор — стремись поместить в L3
4. Используй blocking для больших данных
5. Профилируй реальное поведение кэша

// ✅ Рекомендуемый подход
public class OptimizedProcessing {
    // Массив: хорошая локальность
    private int[] buffer;
    
    // Размер, помещающийся в L3 (например, 4MB)
    private static final int CHUNK_SIZE = 1_000_000;
    
    public void process(int[] data) {
        for (int offset = 0; offset < data.length; offset += CHUNK_SIZE) {
            int end = Math.min(offset + CHUNK_SIZE, data.length);
            processChunk(data, offset, end);
        }
    }
    
    private void processChunk(int[] data, int start, int end) {
        // Обработка в пределах L3
        for (int i = start; i < end; i++) {
            buffer[i - start] = transform(data[i]);
        }
    }
    
    private int transform(int value) {
        return value * 2 + 1;
    }
}

Заключение

L3 Cache — это критичный уровень памяти, влияющий на производительность Java приложений. Хотя явная работа с кэшем невозможна, понимание его характеристик помогает:

• Выбирать правильные структуры данных
• Избегать false sharing в многопоточном коде
• Оптимизировать обработку больших объёмов данных
• Профилировать и устранять узкие места производительности