Что такое уровни кэширования в компьютерной архитектуре?

А, слушай, смотри, вот эта вся хуйня с кэшами — это вообще, блядь, основа основ, если ты хочешь, чтобы твоя программа не ползала как черепаха в сиропе. Представь себе, процессор — это ярый мужик, который хочет всё и сразу, а оперативка — это такая неторопливая тётя в библиотеке, которая ищет книжку по каталогу. Чтобы он не орал "ДАЙ ЖЕ НАХУЙ!", между ними вот эти вот уровни — L1, L2, L3.

Это как, блядь, карманы у тебя. L1 — это мелкие купюры прямо в переднем кармане джинс, схватил и отдал. L2 — это уже бумажник, надо открыть. L3 — это уже, сука, барсетка на поясе, под курткой. А оперативка — это уже банкомат, до которого ещё добежать надо. Задержки, ёпта, растут, как на дрожжах.

И вся соль в том, чтобы процессор как можно реже лез в эту самую барсетку и, уж тем более, не бегал к банкомату. Для этого есть два священных принципа, блядь.

Первый — временная локальность. Если ты один раз спросил у тёти в библиотеке "Где книга про анатомию бобра?", и она тебе сказала — ты запомни это нахуй! Скорее всего, через минуту ты опять её спросишь, потому что забыл, на какой странице про семенники. Бери книгу и клади рядом, не отходи.

Второй — пространственная локальность. Если ты взял книгу "Анатомия бобра, том 1", то, блядь, будь добр, сразу возьми рядом лежащий "том 2: Репродуктивная система". Они же рядом на полке стоят! Не заставляй тётю бегать по всему залу.

Вот смотри, как это в коде выглядит, а то ты, пизда бородавчатая, можешь не понять:

// ПЛОХО, НЕ ДЕЛАЙ ТАК! Это как заказывать пиццу, а курьера посылать за одной пельменей в разные районы.
int sum = 0;
for (int i = 0; i < N; i++) {
    sum += array[randomIndex[i]]; // Каждый раз прыжок в неизвестность. Кэш плачет, процессор матерится.
}

// ХОРОШО, ДЕЛАЙ ТАК! Это как сожрать всю пиццу последовательно, кусок за куском.
int sum = 0;
for (int i = 0; i < array.length; i++) {
    sum += array[i]; // Идём по порядку, как по полочке. Кэш счастлив, всё предзагружено.
}

Чувствуешь разницу, блядь? В первом случае у тебя cache miss на каждом шагу, процессор сидит и бьёт головой об стол. Во втором — cache hit, поток данных как по маслу.

А теперь, ёпта, высший пилотаж для тех, кто не хочет, чтобы его софт сосал лапу.

Выравнивание данных. Ты не можешь таскать книги по одной, если у тебя рюкзак на 10 книг. Бери пачками! Структуры данных выравнивай, желательно под размер cache line (обычно 64 байта). Чтобы одним заходом в память загрузить всё, что нужно.

Предвыборка (prefetching). Это как позвонить в пиццерию заранее, пока едешь домой. Умный процессор, видя, что ты последовательно читаешь массив, уже начинает подгружать в кэш следующие куски данных, пока ты жуёшь текущий.

Избегание false sharing. Вот это, блядь, золото! Представь, у тебя два ядра процессора. У каждого свой L1 кэш. Но данные в памяти лежат блоками (те самые cache line, 64 байта). Если ядро А постоянно меняет одну переменную в этом блоке, а ядро Б — другую, но они в одном блоке... Начинается ад. Кэши ядер начинают синхронизировать эту гребаную cache line между собой на каждом чихе, хотя им, по сути, нужны разные переменные. Производительность летит в пизду. Решение? Паддинг, выравнивание, чтобы горячие данные каждого потока попадали в РАЗНЫЕ cache line. В Java для этого есть, например, @Contended (только с флагом JVM -XX:-RestrictContended).

Ну и, блять, не забывай, что в мире Java кэши — это ещё и про JVM. Пул строк, метаданные классов — это всё своя иерархия, своя кухня. А ещё есть кэши приложения (типа Caffeine — овердохуища быстрый) и кэши баз данных. Но это уже, как говорится, совсем другая история, про которую можно говорить до утра, но у меня терпения ноль ебать.

Короче, суть в чём: дружи с кэшем, и он отблагодарит тебя скоростью. Воевать с ним — самоубийство. Всё.