Насколько важен кэш L3 для процессоров AMD?
Действительно, имеет смысл оснащать многоядерные процессоры выделенной памятью, которая будет использоваться совместно всеми доступными ядрами. В данной роли быстрый кэш третьего уровня (L3) может существенно ускорить доступ к данным, которые запрашиваются чаще всего. Тогда ядрам, если существует такая возможность, не придётся обращаться к медленной основной памяти (ОЗУ, RAM).
По крайней мере, в теории. Недавно AMD анонсировала процессор Athlon II X4 , представляющий собой модель Phenom II X4 без кэша L3, намекая на то, что он не такой и необходимый. Мы решили напрямую сравнить два процессора (с кэшем L3 и без), чтобы проверить, как кэш влияет на производительность.
Нажмите на картинку для увеличения.
Как работает кэш?
Перед тем, как мы углубимся в тесты, важно понять некоторые основы. Принцип работы кэша довольно прост. Кэш буферизует данные как можно ближе к вычислительным ядрам процессора, чтобы снизить запросы CPU в более отдалённую и медленную память. У современных настольных платформ иерархия кэша включает целых три уровня, которые предваряют доступ к оперативной памяти. Причём кэши второго и, в частности, третьего уровней служат не только для буферизации данных. Их цель заключается в предотвращении перегрузки шины процессора, когда ядрам необходимо обменяться информацией.
Попадания и промахи
Эффективность архитектуры кэшей измеряется процентом попаданий. Запросы данных, которые могут быть удовлетворены кэшем, считаются попаданиями. Если данный кэш не содержит нужные данные, то запрос передаётся дальше по конвейеру памяти, и засчитывается промах. Конечно, промахи приводят к большему времени, которое требуется для получения информации. В результате в вычислительном конвейере появляются "пузырьки" (простои) и задержки. Попадания, напротив, позволяют поддержать максимальную производительность.
Запись в кэш, эксклюзивность, когерентность
Политики замещения диктуют, как в кэше освобождается место под новые записи. Поскольку данные, записываемые в кэш, рано или поздно должны появиться в основной памяти, системы могут делать это одновременно с записью в кэш (write-through) или могут маркировать данные области как "грязные" (write-back), а выполнять запись в память тогда, когда она будет вытесняться из кэша.
Данные в нескольких уровнях кэша могут храниться эксклюзивно, то есть без избыточности. Тогда вы не найдёте одинаковых строчек данных в двух разных иерархиях кэша. Либо кэши могут работать инклюзивно, то есть нижние уровни кэша гарантированно содержат данные, присутствующие в верхних уровнях кэша (ближе к процессорному ядру). У AMD Phenom используются эксклюзивный кэш L3, а Intel следует стратегии инклюзивного кэша. Протоколы когерентности следят за целостностью и актуальностью данных между разными ядрами, уровнями кэшей и даже процессорами.
Объём кэша
Больший по объёму кэш может содержать больше данных, но при этом наблюдается тенденция увеличения задержек. Кроме того, большой по объёму кэш потребляет немалое количество транзисторов процессора, поэтому важно находить баланс между "бюджетом" транзисторов, размером кристалла, энергопотреблением и производительностью/задержками.
Ассоциативность
Записи в оперативной памяти могут привязываться к кэшу напрямую (direct-mapped), то есть для копии данных из оперативной памяти существует только одна позиция в кэше, либо они могут быть ассоциативны в n-степени (n-way associative), то есть существует n возможных расположений в кэше, где могут храниться эти данные. Более высокая степень ассоциативности (вплоть до полностью ассоциативных кэшей) обеспечивает наилучшую гибкость кэширования, поскольку существующие данные в кэше не нужно переписывать. Другими словами, высокая n-степень ассоциативности гарантирует более высокий процент попаданий, но при этом увеличивается задержка, поскольку требуется больше времени на проверку всех этих ассоциаций для попадания. Как правило, наибольшая степень ассоциации разумна для последнего уровня кэширования, поскольку там доступна максимальная ёмкость, а поиск данных за пределами этого кэша приведёт к обращению процессора к медленной оперативной памяти.
Приведём несколько примеров: у Core i5 и i7 используется 32 кбайт кэша L1 с 8-way ассоциативностью для данных и 32 кбайт кэша L1 с 4-way для инструкций. Понятно желание Intel, чтобы инструкции были доступны быстрее, а у кэша L1 для данных был максимальный процент попаданий. Кэш L2 у процессоров Intel обладает 8-way ассоциативностью, а кэш L3 у Intel ещё "умнее", поскольку в нём реализована 16-way ассоциативность для максимизации попаданий.
Однако AMD следует другой стратегии с процессорами Phenom II X4, где используется кэш L1 с 2-way ассоциативностью для снижения задержек. Чтобы компенсировать возможные промахи ёмкость кэша была увеличена в два раза: 64 кбайт для данных и 64 кбайт для инструкций. Кэш L2 имеет 8-way ассоциативность, как и у дизайна Intel, но кэш L3 у AMD работает с 48-way ассоциативностью. Но решение выбора той или иной архитектуры кэша нельзя оценивать без рассмотрения всей архитектуры CPU. Вполне естественно, что практическое значение имеют результаты тестов, и нашей целью как раз была практическая проверка всей этой сложной многоуровневой структуры кэширования.
Каждый современный процессор имеет выделенный кэш, которых хранит инструкции и данные процессора, готовые к использованию практически мгновенно. Этот уровень обычно называют первым уровнем кэширования или L1, впервые такой кэш появился у процессоров 486DX. Недавно процессоры AMD стали стандартно использовать по 64 кбайт кэша L1 на ядро (для данных и инструкций), а процессоры Intel используют по 32 кбайт кэша L1 на ядро (тоже для данных и инструкций)
Кэш первого уровня впервые появился на процессорах 486DX, после чего он стал составной функцией всех современных CPU.
Кэш второго уровня (L2) появился на всех процессорах после выхода Pentium III, хотя первые его реализации на упаковке были в процессоре Pentium Pro (но не на кристалле). Современные процессоры оснащаются до 6 Мбайт кэш-памяти L2 на кристалле. Как правило, такой объём разделяется между двумя ядрами на процессоре Intel Core 2 Duo, например. Обычные же конфигурации L2 предусматривают 512 кбайт или 1 Мбайт кэша на ядро. Процессоры с меньшим объёмом кэша L2, как правило, относятся к нижнему ценовому уровню. Ниже представлена схема ранних реализаций кэша L2.
У Pentium Pro кэш L2 находился в упаковке процессора. У последовавших поколений Pentium III и Athlon кэш L2 был реализован через отдельные чипы SRAM, что было в то время очень распространено (1998, 1999).
Последовавшее объявление техпроцесса до 180 нм позволило производителям, наконец, интегрировать кэш L2 на кристалл процессора.
Первые двуядерные процессоры просто использовали существующие дизайны, когда в упаковку устанавливалось два кристалла. AMD представила двуядерный процессор на монолитном кристалле, добавила контроллер памяти и коммутатор, а Intel для своего первого двуядерного процессора просто собрала два одноядерных кристалла в одной упаковке.
Впервые кэш L2 стал использоваться совместно двумя вычислительными ядрами на процессорах Core 2 Duo. AMD пошла дальше и создала свой первый четырёхъядерный Phenom "с нуля", а Intel для своего первого четырёхъядерного процессора вновь использовала пару кристаллов, на этот раз уже два двуядерных кристалла Core 2, чтобы снизить расходы.
Кэш третьего уровня существовал ещё с первых дней процессора Alpha 21165 (96 кбайт, процессоры представлены в 1995) или IBM Power 4 (256 кбайт, 2001). Однако в архитектурах на основе x86 кэш L3 впервые появился вместе с моделями Intel Itanium 2, Pentium 4 Extreme (Gallatin, оба процессора в 2003 году) и Xeon MP (2006).
Первые реализации давали просто ещё один уровень в иерархии кэша, хотя современные архитектуры используют кэш L3 как большой и общий буфер для обмена данными между ядрами в многоядерных процессорах. Это подчёркивает и высокая n-степень ассоциативности. Лучше поискать данные чуть дольше в кэше, чем получить ситуацию, когда несколько ядер используют очень медленный доступ к основной оперативной памяти. AMD впервые представила кэш L3 на процессоре для настольных ПК вместе с уже упоминавшейся линейкой Phenom. 65-нм Phenom X4 содержал 2 Мбайт общего кэша L3, а современные 45-нм Phenom II X4 имеют уже 6 Мбайт общего кэша L3. У процессоров Intel Core i7 и i5 используется 8 Мбайт кэша L3.
Современные четырёхъядерные процессоры имеют выделенные кэши L1 и L2 для каждого ядра, а также большой кэш L3, являющийся общим для всех ядер. Общиё кэш L3 также позволяет обмениваться данными, над которыми ядра могут работать параллельно.
Всем пользователям хорошо известны такие элементы компьютера, как процессор, отвечающий за обработку данных, а также оперативная память (ОЗУ или RAM), отвечающая за их хранение. Но далеко не все, наверное, знают, что существует и кэш-память процессора(Cache CPU), то есть оперативная память самого процессора (так называемая сверхоперативная память).
В чем же состоит причина, которая побудила разработчиков компьютеров использовать специальную память для процессора? Разве возможностей ОЗУ для компьютера недостаточно?
Действительно, долгое время персональные компьютеры обходились без какой-либо кэш-памяти. Но, как известно, процессор – это самое быстродействующее устройство персонального компьютера и его скорость росла с каждым новым поколением CPU. В настоящее время его скорость измеряется миллиардами операций в секунду. В то же время стандартная оперативная память не столь значительно увеличила свое быстродействие за время своей эволюции.
Вообще говоря, существуют две основные технологии микросхем памяти – статическая память и динамическая память. Не углубляясь в подробности их устройства, скажем лишь, что статическая память, в отличие от динамической, не требует регенерации; кроме того, в статической памяти для одного бита информации используется 4-8 транзисторов, в то время как в динамической – 1-2 транзистора. Соответственно динамическая память гораздо дешевле статической, но в то же время и намного медленнее. В настоящее время микросхемы ОЗУ изготавливаются на основе динамической памяти.
Примерная эволюция соотношения скорости работы процессоров и ОЗУ:
Таким образом, если бы процессор брал все время информацию из оперативной памяти, то ему пришлось бы ждать медлительную динамическую память, и он все время бы простаивал. В том же случае, если бы в качестве ОЗУ использовалась статическая память, то стоимость компьютера возросла бы в несколько раз.
Именно поэтому был разработан разумный компромисс. Основная часть ОЗУ так и осталась динамической, в то время как у процессора появилась своя быстрая кэш-память, основанная на микросхемах статической памяти. Ее объем сравнительно невелик – например, объем кэш-памяти второго уровня составляет всего несколько мегабайт. Впрочем, тут стоить вспомнить о том, что вся оперативная память первых компьютеров IBM PC составляла меньше 1 МБ.
Кроме того, на целесообразность внедрения технологии кэширования влияет еще и тот фактор, что разные приложения, находящиеся в оперативной памяти, по-разному нагружают процессор, и, как следствие, существует немало данных, требующих приоритетной обработки по сравнению с остальными.
История кэш-памяти
Строго говоря, до того, как кэш-память перебралась на персоналки, она уже несколько десятилетий успешно использовалась в суперкомпьютерах.
Впервые кэш-память объемом всего в 16 КБ появилась в ПК на базе процессора i80386. На сегодняшний день современные процессоры используют различные уровни кэша, от первого (самый быстрый кэш самого маленького объема – как правило, 128 КБ) до третьего (самый медленный кэш самого большого объема – до десятков МБ).
Сначала внешняя кэш-память процессора размещалась на отдельном чипе. Со временем, однако, это привело к тому, что шина, расположенная между кэшем и процессором, стала узким местом, замедляющим обмен данными. В современных микропроцессорах и первый, и второй уровни кэш-памяти находятся в самом ядре процессора.
Долгое время в процессорах существовали всего два уровня кэша, но в CPU Intel Itanium впервые появилась кэш-память третьего уровня, общая для всех ядер процессора. Существуют и разработки процессоров с четырехуровневым кэшем.
Архитектуры и принципы работы кэша
На сегодняшний день известны два основных типа организации кэш-памяти, которые берут свое начало от первых теоретических разработок в области кибернетики – принстонская и гарвардская архитектуры. Принстонская архитектура подразумевает единое пространство памяти для хранения данных и команд, а гарвардская – раздельное. Большинство процессоров персональных компьютеров линейки x86 использует раздельный тип кэш-памяти. Кроме того, в современных процессорах появился также третий тип кэш-памяти – так называемый буфер ассоциативной трансляции, предназначенный для ускорения преобразования адресов виртуальной памяти операционной системы в адреса физической памяти.
Упрощенно схему взаимодействия кэш-памяти и процессора можно описать следующим образом. Сначала происходит проверка наличия нужной процессору информации в самом быстром - кэше первого уровня, затем - в кэше второго уровня, и.т.д. Если же нужной информации в каком-либо уровне кэша не оказалось, то говорят об ошибке, или промахе кэша. Если информации в кэше нет вообще, то процессору приходится брать ее из ОЗУ или даже из внешней памяти (с жесткого диска).
Порядок поиска процессором информации в памяти:
Именно таким образом Процессор осуществляет поиск инфоромации
Для управления работой кэш-памяти и ее взаимодействия с вычислительными блоками процессора, а также ОЗУ существует специальный контроллер.
Схема организации взаимодействия ядра процессора, кэша и ОЗУ:
Кэш-контроллер является ключевым элементом связи процессора, ОЗУ и Кэш-памяти
Следует отметить, что кэширование данных – это сложный процесс, в ходе которого используется множество технологий и математических алгоритмов. Среди базовых понятий, применяющихся при кэшировании, можно выделить методы записи кэша и архитектуру ассоциативности кэш-памяти.
Методы записи кэша
Существует два основных метода записи информации в кэш-память:
- Метод write-back (обратная запись) – запись данных производится сначала в кэш, а затем, при наступлении определенных условий, и в ОЗУ.
- Метод write-through (сквозная запись) – запись данных производится одновременно в ОЗУ и в кэш.
Архитектура ассоциативности кэш-памяти
Архитектура ассоциативности кэша определяет способ, при помощи которого данные из ОЗУ отображаются в кэше. Существуют следующие основные варианты архитектуры ассоциативности кэширования:
- Кэш с прямым отображением – определенный участок кэша отвечает за определенный участок ОЗУ
- Полностью ассоциативный кэш – любой участок кэша может ассоциироваться с любым участком ОЗУ
- Смешанный кэш (наборно-ассоциативный)
На различных уровнях кэша обычно могут использоваться различные архитектуры ассоциативности кэша. Кэширование с прямым отображением ОЗУ является самым быстрым вариантом кэширования, поэтому эта архитектура обычно используется для кэшей большого объема. В свою очередь, полностью ассоциативный кэш обладает меньшим количеством ошибок кэширования (промахов).
Заключение
В этой статье вы познакомились с понятием кэш-памяти, архитектурой кэш-памяти и методами кэширования, узнали о том, как она влияет на производительность современного компьютера. Наличие кэш-памяти позволяет значительно оптимизировать работу процессора, уменьшить время его простоя, а, следовательно, и увеличить быстродействие всей системы.
Почти все разработчики знают, что кэш процессора - это такая маленькая, но быстрая память, в которой хранятся данные из недавно посещённых областей памяти - определение краткое и довольно точное. Тем не менее, знание «скучных» подробностей относительно механизмов работы кэша необходимо для понимания факторов влияющих на производительность кода.
В этой статье мы рассмотрим ряд примеров иллюстрирующих различные особенности работы кэшей и их влияние на производительность. Примеры будут на C#, выбор языка и платформы не так сильно влияет на оценку производительности и конечные выводы. Естественно, в разумных пределах, если вы выберите язык, в котором чтение значения из массива равносильно обращению к хеш-таблице, никаких результатов пригодных к интерпретации вы не получите. Курсивом идут примечания переводчика.
Habracut - - -
Пример 1: доступ к памяти и производительность
Как вы думаете, насколько второй цикл быстрее первого?int arr = new int ;// первый
for (int i = 0; i < arr.Length; i++) arr[i] *= 3;// второй
for (int i = 0; i < arr.Length; i += 16) arr[i] *= 3;
Первый цикл умножает все значения массива на 3, второй цикл только каждое шестнадцатое значение. Второй цикл совершает только 6% работы первого цикла, но на современных машинах оба цикла выполняются примерно за равное время: 80 мс и 78 мс соответственно (на моей машине).
Разгадка проста - доступ к памяти. Скорость работы этих циклов в первую очередь определяется скоростью работы подсистемы памяти, а не скоростью целочисленного умножения. Как мы увидим в следующем примере, количество обращений к оперативной памяти одинаково и в первом и во втором случае.
Пример 2: влияние строк кэша
Копнём глубже - попробуем другие значения шага, не только 1 и 16:for (int i = 0; i < arr.Length; i += K /* шаг */ ) arr[i] *= 3;
Вот время работы этого цикла для различных значений шага 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 общие для каждой пары ядер:
Logical Processor to Cache Map:
*--- Data Cache 0, Level 1, 32 KB, Assoc 8, LineSize 64
*--- Instruction Cache 0, Level 1, 32 KB, Assoc 8, LineSize 64
-*-- Data Cache 1, Level 1, 32 KB, Assoc 8, LineSize 64
-*-- Instruction Cache 1, Level 1, 32 KB, Assoc 8, LineSize 64
**-- Unified Cache 0, Level 2, 4 MB, Assoc 16, LineSize 64
--*- Data Cache 2, Level 1, 32 KB, Assoc 8, LineSize 64
--*- Instruction Cache 2, Level 1, 32 KB, Assoc 8, LineSize 64
---* Data Cache 3, Level 1, 32 KB, Assoc 8, LineSize 64
---* Instruction Cache 3, Level 1, 32 KB, Assoc 8, LineSize 64
--** Unified Cache 1, Level 2, 4 MB, Assoc 16, LineSize 64
Проверим эту информацию экспериментально. Для этого, пройдёмся по нашему массиву инкрементируя каждое 16-ое значение - простой способ изменить данные в каждой строке кэша. При достижении конца, возвращаемся к началу. Проверим различные размеры массива, мы должны увидеть падение производительности когда массив перестаёт помещаться в кэши разных уровней.
Код такой:
int steps = 64 * 1024 * 1024; // количество итераций
int lengthMod = arr.Length - 1; // размер массива -- степень двойкиfor (int i = 0; i < steps; i++)
{
// x & lengthMod = x % arr.Length, ибо степени двойки
arr[(i * 16) & lengthMod]++;
}
Результаты тестов:
На моей машине заметны падения производительности после 32 Кбайт и 4 Мбайт - это и есть размеры кэшей L1 и L2.
Пример 4: параллелизм инструкций
Теперь давайте взглянем на кое-что другое. По вашему мнению, какой из этих двух циклов выполнится быстрее?int steps = 256 * 1024 * 1024;
int a = new int ;// первый
for (int i = 0; i < steps; i++) { a++; a++; }// второй
for (int i = 0; i < steps; i++) { a++; a++; }
Оказывается, второй цикл выполняется почти в два раза быстрее, по крайней мере, на всех протестированных мной машинах. Почему? Потому, что команды внутри циклов имеют разные зависимости по данным. Команды первого имеют следующую цепочку зависимостей:
Во втором цикле зависимости такие:
Функциональные части современных процессоров способны выполнять определённое число некоторых операций одновременно, как правило, не очень большое число. Например, возможен параллельный доступ к данным из кэша L1 по двум адресам, так же возможно одновременное выполнение двух простых арифметических команд. В первом цикле процессор не может задействовать эти возможности, но может во втором.
Пример 5: ассоциативность кэша
Один из ключевых вопросов, на который необходимо дать ответ при проектировании кэша - могут ли данные из определённой области памяти храниться в любых ячейках кэша или только в некоторых из них. Три возможных решения:- Кэш прямого отображения , данные каждой строки кэша в оперативной памяти хранятся только в одной заранее определённой ячейке кэша. Простейший способ вычисления отображения: индекс_строки_в_памяти % количество_ячеек_кэша. Две строки, отображённые на одну и ту же ячейку, не могут находится в кэше одновременно.
- N-входовый частично-ассоциативный кэш , каждая строка может храниться в N различных ячейках кэша. Например, в 16-входовом кэше строка может храниться в одной из 16-ти ячеек составляющих группу. Обычно, строки с равными младшими битами индексов разделяют одну группу.
- Полностью ассоциативный кэш , любая строка может быть сохранена в любую ячейку кэша. Решение эквивалентно хеш-таблице по своему поведению.
К примеру, на моей машине кэш 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 < rep; i++)
{
arr[p]++;P += K; if (p >= arr.Length) p = 0;
}Sw.Stop();
return sw.ElapsedMilliseconds;
}
Метод инкрементирует каждый K-ый элемент массива. По достижении конца, начинаем заново. После довольно большого количества итераций (2 20), останавливаемся. Я сделал прогоны для различных размеров массива и значений шага K. Результаты (синий - большое время работы, белый - маленькое):
Синим областям соответствуют те случаи, когда при постоянном изменении данных кэш не в состоянии вместить все требуемые данные одновременно . Яркий синий цвет говорит о времени работы порядка 80 мс, почти белый - 10 мс.
Разберёмся с синими областями:
- Почему появляются вертикальные линии?
Вертикальные линии соответствуют значениям шага при которых осуществляется доступ к слишком большому числу строк (больше 16-ти) из одной группы. Для таких значений, 16-входовый кэш моей машины не может вместить все необходимые данные.
Некоторые из плохих значений шага - степени двойки: 256 и 512. Для примера рассмотрим шаг 512 и массив в 8 Мбайт. При этом шаге, в массиве имеются 32 участка (8 * 2 20 / 262 144), которые ведут борьбу друг с другом за ячейки в 512-ти группах кэша (262 144 / 512). Участка 32, а ячеек в кэше под каждую группу только 16, поэтому места на всех не хватает.
Другие значения шага, не являющиеся степенями двойки, просто невезучие, что вызывает большое количество обращений к одинаковым группам кэша, а так же приводит к появлению вертикальных синих линий на рисунке. На этом месте любителям теории чисел предлагается задуматься.
- Почему вертикальные линии обрываются на границе в 4 Мбайт? При размере массива в 4 Мбайт или меньше, 16-входовый кэш ведёт себя так же как и полностью ассоциативный, то есть может вместить все данные массива без конфликтов. Имеется не более 16-ти областей ведущих борьбу за одну группу кэша (262 144 * 16 = 4 * 2 20 = 4 Мбайт).
- Почему слева вверху находится большой синий треугольник?
Потому, что при маленьком шаге и большом массиве кэш не в состоянии уместить все необходимые данные. Степень ассоциативности кэша играет тут второстепенную роль, ограничение связано с размером кэша L2.
Например, при размере массива в 16 Мбайт и шаге 128, мы обращаемся к каждому 128-му байту, таким образом, модифицируя каждую вторую строку кэша массива. Чтобы сохранить каждую вторую строку в кэше, необходим его объём в 8 Мбайт, но на моей машине есть только 4 Мбайт.
Даже если бы кэш был полностью ассоциативным, это не позволило бы сохранить в нём 8 Мбайт данных. Заметьте, что в уже рассмотренном примере с шагом 512 и размером массива 8 Мбайт, нам необходим только 1 Мбайт кэша, чтобы сохранить все нужные данные, но это невозможно сделать из-за недостаточной ассоциативности кэша.
- Почему левая сторона треугольника постепенно набирает свою интенсивность?
Максимум интенсивности приходится на значение шага в 64 байта, что равно размеру строки кэша. Как мы увидели в первом и во втором примере, последовательный доступ к одной и той же строке практически ничего не стоит. Скажем, при шаге в 16 байт, мы имеем четыре обращения к памяти по цене одного.
Так как количество итераций равно в нашем тесте при любом значении шага, то более дешёвый шаг в результате даёт меньшее время работы.
Ассоциативность кэша - интересная штука, которая может проявить себя при определённых условиях. В отличие от остальных рассмотренных в этой статье проблем, она не является настолько серьёзной. Определённо, это не то, что требует постоянного внимания при написании программ.
Пример 6: ложное разделение кэша
На многоядерных машинах можно столкнуться с другой проблемой - согласование кэшей. Ядра процессора имеют частично или полностью раздельные кэши. На моей машине кэши L1 раздельны (как и обычно), так же имеются два кэша L2, общие для каждой пары ядер. Детали могут различаться, но в целом современные многоядерные процессоры имеют многоуровневые иерархические кэши. Причём самые быстрые, но и самые маленькие кэши, принадлежат индивидуальным ядрам.Когда одно из ядер модифицирует значение в своём кэше, другие ядра больше не могут использовать старое значение. Значение в кэшах других ядер должно быть обновлено. Более того, должна быть обновлена полностью вся строка кэша , так как кэши оперируют данными на уровне строк.
Продемонстрируем эту проблему на следующем коде:
private static int s_counter = new int ;private void UpdateCounter(int position)
{
for (int j = 0; j < 100000000; j++)
{
s_counter = s_counter + 3;
}
}
Если на своей четырёхядерной машине я вызову этот метод с параметрами 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 < 200000000; i++)
{
<какой-то код>
}
}
Если вместо <какой-то код> подставить три разных варианта, можно получить следующие результаты:
Инкрементирование полей A, B, C, D занимает больше времени, чем инкрементирование полей A, C, E, G. Что ещё страннее, инкрементирование полей A и C занимает больше времени, чем полей A, C и E, G. Не знаю точно каковы причины этого, но возможно они связаны с банками памяти (да-да, с обычными трёхлитровыми сберегательными банками памяти, а не то, что вы подумали ). Имеющих соображения на этот счёт, прошу высказываться в комментариях.
У меня на машине вышеописанного не наблюдается, тем не менее, иногда бывают аномально плохие результаты - скорее всего, планировщик задач вносит свои «коррективы».
Из этого примера можно вынести следующий урок: очень сложно полностью предсказать поведение железа. Да, можно предсказать многое, но необходимо постоянно подтверждать свои предсказания с помощью измерений и тестирования.
Заключение
Надеюсь, что всё рассмотренное помогло вам понять устройство кэшей процессоров. Теперь вы можете использовать полученные знания на практике для оптимизации своего кода.Сегодняшняя статья не является самостоятельным материалом - она просто продолжает исследование производительности трех поколений архитектуры Core в равных условиях (начатое в конце прошлого года и продолженное недавно). Правда, сегодня мы сделаем небольшой шаг в сторону - часто́ты ядер и кэш-памяти останутся теми же, что и ранее, а вот емкость последней уменьшится. Зачем это нужно? Мы использовали «полный» Core i7 двух последних поколений для чистоты эксперимента, тестируя его с включенной и отключенной поддержкой технологии Hyper-Threading, поскольку вот уже полтора года как Core i5 снабжаются не 8, а 6 МиБ L3. Понятно, что влияние емкости кэш-памяти на производительность не так уж велико, как иногда принято считать, но оно есть, и никуда от него не деться. К тому же, Core i5 являются более массовыми продуктами, чем Core i7, а в первом поколении по этому параметру их никто «не обижал». Зато раньше их чуть ограничивали по-другому: тактовая частота UnCore в i5 первого поколения составляла всего 2,13 ГГц, так что наш «Nehalem» - это не совсем представитель 700-й линейки на частоте 2,4 ГГц, а немного более быстрый процессор. Однако сильно расширять список участников и переделывать условия тестирования мы сочли излишним - все равно, как мы уже не раз предупреждали, тестирования этой линейки никакой новой практической информации не несут: реальные процессоры работают совсем в других режимах. А вот желающим досконально разобраться во всех тонких моментах, как нам кажется, такое тестирование будет интересно.
Конфигурация тестовых стендов
Мы решили ограничиться всего четырьмя процессорами, причем главных участников будет два: оба четырехъядерных Ivy Bridge, но с разной емкостью кэш-памяти третьего уровня. Третий - «Nehalem HT»: в прошлый раз по итоговому баллу он оказался почти идентичен «Ivy Bridge просто». И «просто Nehalem» который, как мы уже сказали, чуть-чуть быстрее настоящего Core i5 первого поколения, работающего на частоте 2,4 ГГц (из-за того, напомним, что в 700-й линейке частота UnCore была немного ниже), но не слишком радикально. Зато и сравнение интересно: с одной стороны - два шага улучшения микроархитекутры, с другой - кэш-память ограничили. Априори можно предположить, что первое в большинстве случаев перевесит, но вот насколько и вообще - как сопоставимы «первые» и «третьи» i5 (с поправкой на частоту UnCore, конечно, хотя если будет много желающих увидеть абсолютно точное сравнение, мы и его потом сделаем) - уже хорошая тема для исследования.
Тестирование
Традиционно, мы разбиваем все тесты на некоторое количество групп и приводим на диаграммах средний результат по группе тестов/приложений (детально с методикой тестирования вы можете ознакомиться в отдельной статье). Результаты на диаграммах приведены в баллах, за 100 баллов принята производительность референсной тестовой системы сайт образца 2011 года. Основывается она на процессоре AMD Athlon II X4 620, ну а объем памяти (8 ГБ) и видеокарта () являются стандартными для всех тестирований «основной линейки» и могут меняться только в рамках специальных исследований. Тем, кто интересуется более подробной информацией, опять-таки традиционно предлагается скачать таблицу в формате Microsoft Excel , в которой все результаты приведены как в преобразованном в баллы, так и в «натуральном» виде.
Интерактивная работа в трёхмерных пакетах
Некоторое влияние емкости кэш-памяти есть, однако оно менее 1%. Соответственно, оба Ivy Bridge можно считать идентичными друг другу, ну а улучшения архитектуры позволяют новым Core i5 спокойно обгонять старые Core i7 точно также, как это делают новые Core i7.
Финальный рендеринг трёхмерных сцен
В данном случае, естественно, никакие усовершенствования не могут скомпенсировать увеличение количества обрабатываемых потоков, но сегодня для нас самым важным является не это, а полное отсутствие влияния емкости кэш-памяти на производительность. Вот Celeron и Pentium, как мы уже установили , разные процессоры, так что программы рендеринга чувствительны к емкости L3, однако лишь тогда, когда последнего мало. А 6 МиБ на четыре ядра, как видим, вполне достаточно.
Упаковка и распаковка
Естественно, эти задачи восприимчивы к емкости кэш-памяти, однако и здесь эффект от ее увеличения с 6 до 8 МиБ достаточно скромный: примерно 3,6%. Более интересно, на самом деле, сравнение с первым поколением - архитектурные улучшения позволяют новым i5 на равных частотах «громить» даже старые i7, но это в общем зачете: благодаря тому, что два теста из четырех однопоточные, а еще один двухпоточный. Сжатие данных силами 7-Zip, естественно, быстрее всего на «Nehalem HT»: восемь потоков всегда быстрее четырех сравнимой производительности. А вот если ограничиться всего четырьмя, то наш «Ivy Bridge 6М» проигрывает не только своему прародителю, но и старичку Nehalem: улучшения микроархитектуры полностью пасуют перед уменьшением емкости кэш-памяти.
Кодирование аудио
Несколько неожиданным оказался не размер разницы между двумя Ivy Bridge, а то, что она вообще есть. Правда настолько копеечная, что ее можно и на особенности округления или погрешности измерения списать.
Компиляция
Важны потоки, но важна и емкость кэш-памяти. Однако, как обычно, не слишком - порядка 1,5%. Более любопытно сравнение с первым поколением Core при отключенном Hyper-Threading: «по очкам» новенький Core i5 даже на равной частоте побеждает, но один из трех компиляторов (производства Microsoft, если быть точным) отработал на обоих процессорах за одинаковое время. Даже с преимуществом в 5 секунд у более старого - притом, что в этой программе у «полнокэшевого» Ivy Bridge результаты на 4 секунды лучше, чем у Nehalem. В общем, и здесь нельзя считать, что уменьшение емкости L3 как-то сильно повлияло на Core i5 второго и третьего поколения, но есть и нюансы.
Математические и инженерные расчёты
Опять менее 1% разницы со «старшим» кристаллом и опять убедительная победа над первым поколением во всех его видах. Что скорее правило, чем исключение для подобных малопоточных тестов, но почему бы в нем в очередной раз не убедиться? Особенно в таком вот рафинированном виде, когда (в отличие от тестов в штатном режиме) не мешает разница в частотах («стандартных» или появляющаяся из-за работы Turbo Boost).
Растровая графика
Но и при более полной утилизации многопоточности картина не всегда меняется. А емкость кэш-памяти не дает вовсе ничего.
Векторная графика
И здесь аналогично. Правда и потоков вычисления нужна всего парочка.
Кодирование видео
В отличие от этой группы, где, тем не менее, даже Hyper-Threading не позволяет Nehalem бороться на равных с последователями более новых поколений. А вот им не слишком мешает уменьшение емкости кэш-памяти. Точнее, практически вообще не мешает, поскольку разница опять менее 1%.
Офисное ПО
Как и следовало ожидать, никакого прироста производительности от увеличения емкости кэш-памяти (точнее, ее падения от уменьшения) нет. Хотя если посмотреть на подробные результаты, то видно, что единственный многопоточный тест этой группы (а именно распознавание текста в FineReader) выполняется примерно на 1,5% быстрее при 8 МиБ L3, нежели на 6 МиБ. Казалось бы - что такое 1,5%? С точки зрения практики - ничто. А вот с исследовательской точки зрения уже интересно: как видим, именно многопоточным тестам чаще всего не хватает кэш-памяти. В результате разница (пусть и небольшая) иногда находится даже там, где ее быть, вроде бы, не должно. Хотя ничего такого уж необъяснимого в этом нет - грубо говоря, в малопоточных тестах мы имеем 3-6 МиБ на поток, а вот в многопоточных там же получается 1,5 МиБ. Первого - много, а вот второго может оказаться и не совсем достаточно.
Java
Впрочем, Java-машина с такой оценкой не согласна, но и это объяснимо: как мы уже не раз писали, она очень хорошо оптимизирована вовсе не под х86-процессоры, а под телефоны и кофеварки, где ядер может быть много, но вот кэш-памяти очень мало. А иногда и ядер, и кэш-памяти мало - дорогие ресурсы как по площади кристалла, так и по энергопотреблению. И, если с ядрами и мегагерцами что-то сделать получается, то вот с кэшом все сложнее: в четырехъядерной Tegra 3 его, к примеру, всего 1 МиБ. Понятно, что JVM может «схрюпать» и больше (как и все системы с байт-кодом), что мы уже видели сравнивая Celeron и Pentium, но более 1,5 МиБ на поток ей если и может пригодиться, то не в тех задачах, которые вошли в SPECjvm 2008.
Игры
На игры у нас были большие надежды, поскольку к емкости кэш-памяти они нередко оказываются более требовательными чем даже архиваторы. Но бывает такое тогда, когда ее совсем мало, а 6 МиБ - как видим, достаточно. Да и, опять же, процессоры уровня четырехъядерных Core любых поколений даже на частоте 2,4 ГГц слишком мощное решение для используемых игровых приложений, так что узким местом явно будут не они, а прочие компоненты системы. Поэтому мы решили стряхнуть пыль с режимов с низким качеством графики - понятно, что для таких систем он слишком уж синтетичен, но у нас и все тестирование синтетическое:)
Когда не мешают всякие там видеокарты и прочее, разница между двумя Ivy Bridge достигает уже «безумных» 3%: и в этом случае можно не обращать внимания на практике, но для теории - немало. Больше вышло как раз только в архиваторах.
Многозадачное окружение
Где-то мы уже такое видели. Ну да - когда тестировали шестиядерные процессоры под LGA2011. И вот ситуация повторяется: нагрузка что ни на есть многопоточная, часть используемых программ до кэш-памяти «жадная», а вот ее увеличение только снижает среднюю производительность. Чем это можно объяснить? Разве что тем, что усложняется арбитраж и увеличивается количество промахов. Причем, заметим, происходит такое только тогда, когда емкость L3 относительно велика и одновременно работающих потоков вычисления не менее четырех - в бюджетном сегменте совсем другая картина. Во всяком случае, как показало наше недавнее тестирование Pentium и Celeron, для двухъядерных процессоров увеличение L3 с 2 до 3 МиБ добавляет 6% производительности. А вот четырех- и шестиядерным не дает, мягко говоря ничего. Даже менее, чем ничего.
Итого
Закономерный общий итог: поскольку нигде существенной разницы между процессорами с разным объемом L3 не обнаружилось, нет ее и в «общем и целом». Таким образом, расстраиваться по поводу уменьшения емкости кэш-памяти во втором и третьем поколении Core i5 поводов нет - предшественники первого поколения им все равно не конкуренты. Да и старые Core i7 в среднем тоже демонстрируют лишь аналогичный уровень производительности (разумеется, в основном за счет отставания в малопоточных приложениях - а так есть сценарии, с которыми в равных условиях они справляются быстрее). Но, как мы уже говорили, на практике реальные процессоры находятся далеко не в равных условиях по частотам, так что практическая разница между поколениями больше, чем можно получить в таких вот исследованиях.
Открытым остается лишь один вопрос: нам пришлось сильно снизить тактовую частоту для обеспечения равенства условий с первым поколением Core, но сохранятся ли замеченные закономерности в более близких к реальности условиям? Ведь из того, что четыре низкоскоростных потока вычислений не видят разницы между 6 и 8 МиБ кэш-памяти, не следует, что она не обнаружится в случае четырех высокоскоростных. Правда, не следует и обратного, так что для того, чтобы окончательно закрыть тему теоретических исследований, нам понадобится еще одна лабораторная работа, которой мы и займемся в следующий раз.
Центральный процессор - (англ. «central processing unit», CPU - центральное процессорное устройство) - микросхема, предназначенная для обработки программного кода и определяющая основные функций компьютера, касающиеся обработки информации. Процессор выполняет логические и арифметические операции, управляет вычислительными процессами и занимается координацией работы устройств системы.
Центральный процессор представляет собой чип, который расположен на материнской плате или устанавливается в нее.
Рассмотрим основные характеристики микропроцессора.
Ядро - это основная составляющая центрального процессора, которая определяет большинство параметров процессора, например таких, как тип сокета, диапазон рабочих частот и частоту работы внутренней шины передачи данных (FSB).
Ядро процессора имеет следующие характеристики, которые будут рассмотрены ниже: объем внутреннего кэша первого и второго уровня, напряжение, теплоотдача и др.
Количество ядер - число ядер в ЦПУ. Увеличение числа ядер ЦПУ повышает его производительность.
Объем КЭШ - памяти первого уровня (кэш L1)
Кэш L1 - это высокоскоростная память объемом от 8 до 128 Кб, в которую копируются данные из оперативной памяти. Блок кэш-памяти располагается на ядре процессора. Благодаря тому, что обработка данных в кэш-памяти происходит быстрее, чем данных из оперативной памяти, хранение в КЭШе основных команд позволяет увеличить производительность ЦПУ. Для многоядерных процессоров объем КЭШ- памяти L1 указывается для одного ядра.
Объем кэш-памяти второго уровня (кэш L2)
Кэш L2 - это высокоскоростная память, предназначенная для тех же целей, что и кэш-память первого уровня, однако она имеет больший объем - от 128 до 12288 Кб. Для решения ресурсоемких задач предназначены процессоры с большим объемом кэш-памяти второго уровня. Многоядерные ЦПУ характеризуются суммарным объемом кэш L2.
Объем кэш-памяти третьего уровня (кэш L3) находится в диапазоне от 0 до 16384 Кб.
Интегрированная кэш-память третьего уровня и системная шина образуют вместе высокоскоростной канал для обмена данными с системной памятью. Памятью кэш L3 комплектуют в основном только процессоры, предназначенные для комплектации компьютера - сервера. Кэш L3 снабжены такие линейки процессоров, как Itanium 2, Intel Pentium 4 Extreme Edition, Xeon DP и др.
Сокет - разъем для установки микропроцессора на материнскую плату. Тип сокета определяется производителем процессора и количеством ножек. Различным ЦПУ соответствуют различные типы сокетов.
Тактовая частота процессора (МГц) - число операций (тактов), которые процессор выполняет в секунду. Чем выше этот показатель, тем производительней процессор. Но следует помнить, что это справедливо только для ЦПУ одного производителя, так как помимо тактовой частоты на производительность микропроцессора влияют следующие параметры: объем кэш L2, частота кэш L3 и др. Частота процессора пропорциональна FSB (частоте шины).
Частота шины (Front Side Bus - FSB) - это тактовая частота, с которой осуществляется обмен данными между системной шиной и процессором.
Шина данных - это совокупность сигнальных линий, предназначенных для обмена данными процессора с внутренними устройствами компьютера.
Тепловыделение (англ. TDP - thermal design power) - параметр, определяющий какую мощность необходимо отводить системе охлаждения для обеспечения нормального функционирования процессора. Значения этого параметра находятся в диапазоне от 10 до 165 Вт. Производить сравнение величины тепловыделения корректно только для процессоров одного производителя, так каждый производитель по-разному определяет тепловыделение.
Поддержка Virtualization Technology
С помощью функции Virtualization Technology стало возможным загружать одновременно несколько операционных систем на одном компьютере.
Поддержка технологии AMD64/EM64T
Благодаря этой технологии микропроцессоры с 64-битной архитектурой способны работать с 32-битными и 64-битными приложениями одинаково эффективно. Линейки процессоров с 64-битной архитектурой: AMD Athlon 64, AMD Opteron, Core 2 Duo, Intel Xeon 64 и другие. ЦПУ, поддерживающие 64-битную адресацию способны работать с оперативной памятью объемом больше 4 Гб, что недоступно для 32-битных процессоров. Релизация 64-битных расширений в ЦПУ линейки AMD называется AMD64, а для Intel - EM64T.
Максимальная рабочая температура (от 54.8 до 105 C) - это максимальное значение допустимой температуры процессора, при которой возможна нормальная его работа. Рабочая температура ЦПУ зависит от его загруженности и качества охлаждения. При низкой загруженности и нормальном теплоотводе температура процессора составляет 25-40 °C, а при высокой загруженности - до 60-70 °C. Процессорам с высокой рабочей температурой необходимы системы охлаждения, обеспечивающие эффективный теплоотвод.
Напряжение на ядре - показатель, определяющий напряжение на ядре процессора, необходимое процессору для работы. Напряжение на ядре колеблется в диапазоне от 0,65 до 165 Вт.