За что отвечает кэш в процессоре. Новый подход к кэшированию процессора. Какой бывает объем и на что он влияет
Кэш процессора - специальная память внутри процессора для ускорения обращения к оперативной памяти. Иногда кэш процессора называют сверхоперативной памятью, потому что доступ к ней происходит за очень маленькое время. Обычно кэш в процессорах делают на основе классических триггеров - так называемой статической памяти (SRAM). Для примера, оперативная память построена на основе конденсаторов, которые время от времени подзаряжаются. Тригеры обеспечивают практически мгновенный доступ к себе, но у них есть два главных недостатка:
Уровни кэша процессора
В современных процессорах кэш делится на несколько уровней
Алгоритм работы кэш памяти
Алгоритмом работы кэша управляет специальный контроллер, расположенный в процессоре. Он может динамически менять свою схему работы, в зависимости от обстоятельств. Но общий алгоритм кэша таков:
Когда процессор делает запрос на чтение, контроллер кэша ищет значение в кэше и если оно найдено, отправляет его процессору. Если значение не найдено, то контроллер отправляет запрос дальше: или кэшу более низкого уровня, или в оперативную память. После чтения значения с более низкого уровня, кэш добавляет это значение себе и при следующем обращении - сразу отдаст его процессору.
Когда процессор делает запрос на запись в оперативную память, то контроллер кэша обновляет значение у себя и передает его дальше - на более низкие уровни. В конце концов значение оказывается в оперативной памяти. По такому алгоритму обычно работает кэш на запись. Можно конечно сохранять значение только к кэше, но тогда остальные компоненты (например, DMA - прямой доступ к памяти) при доступе к оперативной памяти рискуют получить устаревшее значение.
Частота работы кэш-памяти
Поскольку SRAM память модут работать на очень болших частотах, кэш-память процессора обычно работает на той же частоте, что и сам процессор. Это дополнительно увеличивает скорость работы с этим видом памяти.
Интеллектуальная кэш-память
Современные кэш-контроллеры умеют угадывать, к каким ячейкам памяти процессор скоро обратиться и заранее загружает из в кэш. Например, если процессор обратился к ячейке 42, затем к 43, то высока вероятность того, что третье обращение будет к ячейке 44. Поэтому контроллер заранее загружает значение ячейки 44 себе в сверхбыструю память.
Первый кэш
Некоторое подобие кэша было еще в процессоре 8086. В нем было 6 байт кэша команд. Небольшое количество, без больших интеллектуальных способностей, но он значительно повышал быстродействие системы. Но настоящий кэш стал использоваться с процессором 80386. В те времена для обращения к оперативной памяти нужно было 120 нс времени. Но рядом с процессором ставили специальную микросхему кэш-памяти и доступ к ней просходил в 12 раз быстрее, чем к оперативной памяти. Но эта память (SRAM) была достаточно дорогой и ставить микросхему кэш памяти большого объема было нерентабельно. Поэтому первые кэши процессора были ограничены объемом 64 килобайт и устанавливались они отдельно. Начиная с процесора 80486 кэш процессора стал оправдывать свое название, потому что устанавливался прямо в процессоре.
Место установки кэша
Как уже было сказано выше, в процессоре 80386 не было внутреннего кэша. Кэш устанавливался отдельной микросхемой на материнской плате. В компьютерах на базе процессора 80486 как к прежде на материнской плате размещался кэш, но это был второй уровень. Первый уровень кэша устанавливался прямо в процессоре . С течением времени и развитием технологии изготовления микросхем кэш процессора полностью переехал в процессор, как и контроллер оперативной памяти.
Кэш процессора является эффективным способом увеличить производительность процессора, за счет увеличения скорости работы с оперативной памятью .
Первым процессором, который производился с кэшем L2, стал Pentium Pro в 1995 году. У него было 256 или 512 кбайт кэша второго уровня на кристалле, что давало существенное преимущество над обычными процессорами Pentium, чей кэш располагался на материнской плате. С появлением Pentium II в модуле Slot 1 выделенная кэш-память "поселилась" рядом с процессором. Но только у второго поколения Pentium III для Socket 370 кэш-память перешла на кристалл процессора. Так продолжается и по сей день, но есть процессоры с небольшим количеством кэша, а есть с большим. Стоит ли тратить деньги на модель с большим кэшем? В прошлом дополнительная кэш-память не всегда ощутимо влияла на производительность.
Хотя всегда можно найти измеряемые различия между двумя процессорами с разными размерами кэша, для экономии средств вполне можно было покупать процессоры с меньшим кэшем. Но ни один процессор до появления Core 2 Duo не был доступен с тремя разными вариантами кэша.
Pentium 4 в своём первом поколении (Willamette, 180 нм) оснащался 256 кбайт кэша, а в более успешном втором поколении (Northwood, 130 нм) - уже 512 кбайт кэша. В то время дешёвые процессоры Celeron с меньшим кэшем производились на тех же вычислительных ядрах. Celeron относятся к первому поколению продуктов с одной технологической базой для high-end и дешёвых моделей, различающихся только доступным размером кэша и частотами FSB/ядра. Позднее была добавлена и разница в функциях, чтобы заметнее разделить сегменты рынка.
С выпуском 90-нм ядра Prescott объём кэша L2 вырос до 1 Мбайт, и этот процессор стал основой линейки настольных процессоров Intel до появления 2-Мбайт 65-нм Cedar Mill. Intel даже использовала два таких ядра для создания процессоров Pentium D 900 второго поколения. Впрочем, более быстрые тактовые частоты и больший объём кэша даже тогда не значили очень много. Сегодня ситуация изменилась: лучшая производительность Core 2 Duo (Conroe, 65 нм) и меньшее энергопотребление немало обязаны размеру кэша.
AMD весьма сдержанно относилась к увеличению объёма кэша. Скорее всего, это связано с площадью кристалла (бюджетом транзисторов), поскольку количество 65-нм процессоров не может удовлетворить спрос на рынке, а у менее выгодных 90-нм моделей этот вопрос стоит ещё острее. У Intel, с другой стороны, есть преимущество в виде производства всех массовых процессоров по 65-нм техпроцессу, да и ёмкость кэша L2 будет ещё расти. Например, следующее поколение Core 2 на 45-нм ядре Penryn будет оснащаться до 6 Мбайт кэша L2. Можно ли рассматривать это как маркетинговый шаг, или увеличение ёмкости L2 действительно даст прирост производительности? Давайте посмотрим.
Большой кэш L2: маркетинг или рост производительности?
Кэши процессора играют вполне определённую роль: они уменьшают количество обращений к памяти, буферизуя часто используемые данные. Сегодня ёмкость ОЗУ составляет от 512 Мбайт до 4 Гбайт, а объём кэша - от 256 кбайт до 8 Мбайт, в зависимости от модели. Впрочем, даже небольшого объёма кэша в 256 или 512 кбайт достаточно, чтобы обеспечить высокую производительность, которую сегодня воспринимают само собой разумеющейся.
Есть разные способы организации иерархии кэша. В большинстве современных компьютеров установлены процессоры с небольшим кэшем первого уровня (L1, до 128 кбайт), который обычно разделяется на кэш данных и кэш инструкций. Кэш L2 большего размера обычно используется для хранения данных, он является общим для двух процессорных ядер Core 2 Duo, хотя Athlon 64 X2 или Pentium D имеют раздельные кэши на ядро. Кэш L2 может работать эксклюзивно или инклюзивно, то есть он может либо хранить копию содержимого кэша L1, либо нет. AMD вскоре представит процессоры с третьим уровнем кэша, который будет общим для четырёх ядер в процессорах AMD Phenom. То же самое ожидается и для архитектуры Nehalem, которую Intel представит в 2008 году на замену текущим Core 2.
Кэш L1 всегда был в составе процессора, но поначалу кэш L2 устанавливался на материнские платы, как было в случае многих компьютеров 486DX и Pentium. Для кэш-памяти первого уровня использовались простые чипы статической памяти (SRAM, Static RAM). Они вскоре были заменены конвейерным пакетным кэшем (pipelined burst cache) у процессоров Pentium, пока не появилась возможность устанавливать кэш на кристалл. Pentium Pro на 150 - 200 МГц стал первым процессором, содержащим 256 кбайт кэш-памяти L2 на кристалле, побив рекорд по размеру керамической упаковки для настольных ПК и рабочих станций. Pentium III для Socket 370, работающий на частотах от 500 МГц до 1,13 ГГц, стал первым процессором с 256 кбайт кэш-памяти на кристалле L2, что давало преимущество по снижению задержек, поскольку кэш работает на частоте CPU.
Встроенный кэш L2 дал существенный прирост производительности практически в любых приложениях. Увеличение производительности оказалось столь существенным, что появление интегрированного кэша L2 можно назвать самым важным фактором производительности у процессоров x86. Отключение кэша L2 снизит производительность сильнее, чем отключение второго ядра у двуядерного процессора.
Однако кэш-память влияет не только на производительность. Она стала мощным инструментом, позволяющим создавать разные модели процессоров для low-end, массового и high-end сегментов, поскольку производитель может гибко отбирать процессоры по отбраковке и тактовым частотам. Если на кристалле нет дефектов, то можно включить весь кэш L2, да и частоты получаются высокие. Если же желаемых тактовых частот достичь не удастся, то кристалл может стать моделью начального уровня в high-end линейке, например, Core 2 Duo 6000 с 4 Мбайт кэша и низкими частотами. Если дефекты присутствуют в кэше L2, то производитель имеет возможность отключить его часть и создать модель начального уровня с меньшим объёмом кэша, например, Core 2 Duo E4000 с 2 Мбайт кэша L2 или даже Pentium Dual Core всего с 1 Мбайт кэша. Всё это действительно так, но вопрос заключается в следующем: насколько различие в объёме кэша влияет на производительность?
Варианты Core 2 Duo
Intel выпустила на рынок большой ассортимент настольных процессоров. Сегодня ещё можно найти Pentium 4 и Pentium D, но большинство моделей построено на микро-архитектуре Core. Мы не рекомендуем брать процессоры Pentium 4 или Pentium D, хотя их тактовые частоты до 3,8 ГГц могут выглядеть привлекательно. Но любой процессор Core 2 на частоте 2,2 ГГц и выше способен победить даже самые быстрые модели Pentium D (собственно, как и Athlon 64 X2), поскольку Core 2 даёт намного лучшую производительность на такт .
Благодаря меньшим тактовым частотам процессоры Core 2 более эффективны по энергопотреблению. Если топовые модели Pentium D 800 "съедают" до 130 Вт, то лишь Core 2 Extreme с четырьмя ядрами преодолевает порог 100 Вт. Все двуядерные процессоры потребляют не больше 65 Вт. Кроме того, энергопотребление в режиме бездействия процессоров Core 2 Duo ещё ниже, поскольку рабочая частота в режиме бездействия меньше (максимум 1,2 ГГц для Core 2 Duo/Quad против 2,8 ГГц для Pentium D/4). На снижение энергопотребления повлиял улучшенный дизайн транзисторов с уменьшенными токами утечки.
Сегодня доступны модели E и X. Модели E предназначены для массового рынка, а X относятся к классу Extreme Edition. Q обозначает четыре ядра, которые Intel создаёт, размещая два двуядерных кристалла в одной физической упаковке. Процессоры E6000 оснащены 4 Мбайт кэша L2, если их модельный номер выше E6400 или заканчивается на 20 (например, E6320). Модели, заканчивающиеся на 00 (например, E6600) работают с FSB 266 МГц (FSB1066), а модели, заканчивающиеся на 50 (E6750), работают с FSB 333 МГц (FSB1333). Последняя требует чипсета P35 или X38 и даёт чуть более высокую производительность. E4000 работает с FSB 200 МГц (FSB800) и имеет всего 2 Мбайт кэша L2. Версии с 1 Мбайт кэша продаются как Pentium Dual Core E2140, E2160 и E2180 с частотами от 1,6 до 2,0 ГГц. Кроме названия и некоторых функций, которые Intel отключает у дешёвых процессоров, упомянутые модели Pentium Dual Cores идентичны Core 2 Duo.
| Характеристики процессоровCore 2 Duo | |||||
| Номер 65-нм процессора | Кэш | Тактовая частота | FSB | Технология виртуализации | Технология Trusted Execution |
| E6850 | 4 Мбайт L2 | 3 ГГц | 333 МГц | X | X |
| E6750 | 4 Мбайт L2 | 2,66 ГГц | 333 МГц | X | X |
| E6700 | 4 Мбайт L2 | 2,66 ГГц | 266 МГц | X | |
| E6600 | 4 Мбайт L2 | 2,40 ГГц | 266 МГц | X | |
| E6550 | 4 Мбайт L2 | 2,33 ГГц | 333 МГц | X | X |
| E6540 | 4 Мбайт L2 | 2,33 ГГц | 333 МГц | X | |
| E6420 | 4 Мбайт L2 | 2,13 ГГц | 266 МГц | X | |
| E6400 | 2 Мбайт L2 | 2,13 ГГц | 266 МГц | X | |
| E6320 | 4 Мбайт L2 | 1,86 ГГц | 266 МГц | X | |
| E6300 | 2 Мбайт L2 | 1,86 ГГц | 266 МГц | X | |
| E4600 | 2 Мбайт L2 | 2,40 ГГц | 200 МГц | ||
| E4500 | 2 Мбайт L2 | 2,20 ГГц | 200 МГц | ||
| E4400 | 2 Мбайт L2 | 2 ГГц | 200 МГц | ||
| E4300 | 2 Мбайт L2 | 1,80 ГГц | 200 МГц | ||
| Платформа | |
| CPU I | Intel Pentium Dual Core E2160 (65 нм; 1 800 МГц, 1 Мбайт кэша L2) на частоте 2,4 ГГц (266 МГц x9) |
| CPU II | Intel Core 2 Duo E4400 (65 нм; 2 000 МГц, 2 Мбайт кэша L2) на частоте 2,4 ГГц (266 МГц x9) |
| CPU III | Intel Core 2 Duo X6800 (65 нм; 3 000 МГц, 4 Мбайт кэша L2) на частоте 2,4 ГГц (266 МГц x9) |
| Материнская плата | ASUS Blitz Formula, Rev: 1.0 |
| Чипсет: Intel P35, BIOS 1101 | |
| Память | Corsair CM2X1024-888C4D, 2x 1024 Мбайт DDR2-800 (CL 4-4-4-12 2T) |
| Жёсткий диск | Western Digital Raptor WD1500ADFD, 150 Гбайт, 10 000 об/мин, кэш 16 Мбайт, SATA/150 |
| DVD-ROM | Samsung SH-S183 |
| Видеокарта | Zotac GeForce 8800 GTS, GPU: GeForce 8800 GTS (500 МГц), память: 320 Мбайт GDDR3 (1 600 Мгц) |
| Звуковая карта | Встроенная |
| Блок питания | Enermax EG565P-VE, ATX 2.01, 510 Вт |
| Системное ПО и драйверы | |
| ОС | Windows XP Professional 5.10.2600, Service Pack 2 |
| Версия DirectX | 9.0c (4.09.0000.0904) |
| Драйверы платформы Intel | Version 8.3.1013 |
| Графический драйвер nVidia | Forceware 162.18 |
Тесты и настройки
| 3D-игры | |
| Call Of Duty 2 | Version: 1.3 Retail Video Mode: 1280x960 Anti Aliasing: off Graphics Card: medium Timedemo demo2 |
| Prey | Version: 1.3 Video Mode: 1280x1024 Video Quality: game default Vsync = off Benchmark: THG-Demo |
| Quake 4 | Version: 1.2 (Dual-Core Patch) Video Mode: 1280x1024 Video Quality: high THG Timedemo waste.map timedemo demo8.demo 1 (1 = load textures) |
| Аудио | |
| Lame MP3 | Version 3.98 Beta 5 Audio CD "Terminator II SE", 53 min wave to mp3 160 kbps |
| Видео | |
| TMPEG 3.0 Express | Version: 3.0.4.24 (no Audio) fist 5 Minutes DVD Terminator 2 SE (704x576) 16:9 Multithreading by rendering |
| DivX 6.7 | Version: 6.6 (4 Logical CPUs) Profile: High Definition Profile 1-pass, 3000 kbit/s Encoding mode: Insane Quality Enhanced multithreading no Audio |
| XviD 1.1.3 | Version: 1.1.3 Target quantizer: 1.00 |
| Mainconcept H.264 v2 | Version 2.1 260 MB MPEG-2 source (1920x1080) 16:9 Codec: H.264 Mode: NTSC Audio: AAC Profile: High Stream: Program |
| Приложения | |
| WinRAR | Version 3.70 (303 MB, 47 Files, 2 Folders) Compression = Best Dictionary = 4096 kB |
| Autodesk 3D Studio Max | Version: 8.0 Characters "Dragon_Charater_rig" rendering HTDV 1920x1080 |
| Cinebench | Version: R10 1 CPU, x CPU run |
| PCMark05 Pro | Version: 1.2.0 CPU and Memory Tests Windows Media Player 10.00.00.3646 Windows Media Encoder 9.00.00.2980 |
Заключение
Если объём кэш-памяти ограниченно влияет на такие синтетические тесты, как PCMark05, то разница в производительности большинства реальных приложений оказалась весьма существенной. Поначалу это кажется удивительным, поскольку опыт говорит, что именно синтетические тесты дают самую ощутимую разницу в производительности, которая мало отражается на реальных приложениях.
Ответ прост: размер кэша очень важен для современных процессоров с микро-архитектурой Core 2 Duo. Мы использовали 4-Мбайт Core 2 Extreme X6800, 2-Мбайт Core 2 Duo E4400 и Pentium Dual Core E2160, который является процессором Core 2 Duo с кэшем L2 всего 1 Мбайт. Все процессоры работали на одинаковой системной шине 266 МГц и с множителем 9x, чтобы частота составила 2 400 МГц. Единственная разница заключается в размере кэша, поскольку все современные двуядерные процессоры, за исключением старого Pentium D, производятся из одинаковых кристаллов. Чем станет ядро, Core 2 Extreme Edition или Pentium Dual Core, определяется выходом годных кристаллов (дефектами) или спросом рынка.
Если вы сравните результаты 3D-шутеров Prey и Quake 4, являющих типичными игровыми приложениями, разница в производительности между 1 и 4 Мбайт составляет примерно один шаг по частоте. То же самое касается тестов кодирования видео для кодеков DivX 6.6 и XviD 1.1.2, а также архиватора WinRAR 3.7. Однако, такие интенсивно нагружающие CPU приложения, как 3DStudio Max 8, Lame MP3 Encoder или H.264 Encoder V2 от MainConcept не слишком сильно выигрывают от увеличения размера кэша.
Впрочем, подход Intel, а именно, использование всего доступного бюджета транзисторов, который увеличился при переходе с 65-нм техпроцесса на 45-нм, имеет для микро-архитектуры Core 2 Duo определённую значимость. Кэш L2 у этих процессоров работает очень эффективно, особенно, если учесть, что он общий для двух ядер. Поэтому кэш нивелирует влияние разных частот памяти и предотвращает "узкое место" в виде FSB. И делает он это замечательно, поскольку тесты наглядно показывают, что производительность процессора с одним мегабайтом кэш-памяти невысокая.
С этой точки зрения увеличение размера кэша L2 с 4 Мбайт до, максимум, 6 Мбайт у грядущих 45-нм двуядерных процессоров Penryn (линейка Core 2 Duo E8000) имеет смысл. Уменьшение техпроцесса с 65 до 45 нм позволяет Intel увеличить бюджет транзисторов, и благодаря увеличению объёма кэша мы вновь получим рост производительности. Впрочем, Intel получит выгоду из-за разных вариантов процессоров с 6, 4, 2 или даже 1 Мбайт кэша L2. Благодаря нескольким вариантам Intel может использовать большее число кристаллов с пластины, несмотря на наличие случайных дефектов, которые в противном случае приводили бы к попаданию кристалла в мусорную корзину. Большой размер кэша, как видим, важен не только для производительности, но и для прибыли Intel.
Всем пользователям хорошо известны такие элементы компьютера, как процессор, отвечающий за обработку данных, а также оперативная память (ОЗУ или RAM), отвечающая за их хранение. Но далеко не все, наверное, знают, что существует и кэш-память процессора(Cache CPU), то есть оперативная память самого процессора (так называемая сверхоперативная память).
В чем же состоит причина, которая побудила разработчиков компьютеров использовать специальную память для процессора? Разве возможностей ОЗУ для компьютера недостаточно?
Действительно, долгое время персональные компьютеры обходились без какой-либо кэш-памяти. Но, как известно, процессор – это самое быстродействующее устройство персонального компьютера и его скорость росла с каждым новым поколением CPU. В настоящее время его скорость измеряется миллиардами операций в секунду. В то же время стандартная оперативная память не столь значительно увеличила свое быстродействие за время своей эволюции.
Вообще говоря, существуют две основные технологии микросхем памяти – статическая память и динамическая память. Не углубляясь в подробности их устройства, скажем лишь, что статическая память, в отличие от динамической, не требует регенерации; кроме того, в статической памяти для одного бита информации используется 4-8 транзисторов, в то время как в динамической – 1-2 транзистора. Соответственно динамическая память гораздо дешевле статической, но в то же время и намного медленнее. В настоящее время микросхемы ОЗУ изготавливаются на основе динамической памяти.
Примерная эволюция соотношения скорости работы процессоров и ОЗУ:
Таким образом, если бы процессор брал все время информацию из оперативной памяти, то ему пришлось бы ждать медлительную динамическую память, и он все время бы простаивал. В том же случае, если бы в качестве ОЗУ использовалась статическая память, то стоимость компьютера возросла бы в несколько раз.
Именно поэтому был разработан разумный компромисс. Основная часть ОЗУ так и осталась динамической, в то время как у процессора появилась своя быстрая кэш-память, основанная на микросхемах статической памяти. Ее объем сравнительно невелик – например, объем кэш-памяти второго уровня составляет всего несколько мегабайт. Впрочем, тут стоить вспомнить о том, что вся оперативная память первых компьютеров IBM PC составляла меньше 1 МБ.
Кроме того, на целесообразность внедрения технологии кэширования влияет еще и тот фактор, что разные приложения, находящиеся в оперативной памяти, по-разному нагружают процессор, и, как следствие, существует немало данных, требующих приоритетной обработки по сравнению с остальными.
История кэш-памяти
Строго говоря, до того, как кэш-память перебралась на персоналки, она уже несколько десятилетий успешно использовалась в суперкомпьютерах.
Впервые кэш-память объемом всего в 16 КБ появилась в ПК на базе процессора i80386. На сегодняшний день современные процессоры используют различные уровни кэша, от первого (самый быстрый кэш самого маленького объема – как правило, 128 КБ) до третьего (самый медленный кэш самого большого объема – до десятков МБ).
Сначала внешняя кэш-память процессора размещалась на отдельном чипе. Со временем, однако, это привело к тому, что шина, расположенная между кэшем и процессором, стала узким местом, замедляющим обмен данными. В современных микропроцессорах и первый, и второй уровни кэш-памяти находятся в самом ядре процессора.
Долгое время в процессорах существовали всего два уровня кэша, но в CPU Intel Itanium впервые появилась кэш-память третьего уровня, общая для всех ядер процессора. Существуют и разработки процессоров с четырехуровневым кэшем.
Архитектуры и принципы работы кэша
На сегодняшний день известны два основных типа организации кэш-памяти, которые берут свое начало от первых теоретических разработок в области кибернетики – принстонская и гарвардская архитектуры. Принстонская архитектура подразумевает единое пространство памяти для хранения данных и команд, а гарвардская – раздельное. Большинство процессоров персональных компьютеров линейки x86 использует раздельный тип кэш-памяти. Кроме того, в современных процессорах появился также третий тип кэш-памяти – так называемый буфер ассоциативной трансляции, предназначенный для ускорения преобразования адресов виртуальной памяти операционной системы в адреса физической памяти.
Упрощенно схему взаимодействия кэш-памяти и процессора можно описать следующим образом. Сначала происходит проверка наличия нужной процессору информации в самом быстром - кэше первого уровня, затем - в кэше второго уровня, и.т.д. Если же нужной информации в каком-либо уровне кэша не оказалось, то говорят об ошибке, или промахе кэша. Если информации в кэше нет вообще, то процессору приходится брать ее из ОЗУ или даже из внешней памяти (с жесткого диска).
Порядок поиска процессором информации в памяти:
Именно таким образом Процессор осуществляет поиск инфоромации
Для управления работой кэш-памяти и ее взаимодействия с вычислительными блоками процессора, а также ОЗУ существует специальный контроллер.
Схема организации взаимодействия ядра процессора, кэша и ОЗУ:
Кэш-контроллер является ключевым элементом связи процессора, ОЗУ и Кэш-памяти
Следует отметить, что кэширование данных – это сложный процесс, в ходе которого используется множество технологий и математических алгоритмов. Среди базовых понятий, применяющихся при кэшировании, можно выделить методы записи кэша и архитектуру ассоциативности кэш-памяти.
Методы записи кэша
Существует два основных метода записи информации в кэш-память:
- Метод write-back (обратная запись) – запись данных производится сначала в кэш, а затем, при наступлении определенных условий, и в ОЗУ.
- Метод write-through (сквозная запись) – запись данных производится одновременно в ОЗУ и в кэш.
Архитектура ассоциативности кэш-памяти
Архитектура ассоциативности кэша определяет способ, при помощи которого данные из ОЗУ отображаются в кэше. Существуют следующие основные варианты архитектуры ассоциативности кэширования:
- Кэш с прямым отображением – определенный участок кэша отвечает за определенный участок ОЗУ
- Полностью ассоциативный кэш – любой участок кэша может ассоциироваться с любым участком ОЗУ
- Смешанный кэш (наборно-ассоциативный)
На различных уровнях кэша обычно могут использоваться различные архитектуры ассоциативности кэша. Кэширование с прямым отображением ОЗУ является самым быстрым вариантом кэширования, поэтому эта архитектура обычно используется для кэшей большого объема. В свою очередь, полностью ассоциативный кэш обладает меньшим количеством ошибок кэширования (промахов).
Заключение
В этой статье вы познакомились с понятием кэш-памяти, архитектурой кэш-памяти и методами кэширования, узнали о том, как она влияет на производительность современного компьютера. Наличие кэш-памяти позволяет значительно оптимизировать работу процессора, уменьшить время его простоя, а, следовательно, и увеличить быстродействие всей системы.
Все процессоры с конца 90-х годов имеют внутреннюю кэш-память (или просто кэш). Кэш — это быстродействующая память, в которую переносятся команды и данные, непосредственно обрабатываемые процессором.
В современных процессорах встроена кэш-память двух уровней — первого (L1) и второго (L2). С содержимым кэша L1 процессор работает несколько быстрее, а объем кэша L2 обычно несколько больше. Обращение к кэш-памяти происходит без состояния ожидания, т.е. кэш-память первого уровня (встроенный кэш) работает на частоте процессора.
Это означает, что если данные, необходимые процессору, находятся в кэш-памяти, то задержек с обработкой не возникает. В противном случае процессор должен получить данные из основной памяти, что существенно уменьшает быстродействие системы.
Для того чтобы качественно разобраться с принципом работы кэшпамяти обоих уровней, рассмотрим на примере бытовую ситуацию.
Вы приходите в кафе пообедать ежедневно, в одно и то же время, и садитесь всегда за один и тот же столик. Всегда заказываете стандартный набор из трех блюд.
Официант бегает на кухню, повар их раскладывает на поднос и затем вам приносят заказ. И вот, скажем, на третий день официант, чтобы лишний раз не бегать на кухню, к назначенному времени встречает вас с уже готовым горячим обедом на подносе.
Вы не ждете заказ и сэкономили массу времени. Поднос с вашими блюдами — это и есть кэш первого уровня. Но на четвертый день вам вдруг захотелось добавить еще одно блюдо, допустим, десерт.
Хотя вас в назначенное время уже ждал поднос с заказом, но за десертом официанту все равно пришлось бежать на кухню.
А на пятый — снова меню из трех наименований. На шестой — опять десерт, но отличающийся от предыдущего. И официант, не зная, что вы из десерта захотите заказать (да и вообще не зная, будете ли вы что-либо заказывать), решается на следующий шаг: рядом с вашим столиком ставит шкафчик с несколькими наименованиями десерта.
И если вы изъявите желание, все под рукой, на кухню бежать не надо. Шкафчик с десертом — это кэш второго уровня.
От объема кэша L1 (от 16 до 128 Кбайт) и L2 (от 64 Кбайт до 512 Кбайт, в Pentium III Хеоп и AMD Opteron до 4 Мбайт) существенно зависит производительность процессора.
У процессоров Intel Pentium III и процессоров Celeron на его основе размер кэша L1 составляет 32 Кбайт. У Intel Pentium 4, а также на его базе Celeron и Хеоп-версий — всего 20 Кбайт. Процессоры AMD Duron, Athlon (включая ХР/МР) и Opteron, а также VIA СЗ содержат 128 Кбайт L1 кэша.
Современные двухъядерные процессоры имеют кэш первого уровня для каждого ядра в отдельности, поэтому иногда в описании кэша мы можем встретить цифру 128×2. Это означает, что каждое ядро процессора обладает 128 Кбайт кэш-памяти первого уровня.
Размер кэша L1 важен для получения высокой производительности в большинстве распространенных задач (офисные приложения, игры, большинство серверных приложений и т.п.). Особенно сильно его эффективность проявляется для поточных вычислений (например, обработка видеоизображения).
Это одна из причин того, что Pentium 4 относительно малоэффективен для большинства распространенных применений (хотя это компенсируется высокой тактовой частотой). Кэш L1 всегда работает (обменивается информацией с ядром процессора) на внутренней частоте процессора.
В отличие от него, кэш L2 в разных моделях процессоров работает с разной частотой (и соответственно производительностью). Начиная с Intel Pentium II во многих процессорах применялся кэш L2, работающий на частоте, вполовину меньшей, чем внутренняя частота процессора.
Такое решение использовано в устаревших процессорах Intel Pentium III (до 550 МГц) и устаревших AMD Athlon (в некоторых из них внутренний кэш L2 работал на трети частоты ядра процессора). Объем кэша L2 также различен для разных процессоров.
В устаревших, а также некоторых более новых процессорах Intel Pentium III объем кэша L2 составляет 512 Кбайт, в остальных Pentium III — 256 Кбайт. Процессор Intel Celeron на основе Pentium III выпускался с 128 и 256 Кбайт кэша L2, а на основе Pentium 4 — только со 128 Кбайт. В различных вариантах Xeon-версии Intel Pentium 4 присутствует до 4 Мбайт кэш-памяти L2.
В новых процессорах Pentium 4 (некоторые серии с частотой 2000 МГц и все — для частот выше) имеется 512 Кбайт кэша L2, в остальных Pentium 4 -256 Кбайт. В процессорах Хеоп (на основе Pentium 4) бывает 256 или 512 Кбайт кэша L2.
Кроме того, в них присутствует еще кэш-память третьего уровня L3. Интегрированная кэш-память L3 в сочетании с быстрой системной шиной формирует высокоскоростной канал обмена данными с системной памятью.
Как правило, кэш-памятью третьего уровня L3 комплектуются только процессоры для серверных решений или специальные модели «настольных» процессоров. Кэш-памятью L3 обладают, например, такие линейки процессоров, как Xeon DP, Itanium 2, Xeon MP.
Процессор AMD Duron имеет 128 Кбайт кэша L1 и 64 Кбайт кэша L2. В процессорах Athlon (кроме наиболее старых), Athlon MP и большинстве вариантов Athlon ХР присутствует 128 Кбайт кэша L1 и 256 Кбайт кэша L2, а в новейших Athlon ХР (2500+, 2800+, 3000+ и выше) — 512 Кбайт кэша L2. AMD Opteron содержит 1 Мбайт кэш-памяти L2.
Последние модели процессоров Intel Pentium D, Intel Pentium M, Intel Core 2 Duo выпускаются с 6 Мбайт кэш-памяти L2, a Core 2 Quad — 12 Мбайт кэш-памяти L2.
Последний на момент написания данной книги процессор фирмы Intel Core i7 обладает 64 Кбайт кэш-памяти L1 для каждого из 4 ядер, а также 256 Кбайт памяти L2 также для каждого ядра. Помимо кэш памяти первого и второго уровней процессор обладает и общей для всех ядер кэш-памятью третьего уровня, равной 8 Мбайт.
Для процессоров, у которых возможен разный размер кэша L2 (или в случае Intel Xeon MP — L3) у одной и той же модели, этот размер должен быть указан при продаже (от него, разумеется, зависит цена процессора). Если процессор продается в «коробочной» упаковке (поставка In-Box), на ней обычно указывается размер кэш-памяти.
Для обычных пользовательских задач (в том числе игр) важнее скорость кэша L2, чем его объем; для серверных задач, наоборот, важнее объем. Наиболее продуктивные серверы, особенно с большим объемом оперативной памяти (несколько гигабайт), требуют максимального объема и максимальной скорости кэша L2.
Непревзойденными по этим параметрам остаются Хеоп-версии процессоров Pentium III. (Процессор Xeon MP оказывается все же более производительны в серверных задачах, чем Pentium III Xeon, за счет более высокой тактовой частоты самого процессора и шины обмена информацией с памятью.) Из изложенного выше сделаем вывод: кэш-память улучшает взаимодействие между быстрым процессором и более медленной оперативной памятью, а также позволяет минимизировать периоды ожидания, возникающие при обработке данных. Решающую роль в этом играет кэш-память второго уровня, расположенная в кристалле процессора.
Почти все разработчики знают, что кэш процессора - это такая маленькая, но быстрая память, в которой хранятся данные из недавно посещённых областей памяти - определение краткое и довольно точное. Тем не менее, знание «скучных» подробностей относительно механизмов работы кэша необходимо для понимания факторов влияющих на производительность кода.
В этой статье мы рассмотрим ряд примеров иллюстрирующих различные особенности работы кэшей и их влияние на производительность. Примеры будут на 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. Не знаю точно каковы причины этого, но возможно они связаны с банками памяти (да-да, с обычными трёхлитровыми сберегательными банками памяти, а не то, что вы подумали ). Имеющих соображения на этот счёт, прошу высказываться в комментариях.
У меня на машине вышеописанного не наблюдается, тем не менее, иногда бывают аномально плохие результаты - скорее всего, планировщик задач вносит свои «коррективы».
Из этого примера можно вынести следующий урок: очень сложно полностью предсказать поведение железа. Да, можно предсказать многое, но необходимо постоянно подтверждать свои предсказания с помощью измерений и тестирования.