на что влияет кэш память процессора
Кэш-память процессора
Кэш-память играет важную роль. Без нее от высокой тактовой частоты процессора не было бы никакого проку. Кэш позволяет использовать в компьютере любую, даже самую «медленную» оперативную память, без ощутимого ущерба для его производительности.
О том, что такое кэш-память процессора, как она работает и какое влияние оказывает на быстродействие компьютера, читатель узнает из этой статьи.
Содержание статьи
Что такое кэш-память процессора
Решая любую задачу, процессор компьютера получает из оперативной памяти необходимые блоки информации. Обработав их, он записывает в память результаты вычислений и получает для обработки следующие блоки. Это продолжается, пока задача не будет выполнена.
Все упомянутые операции производятся на очень высокой скорости. Однако, даже самая быстрая оперативная память работает медленнее любого «неторопливого» процессора. Каждое считывание из нее информации и обратная ее запись отнимают много времени. В среднем, скорость работы оперативной памяти в 16 – 17 раз ниже скорости процессора.
Не смотря на такой дисбаланс, процессор не простаивает и не ожидает каждый раз, когда оперативная память «выдает» или «принимает» данные. Он почти всегда работает на максимальной скорости. И все благодаря наличию у него кэш-памяти.
Кэш-память процессора – это небольшая, но очень быстрая память. Она встроена в процессор и является своеобразным буфером, сглаживающим перебои в обмене данными с более медленной оперативной памятью. Кэш-память часто называют сверхоперативной памятью.
Кэш нужен не только для выравнивания дисбаланса скорости. Процессор обрабатывает данные более мелкими порциями, чем те, в которых они хранятся в оперативной памяти. Поэтому кэш-память играет еще и роль своеобразного места для «перепаковки» и временного хранения информации перед ее передачей процессору, а также возвращением результатов обработки в оперативную память.
Устройство кэш-памяти процессора
Контроллер кэш памяти
Контроллер кэш памяти – это устройство, управляющее содержанием кэша, получением необходимой информации из оперативной памяти, передачей ее процессору, а также возвращением в оперативную память результатов вычислений.
Когда ядро процессора обращается к контроллеру за какими-то данными, тот проверяет, есть ли эти данные в кэш-памяти. Если это так, ядру моментально отдается информация из кэша (происходит так называемое кэш-попадание).
В противном случае ядру приходится ожидать поступления данных из медленной оперативной памяти. Ситуация, когда в кэше не оказывается нужных данных, называется кэш-промахом.
Задача контроллера – сделать так, чтобы кэш-промахи происходили как можно реже, а в идеале – чтобы их не было вообще.
Размер кэша процессора по сравнению с размером оперативной памяти несоизмеримо мал. В нем может находиться лишь копия крошечной части данных, хранимых в оперативной памяти. Но, не смотря на это, контроллер допускает кэш-промахи не часто. Эффективность его работы определяется несколькими факторами:
• размером и структурой кэш-памяти (чем больше ресурсов имеет в своем распоряжении контроллер, тем ниже вероятность кэш-промаха);
• эффективностью алгоритмов, по которым контроллер определяет, какая именно информация понадобится процессору в следующий момент времени;
• сложностью и количеством задач, одновременно решаемых процессором. Чем сложнее задачи и чем их больше, тем чаще «ошибается» контроллер.
Кэш-память процессора
Однако, эта скорость зависит также от объема конкретной микросхемы. Чем значительней объем микросхемы, тем сложнее обеспечить высокую скорость ее работы.
Учитывая указанную особенность, кэш-память процессора изготовляют в виде нескольких небольших блоков, называемых уровнями. В большинстве процессоров используется трехуровневая система кэша:
Количество микросхем памяти L1 в процессоре, как правило, равно количеству его ядер. Каждое ядро имеет доступ только к своей микросхеме L1.
• Кэш-память второго уровня (L2) немного медленнее кэш-памяти L1, но и объем ее более существенный (несколько сотен килобайт). Служит она для временного хранения важной информации, вероятность запроса которой ниже, чем у информации, находящейся в L1.
• Кэш-память третьего уровня (L3) – еще более объемная, но и более медленная схема памяти. Тем не менее, она значительно быстрее оперативной памяти. Ее размер может достигать нескольких десятков мегабайт. В отличие от L1 и L2, она является общей для всех ядер процессора.
Уровень L3 служит для временного хранения важных данных с относительно низкой вероятностью запроса, а также для обеспечения взаимодействия ядер процессора между собой.
Встречаются также процессоры с двухуровневой кэш-памятью. В них L2 совмещает в себе функции L2 и L3.
Влияние кэш-памяти процессора на быстродействие компьютера
Указанные показатели касаются простых задач. С повышением нагрузки на процессор число кэш-промахов увеличивается.
Эффективность кэш-памяти процессора сводит к минимуму влияние скорости оперативной памяти на быстродействие компьютера. Например, компьютер одинаково хорошо будет работать с оперативной памятью 1066 МГц и 2400 МГц. При прочих равных условиях разница производительности в большинстве приложений не превысит 5%.
Пытаясь оценить эффективность кэш-памяти, пользователи чаще всего ищут ответы на следующие вопросы:
Какая структура кэш-памяти лучше: двух- или трехуровневая?
Трехуровневая кэш-память более эффективна.
Чтобы определить, как сильно L3 влияет на работу процессора, сайтом Tom’s Hardware был проведен эксперимент. Заключался он в замере производительности процессоров Athlon II X4 и Phenom II X4. Оба процессора оснащены одинаковыми ядрами. Первый отличается от второго лишь отсутствием кэш-памяти L3 и более низкой тактовой частотой.
Приведя частоты обеих процессоров к одинаковому показателю, было установлено, что наличие кэш-памяти L3 повышает производительность процессора Phenom на 5,8 %. Но это средний показатель. В одних приложениях он был почти равен нулю (офисные программы), в других – достигал 8% и даже больше (компьютерные 3D игры, архиваторы и др.).
Как влияет размер кэша на производительность процессора?
Оценивая размер кэш-памяти, нужно учитывать характеристики процессора и круг решаемых им задач.
Кэш-память двуядерного процессора редко превышает 3 MB. Тем более, если его тактовая частота ниже 3 Ггц. Производители прекрасно понимают, что дальнейшее увеличение размера кэша такого процессора не принесет прироста производительности, зато существенно повысит его стоимость.
Другое дело высокочастотные 4-, 6- или даже 8-миядерные процессоры. Некоторые из них (например, Intel Core i7) поддерживают технологию Hyper Threading, обеспечивающую одновременное выполнение каждым ядром двух задач. Естественно, что потенциал таких процессоров не может быть раскрыт с маленьким кэшем. Поэтому его увеличение до 15 или даже 20 MB вполне оправдано.
В процессорах Intel алгоритм наполнения кэш-памяти построен по так называемой инклюзивной схеме, когда содержимое кэшей верхнего уровня (L1, L2) полностью или частично дублируется в кэше нижнего уровня (L3). Это в определенной степени уменьшает полезный объем его пространства. С другой стороны, инклюзивная схема позитивно сказывается на взаимодействии ядер процессора между собой.
В целом же, эксперименты свидетельствуют, что в среднестатистическом «домашнем» процессоре влияние размера кэша на производительность находится в пределах 10 %, и его вполне можно компенсировать, например, высокой частотой.
Эффект от большого кэша наиболее ощутим при использовании архиваторов, в 3D играх, во время кодирования видео. В «не тяжелых» же приложениях разница стремится к нулю (офисные программы, интернет-серфинг, работа с фотографиями, прослушивание музыки и др.).
Многоядерные процессоры с большим кэшем необходимы на компьютерах, предназначенных для выполнения многопоточных приложений, одновременного решения нескольких сложных задач.
Особенно актуально это для серверов с высокой посещаемостью. В некоторых высоконагружаемых серверах и суперкомпьютерах предусмотрена даже установка кэш-памяти четвертого уровня (L4). Изготавливается она в виде отдельных микросхем, подключаемых к материнской плате.
Как узнать размер кэш-памяти процессора?
Существуют специальные программы, предоставляющие подробную информацию о процессоре компьютера, в том числе и о его кэш-памяти. Одной из них является программа CPU-Z.
Программа не требует установки. После ее запуска нужно перейти на вкладку «Caches» (см. изображение).
На примере видно, что проверяемый процессор оснащен трехуровневой кэш-памятью. Размер кэша L3 у него составляет 3 MB, L2 – 512 KB (256×2), L1 – 128 KB (32×2+32×2).
Можно ли как-то увеличить кэш-память процессора?
Как уже было сказано в одном из предыдущих пунктов, возможность увеличения кэш-памяти процессора предусмотрена в некоторых серверах и суперкомпьютерах, путем ее подключения к материнской плате.
В домашних же или офисных компьютерах такая возможность отсутствует. Кэш-память является внутренней неотъемлемой частью процессора, имеет очень маленькие физические размеры и не подлежит замене. А на обычных материнских платах нет разъемов для подключения дополнительной кэш-памяти.
Галерея эффектов кэшей процессоров
Почти все разработчики знают, что кэш процессора — это такая маленькая, но быстрая память, в которой хранятся данные из недавно посещённых областей памяти — определение краткое и довольно точное. Тем не менее, знание «скучных» подробностей относительно механизмов работы кэша необходимо для понимания факторов влияющих на производительность кода.
В этой статье мы рассмотрим ряд примеров иллюстрирующих различные особенности работы кэшей и их влияние на производительность. Примеры будут на C#, выбор языка и платформы не так сильно влияет на оценку производительности и конечные выводы. Естественно, в разумных пределах, если вы выберите язык, в котором чтение значения из массива равносильно обращению к хеш-таблице, никаких результатов пригодных к интерпретации вы не получите. Курсивом идут примечания переводчика.
Пример 1: доступ к памяти и производительность
Как вы думаете, насколько второй цикл быстрее первого?
int [] arr = new int [64 * 1024 * 1024];
// первый
for ( int i = 0; i // второй
for ( int i = 0; i
Первый цикл умножает все значения массива на 3, второй цикл только каждое шестнадцатое значение. Второй цикл совершает только 6% работы первого цикла, но на современных машинах оба цикла выполняются примерно за равное время: 80 мс и 78 мс соответственно (на моей машине).
Разгадка проста — доступ к памяти. Скорость работы этих циклов в первую очередь определяется скоростью работы подсистемы памяти, а не скоростью целочисленного умножения. Как мы увидим в следующем примере, количество обращений к оперативной памяти одинаково и в первом и во втором случае.
Пример 2: влияние строк кэша
Копнём глубже — попробуем другие значения шага, не только 1 и 16:
Вот время работы этого цикла для различных значений шага K:
Обратите внимание, при значениях шага от 1 до 16 время работы практически не изменяется. Но при значениях больше 16, время работы уменьшается примерно вдвое каждый раз когда мы увеличиваем шаг в два раза. Это не означает, что цикл каким-то магическим образом начинает работать быстрее, просто количество итераций при этом так же уменьшается. Ключевой момент — одинаковое время работы при значениях шага от 1 до 16.
Причина этого в том, что современные процессоры осуществляют доступ к памяти не побайтно, а небольшими блоками, которые называют строками кэша. Обычно размер строки составляет 64 байта. Когда вы читаете какое-либо значение из памяти, в кэш попадает как минимум одна строка кэша. Последующий доступ к какому-либо значению из этой строки происходит очень быстро.
Из-за того, что 16 значений типа int занимают 64 байта, циклы с шагами от 1 до 16 обращаются к одинаковому количеству строк кэша, точнее говоря, ко всем строкам кэша массива. При шаге 32, обращение происходит к каждой второй строке, при шаге 64, к каждой четвёртой.
Понимание этого очень важно для некоторых способов оптимизации. От места расположения данных в памяти зависит число обращений к ней. Например, из-за невыровненных данных может потребоваться два обращения к оперативной памяти, вместо одного. Как мы выяснили выше, скорость работы при этом будет в два раза ниже.
Пример 3: размеры кэшей первого и второго уровня (L1 и L2)
Современные процессоры, как правило, имеют два или три уровня кэшей, обычно их называют L1, L2 и L3. Для того, чтобы узнать размеры кэшей различных уровней, можно воспользоваться утилитой CoreInfo или функцией Windows API GetLogicalProcessorInfo. Оба способа так же предоставляют информацию о размере строки кэша для каждого уровня.
На моей машине CoreInfo сообщает о кэшах данных L1 объёмом по 32 Кбайт, кэшах инструкций L1 объёмом по 32 Кбайт и кэшах данных L2 объёмом по 4 Мбайт. Каждое ядро имеет свои персональные кэши L1, кэши L2 общие для каждой пары ядер:
Проверим эту информацию экспериментально. Для этого, пройдёмся по нашему массиву инкрементируя каждое 16-ое значение — простой способ изменить данные в каждой строке кэша. При достижении конца, возвращаемся к началу. Проверим различные размеры массива, мы должны увидеть падение производительности когда массив перестаёт помещаться в кэши разных уровней.
На моей машине заметны падения производительности после 32 Кбайт и 4 Мбайт — это и есть размеры кэшей L1 и L2.
Пример 4: параллелизм инструкций
Теперь давайте взглянем на кое-что другое. По вашему мнению, какой из этих двух циклов выполнится быстрее?
int steps = 256 * 1024 * 1024;
int [] a = new int [2];
// первый
for ( int i = 0; i // второй
for ( int i = 0; i
Оказывается, второй цикл выполняется почти в два раза быстрее, по крайней мере, на всех протестированных мной машинах. Почему? Потому, что команды внутри циклов имеют разные зависимости по данным. Команды первого имеют следующую цепочку зависимостей:
Во втором цикле зависимости такие:
Функциональные части современных процессоров способны выполнять определённое число некоторых операций одновременно, как правило, не очень большое число. Например, возможен параллельный доступ к данным из кэша L1 по двум адресам, так же возможно одновременное выполнение двух простых арифметических команд. В первом цикле процессор не может задействовать эти возможности, но может во втором.
Пример 5: ассоциативность кэша
К примеру, на моей машине кэш L2 размером в 4 Мбайт является 16-входовым частично-ассоциативным кэшем. Вся оперативная память разделена на множества строк по младшим битам их индексов, строки из каждого множества соревнуются за одну группу из 16 ячеек кэша L2.
Так как кэш L2 имеет 65 536 ячеек (4 * 2 20 / 64) и каждая группа состоит из 16 ячеек, всего мы имеем 4 096 групп. Таким образом, младшие 12 битов индекса строки определяют к какой группе относится эта строка (2 12 = 4 096). В результате, строки с адресами кратными 262 144 (4 096 * 64) разделяют одну и ту же группу из 16-ти ячеек и соревнуются за место в ней.
Чтобы эффекты ассоциативности проявили себя, нам необходимо постоянно обращаться к большому количеству строк из одной группы, например, используя следующий код:
public static long UpdateEveryKthByte( byte [] arr, int K)
<
const int rep = 1024 * 1024; // количество итераций
Stopwatch sw = Stopwatch.StartNew();
int p = 0;
for ( int i = 0; i if (p >= arr.Length) p = 0;
>
Метод инкрементирует каждый K-ый элемент массива. По достижении конца, начинаем заново. После довольно большого количества итераций (2 20 ), останавливаемся. Я сделал прогоны для различных размеров массива и значений шага K. Результаты (синий — большое время работы, белый — маленькое):
Синим областям соответствуют те случаи, когда при постоянном изменении данных кэш не в состоянии вместить все требуемые данные одновременно. Яркий синий цвет говорит о времени работы порядка 80 мс, почти белый — 10 мс.
Некоторые из плохих значений шага — степени двойки: 256 и 512. Для примера рассмотрим шаг 512 и массив в 8 Мбайт. При этом шаге, в массиве имеются 32 участка (8 * 2 20 / 262 144), которые ведут борьбу друг с другом за ячейки в 512-ти группах кэша (262 144 / 512). Участка 32, а ячеек в кэше под каждую группу только 16, поэтому места на всех не хватает.
Другие значения шага, не являющиеся степенями двойки, просто невезучие, что вызывает большое количество обращений к одинаковым группам кэша, а так же приводит к появлению вертикальных синих линий на рисунке. На этом месте любителям теории чисел предлагается задуматься.
Например, при размере массива в 16 Мбайт и шаге 128, мы обращаемся к каждому 128-му байту, таким образом, модифицируя каждую вторую строку кэша массива. Чтобы сохранить каждую вторую строку в кэше, необходим его объём в 8 Мбайт, но на моей машине есть только 4 Мбайт.
Даже если бы кэш был полностью ассоциативным, это не позволило бы сохранить в нём 8 Мбайт данных. Заметьте, что в уже рассмотренном примере с шагом 512 и размером массива 8 Мбайт, нам необходим только 1 Мбайт кэша, чтобы сохранить все нужные данные, но это невозможно сделать из-за недостаточной ассоциативности кэша.
Так как количество итераций равно в нашем тесте при любом значении шага, то более дешёвый шаг в результате даёт меньшее время работы.
Обнаруженные эффекты сохраняются и при больших значениях параметров:
Ассоциативность кэша — интересная штука, которая может проявить себя при определённых условиях. В отличие от остальных рассмотренных в этой статье проблем, она не является настолько серьёзной. Определённо, это не то, что требует постоянного внимания при написании программ.
Пример 6: ложное разделение кэша
На многоядерных машинах можно столкнуться с другой проблемой — согласование кэшей. Ядра процессора имеют частично или полностью раздельные кэши. На моей машине кэши L1 раздельны (как и обычно), так же имеются два кэша L2, общие для каждой пары ядер. Детали могут различаться, но в целом современные многоядерные процессоры имеют многоуровневые иерархические кэши. Причём самые быстрые, но и самые маленькие кэши, принадлежат индивидуальным ядрам.
Когда одно из ядер модифицирует значение в своём кэше, другие ядра больше не могут использовать старое значение. Значение в кэшах других ядер должно быть обновлено. Более того, должна быть обновлена полностью вся строка кэша, так как кэши оперируют данными на уровне строк.
Продемонстрируем эту проблему на следующем коде:
private static int [] s_counter = new int [1024];
private void UpdateCounter( int position)
<
for ( int j = 0; j
Если на своей четырёхядерной машине я вызову этот метод с параметрами 0, 1, 2, 3 одновременно из четырёх потоков, то время работы составит 4.3 секунды. Но если я вызову метод с параметрами 16, 32, 48, 64, то время работы составит только 0.28 секунды.
Почему? В первом случае, все четыре значения, обрабатываемые потоками в каждый момент времени, с большой вероятностью попадают в одну строку кэша. Каждый раз когда одно ядро увеличивает очередное значение, оно помечает ячейки кэша, содержащие это значение в других ядрах, как невалидные. После этой операции, все остальные ядра должны будут закэшировать строку заново. Это делает механизм кэширования неработоспособным, убивая производительность.
Пример 7: сложность железа
Даже теперь, когда принципы работы кэшей для вас не секрет, железо по-прежнему будет преподносить вам сюрпризы. Процессоры отличаются друг от друга методами оптимизации, эвристиками и прочими тонкостями реализации.
Кэш L1 некоторых процессоров может осуществлять параллельный доступ к двум ячейкам, если они относятся к разным группам, но если они относятся к одной, только последовательно. Насколько мне известно, некоторые даже могут осуществлять параллельный доступ к разным четвертинкам одной ячейки.
Процессоры могут удивить вас хитрыми оптимизациями. Например, код из предыдущего примера про ложное разделение кэша не работает на моём домашнем компьютере так, как задумывалось — в простейших случаях процессор может оптимизировать работу и уменьшить негативные эффекты. Если код немного модифицировать, всё встаёт на свои места.
Вот другой пример странных причуд железа:
private static int A, B, C, D, E, F, G;
private static void Weirdness()
<
for ( int i = 0; i
>
>
Если вместо подставить три разных варианта, можно получить следующие результаты:
Инкрементирование полей A, B, C, D занимает больше времени, чем инкрементирование полей A, C, E, G. Что ещё страннее, инкрементирование полей A и C занимает больше времени, чем полей A, C и E, G. Не знаю точно каковы причины этого, но возможно они связаны с банками памяти (да-да, с обычными трёхлитровыми сберегательными банками памяти, а не то, что вы подумали). Имеющих соображения на этот счёт, прошу высказываться в комментариях.
У меня на машине вышеописанного не наблюдается, тем не менее, иногда бывают аномально плохие результаты — скорее всего, планировщик задач вносит свои «коррективы».
Из этого примера можно вынести следующий урок: очень сложно полностью предсказать поведение железа. Да, можно предсказать многое, но необходимо постоянно подтверждать свои предсказания с помощью измерений и тестирования.
Заключение
Надеюсь, что всё рассмотренное помогло вам понять устройство кэшей процессоров. Теперь вы можете использовать полученные знания на практике для оптимизации своего кода.
Влияние кэша L3 на производительность процессоров Intel
Содержание
Содержание
Проверяем, какое влияние оказывает объём L3 Cache на производительность процессоров Intel Core 10 серии как в рабочих приложениях, так и в играх. Выясняем, почему нельзя использовать старшие процессоры для эмуляции младших моделей.
Что такое кэш процессора и зачем он нужен
Кэш процессора – это очень быстрая память. Он выполняет функцию буфера (временного хранения данных), из которого процессор очень быстро может получить необходимую для обработки информацию.
Современные процессоры, будь то Intel или AMD, в основном имеет 3 уровня кэша:
В многоядерных процессорах каждое ядро имеет выделенный кэш L1 и L2 Cache, а вот к L3 Cache чье влияние на производительность мы и будем сегодня изучать имеют доступ все ядра процессора.
Когда процессору необходимо получить данные, поиск он начинает с кэша первого уровня. Если нужной информации в нем нет, он повторяет поиск в кэше второго и третьего уровня что несколько увеличивает время на выполнение операции. Если поиск завершился неудачей процессору приходится обращаться к оперативной памяти что значительно увеличивает время выполнение операции.
Именно поэтому чем больше объём кэша, тем больше вероятность нахождения в нем нужных данных, а значит сократить задержек. Но и у большого кэша есть и свои минусы, о которых чуть позже.
Более подробно о работе кэша процессора и зачем он нужен можно ознакомиться в статье «Что такое кэш в процессоре и зачем он нужен»
В тестировании участвую 4 процессора Intel из 10 серии:
Чтобы измерить именно влияние объёма L3 Cache на производительность процессора, зафиксируем частоту ядер всех участников на отметке 4000 MHz, а у старших моделей дополнительно отключим ядра, чтобы конфигурация ядер всех участников составила 4 ядра с HT, как и у младшей модели intel Core i3.
Частота контроллера памяти во всех случаях составила 3400 MHz. Оперативная память работала на частоте 2133 MHz по стандарту JEDEC c таймингами 15-15-15-36 CR2.
Тестовая конфигурация
Тестирование в бенчмарках
В Aida64 Cache and Memory Benchmark разный объём L3 Cache оказывает незначительное влияние на прописную способность памяти, также можно заметить, что процессор с более больший кэш 3 уровня несколько отстает по скорости и задержкам от своих младших собратьев с меньшем кэшем.
Бенчмарк CPU-Z как и Geekbench 5 не питает большой любви к объёму кэша, хоть и прослеживается незначительное изменение в производительности.
Похожая картина наблюдается и в бенчмарке 3DMark Time Spy.
А вот программы архивации, в частности, WinRAR, отдают предпочтение процессору с большим кэшем, разница в производительности доходит до 35 %.
7-Zip также положительно откликается на увеличение объёма кэша, разница между моделью i3 с L3 Cache 6 mb и процессором i9 L3 Cache 20 mb составляет порядка 20 % в операциях упаковки.
Получив такую неоднозначную реакцию бенчмарков на объём кэша третьего уровня, переходим к тестированию в играх.
Тестирование в играх
Скандинавская сага о набегах викингов хорошо откликается на изменение объёма L3 кэша, и если переход от процессора с 6 мегабайтами кэша на 12 кажется не столь значительным, то переход на модель i9 c 20 мегабайтами кэша 3 уровня составляет уже 15%.
Подобная картина наблюдается во всех протестированных играх, где-то влияние больше где-то меньше, но оно безусловно.
Это еще раз доказывает факт того что использовать для тестирования необходимо оригинальные модели процессоров а не старшую модель для эмуляции младших путем отключения ядер процессора в биос материнской платы.
Выводы
Изменение объёма кэша 3 уровня положительно сказывается на игровой производительности процессора. Большинство протестированных программ практически не реагируют на его изменение, исключением являются программы-архиваторы.
В целом объем кэша 3 уровня играет немалую роль в производительности процессора, но самостоятельно пользователь увеличить его объем, увы, не сможет.
Выход процессоров AMD Zen 2 с увеличенным до 32 мегабайт кэшем 3 уровня должен был заставить инженеров Intel задуматься, ведь процессор intel Core i3 10100 c кэшем 3 уровня 20 мегабайт мог бы составить конкуренцию даже процессорам Ryzen 5000 серии.
В то же время у большого кэша есть и недостатки — это большая площадь, занимаемая на подложке, и возросшие задержки, но эти недостатки не кажутся такими серьезными на фоне роста производительности.