- Кохерентността на кеша гарантира, че всички копия на едни и същи данни в различни кешове и в RAM паметта остават последователни в многоядрени системи.
- Йерархията на кеша със споделено последно ниво опростява контрола на консистентността и намалява директния достъп до основната памет.
- Протоколите за кохерентност използват стратегии за анулиране или актуализиране на копията, поддържани от състояния и контролни битове на кеш ред.
- Компилаторът и операционната система могат да допълнят хардуерната съгласуваност чрез вмъкване на инструкции и конфигуриране на паметта за критични периоди.
Когато погледнете диаграма на който и да е съвременен многоядрен процесор, винаги се появява един и същ модел: множество ядра, всяко със собствени близки кешове, и споделен кеш от последно ниво, който действа като обща точка, преди да достигне RAM паметта. Тази подредба не е случайна или прищявка на дизайнерите, а директен отговор на критичен проблем в паралелните системи: кохерентността на кеша.
Без стабилен механизъм за съгласуваност, всяко ядро може да работи с различна и остаряла версия на едни и същи данни в паметта , което в реална програма води до фини грешки, непредсказуеми повреди и дори системни сривове. Следователно, разбирането как се поддържа тази съгласуваност – както на хардуерно, така и на софтуерно ниво – е ключово за разбирането на производителността и стабилността на съвременните многоядрени процесори.
Какво е кохерентност на кеша: метафората на терминала
Представете си няколко души, седнали пред различни терминали, всички редактиращи един и същ документ, съхраняван на централен сървър . Всеки екран показва копие на файла и всички промени, направени от един човек, се очаква да се отразят незабавно на екраните на всички останали.
За да работи това, е необходим механизъм за синхронизация, който разпространява промените в документа до всички терминали, така че всички винаги да виждат една и съща версия. Докато тази система работи, всичко е наред: който и да промени текста, знае, че всички останали ще видят новата версия почти мигновено.
Сега си представете, че системата за синхронизация внезапно се повреди. Всеки човек продължава да редактира, убеден, че работи върху споделения документ, но в действителност всеки терминал остава със собствено несвързано локално копие . От този момент нататък промените, направени от един човек, не достигат до останалите и документът започва неконтролируемо да се разминава.
В сферата на изчислителната техника, точно това би се случило, ако процесорът нямаше надежден протокол за съгласуваност: едното ядро променя данните в паметта, но другите ядра продължават да четат по-стара версия от своите частни кешове . Това създава плодородна почва за сериозни логически грешки, повредени данни и поведение при отстраняване на грешки.
Кохерентността на кеша следователно е набор от механизми, които гарантират, че в многоядрена система всички копия на едни и същи данни, разпределени в различните кешове и RAM памет, поддържат консистентно състояние . Дори ако съществуват множество копия, системата трябва да се държи „сякаш“ има само едно.
Кеш памет и йерархия на паметта в многоядрен процесор
Кеш паметта на процесора е малка, много бърза памет, която съхранява копия на често използвани части от RAM паметта . Когато процесорът изпълнява код, вместо непрекъснато да осъществява достъп до (сравнително бавна) RAM памет, той се опитва да чете от и да записва в кеша, което драстично намалява латентността.
Номерът, разбира се, е, че кешовете не съхраняват „официалната версия“ на данните, а само временно копие . Следвайки метафората за терминала, RAM паметта би била документът на сървъра, докато кешовете биха били локалните екрани, които показват копия на определени части от файла.
В многоядрен процесор дизайнът става по-сложен, защото всяко ядро обикновено има свой собствен кеш от ниво 1 (L1) и дори от ниво 2 (L2) . Над тях се добавя например споделен кеш от ниво 3, разположен между ядрата и контролера на паметта, който осигурява достъп до RAM паметта.
Този споделен кеш е въведен, защото разрешаването на директен и интензивен достъп до RAM паметта на всички ядра би довело до конфликти на достъп, конфликти в шината на паметта и значителен спад в производителността . Кешът от последно ниво действа като общ „буфер“, който намалява достъпа до RAM паметта и централизира голяма част от трафика на данни.
Освен това, много архитектури организират кешовете инклузивно: линии, съхранявани на нива, близки до процесора, присъстват и на по-високи нива в йерархията . Тоест, линия, която се появява в L1, е също в L2 и от своя страна в L3. Това има много полезно последствие за последователност: простото актуализиране на кеша от най-ниско ниво е достатъчно, за да се контролира състоянието на другите нива, без да се налага постоянен достъп до RAM паметта.
Защо споделеното кеширане от последно ниво е ключово за съгласуваността
Без този глобален кеш от последно ниво, всяко ядро би трябвало да проверява за съгласуваност директно спрямо основната памет . Всеки път, когато даден ред от паметта в частен кеш бъде променен, би било необходимо да се провери дали други ядра поддържат копие на същия ред и, ако е така, да се актуализира или анулира навсякъде.
В система с много ядра, това натоварване от проверки би довело до огромен брой транзакции в RAM паметта , което би обезсмислило голяма част от предимствата на бързите кешове. Чрез поставяне на споделен кеш между ядрата и паметта, процесорът може да концентрира контрола на кохерентността в едно междинно място.
В много реализации, кешовете на по-високи нива (по-далеч от процесора) съдържат копия на редовете, присъстващи в нивата, по-близо до ядрото . С тази организация, протоколът за кохерентност трябва само да гарантира, че последното ниво е синхронизирано с основната памет и че частните нива на всяко ядро са синхронизирани с нивото непосредствено над него.
Това може да се визуализира като вид руска матрична кукла: кешът от трето ниво включва съдържанието на второто и първото ниво , второто ниво включва собственото си съдържание и това на първото ниво, а първото ниво знае само собствените си редове. По този начин, чрез контролиране на „голямата кукла“ (последното ниво), системата може да координира останалото по-ефективно.
Резултатът е, че поддържането на консистентност става по-икономично от гледна точка на дизайна и трафика на паметта . Вместо да принуждава всяко ядро постоянно да обработва RAM паметта, протоколът работи върху споделения кеш и оттам управлява кои редове трябва да бъдат актуализирани или анулирани в частните кешове.
Методи за актуализиране: обезсилване и актуализиране на копия
Критичен проблем възниква, когато две или повече ядра искат да осъществят достъп, почти едновременно, до един и същ ред данни, който се репликира в множество кешове . В този контекст системите за съгласуваност обикновено използват две основни стратегии при обработката на записи.
Първият метод се основава на анулиране. Когато ядрото трябва да запише в определен ред от кеша, протоколът анулира всички копия на същия ред, които може да съществуват в другите кешове . Само ядрото, което ще записва, поддържа реда в състояние за четене и запис; останалите, ако искат да използват тези данни отново, ще трябва да презаредят реда от по-горното ниво (или от паметта) с актуализираната версия.
Втората стратегия включва актуализиране. В този случай, когато ядрото модифицира ред, системата се опитва автоматично да разпространи новото съдържание към съществуващите копия в другите кешове . По този начин всички кешове, които са съхранили този ред, получават актуализираната версия, без да е необходимо да го анулират и презареждат по-късно.
Всеки подход има своите плюсове и минуси. Анулирането обикновено е по-ефективно, когато записите са чести, защото избягва насищането на паметта с актуализации, от които други ядра може да не се нуждаят веднага. Обратно, актуализирането може да бъде предимство, когато много ядра често четат едни и същи данни, които се променят сравнително рядко , тъй като намалява латентността, като не се налага презареждане на линията след всяко анулиране.
И в двата случая, и двата метода използват допълнителни състояния и контролни битове в кеш редовете. Всеки ред обикновено включва информация за това дали съдържанието му съвпада с това в RAM паметта и дали е споделен, модифициран, ексклузивен, резервиран и т.н., в зависимост от конкретния протокол (MESI, MOESI, MSI и т.н.). Това позволява на хардуера да взема бързи решения за това какво да прави, когато се възникне операция за четене или запис на вече репликиран ред.
Проверка на съгласуваността между кешовете и паметта
Директната проверка на съответствието между всички нива на кеша на процесор или графичен процесор и основната памет би била огромна задача, както по отношение на сложността на дизайна, така и на разходите за производителност. Следователно, съвременните системи организират тази проверка йерархично.
Кешовете, които са най-близо до процесора (L1, L2), обикновено не са свързани директно с RAM паметта, а със следващото ниво на кеша. Това означава, че съгласуваността не се проверява спрямо основната памет на всяко ниво, а по-скоро спрямо непосредствено по-високото ниво . Това намалява броя на достъпите до RAM паметта и опростява логиката, необходима на по-ниските нива.
В крайна сметка, сравнението между съдържанието на кеша и съдържанието на RAM паметта се извършва между кеша от последно ниво и основната памет . Ако това последно ниво поддържа правилно и последователно състояние и всяко по-ниско ниво поддържа своята последователност с това над него, цялата йерархия остава последователна, без да е необходимо всеки ред да се проверява многократно спрямо RAM паметта.
Когато ядрото записва в кеш ред и променя данните си, състоянието на този ред се маркира, за да покаже, че той вече не съвпада точно с копието, съхранено в паметта . Оттам нататък протоколът координира актуализацията: той маркира съответните копия в други кешове като резервирани или невалидни и, когато е уместно, записва новото съдържание в съответния основен ред памет.
Тази каскадна организация позволява промените да се разпространяват прогресивно от ядрото, което актуализира данните, към основната памет, преминавайки през всяко ниво на кеша по контролиран начин. По този начин поддържането на последователност не се превръща в непреодолимо пречка за процесора.
Хардуерна кохерентност спрямо софтуерна кохерентност
Досега обсъждахме механизми за съгласуваност, които се реализират главно в хардуера: протоколи, битове за състояние, споделени кешове и др. Съществува обаче и друг подход, който се стреми да прехвърли част от тази сложност към софтуера , по-специално към компилатора и операционната система.
Софтуерно-базираните схеми за съгласуваност се опитват да намалят нуждата от допълнителна логика на чипа чрез анализ на кода и вземане на решения по време на компилация . Идеята е, че ако компилаторът може да заключи кога и как се осъществява достъп до определени споделени данни, в много случаи той би могъл да предотврати кеширането на тези данни или изрично да управлява тяхната видимост.
Този подход има ясно предимство: част от натоварването се измества от разрешаване по време на изпълнение към разрешаване по време на компилация . Вместо хардуерът да открива и обработва всички конфликти в движение, компилаторът се опитва да ги предвиди и да генерира код, който избягва опасни ситуации.
Недостатъкът е, че статичният анализ на код е ограничен и следователно компилаторите са склонни да бъдат консервативни . Това означава, че за да избегнат нарушаване на съгласуваността, те често вземат решения, които намаляват ефективността на кешовете. Ако подозират, че някои данни може да са проблематични, те често предотвратяват кеширането им или налагат синхронизации по-често от строго необходимото.
Следователно, въпреки че тези софтуерни схеми са привлекателни на теория, особено за опростяване на хардуерния дизайн, на практика те не заместват поддръжката на кохерентност, интегрирана в самия процесор , а по-скоро я допълват в някои специфични сценарии.
Ролята на компилатора за консистентността на кеша
Ключов елемент от софтуерно-базираните подходи за съгласуваност е ролята на компилатора. Компилаторът може да извърши задълбочен анализ на кода и да определи кои споделени структури от данни може да са опасни за кеширане . Въз основа на това той маркира тези елементи по специален начин или адаптира генерирането на код.
Най-простият и същевременно най-консервативният подход е да се предотврати кеширането на споделени променливи с данни . Тоест, всеки достъп до тези променливи налага достъп до основната памет или до некеширана област. Това гарантира последователност, но пропуска много възможности за производителност, защото споделената структура всъщност може да се използва частно през определени периоди или само за четене през други.
В действителност, проблемът с консистентността възниква само по време на интервали, когато поне един процес може да записва в променливата, а друг процес може да я чете . Извън тези критични периоди, променливата може да се третира като предназначена за изключителна употреба от една нишка или дори като ефективна константа за известно време, което позволява кеширането ѝ без проблеми.
Най-модерните стратегии за компилация се опитват да идентифицират онези „безопасни“ периоди, през които споделената променлива може да се счита за неконфликтна . За да направи това, компилаторът анализира пътищата на изпълнение, потенциалните едновременни достъпи и моделите на синхронизация (заключвания, критични секции и др.). Въз основа на този анализ той разделя живота на променливата на фази: някои подходящи за кеширане, други изискващи специална обработка.
По време на критични периоди, когато се засече едновременен достъп със записи, компилаторът вмъква допълнителни инструкции в генерирания код, за да осигури съгласуваност на кеша . Тези инструкции могат да наложат изчистване на кеша, презареждане на паметта, създаване на бариери за паметта или достъп до региони, маркирани като некешируеми, в зависимост от програмния модел и основната архитектура.
Връзка между компилатор, операционна система и хардуер
Фразата „компилаторът вмъква инструкции в генерирания код, за да осигури консистентност на кеша“ може да накара човек да си помисли, че операционната система чете тези инструкции като подсказки от високо ниво и въз основа на това решава как да изпълни програмата. В действителност механизмът е малко по-различен.
Когато компилаторът добавя тези типове инструкции, той въвежда в двоичния файл специфични операции, поддържани от архитектурата или средата за изпълнение . Например, той може да вмъква инструкции за прочистване на кеша, бариери за паметта, специални инструкции за маркиране на региони като некешируеми или извиквания към услуги на операционната система, които конфигурират атрибутите на паметта.
Операционната система не интерпретира тези инструкции като „коментари“ или „подсказки“ от високо ниво, написани от компилатора; тя просто изпълнява машинния код като всеки друг . Някои от тези инструкции обаче са предназначени да взаимодействат с подсистемата памет и управлението на кеша, като по този начин променят начина, по който процесорът осъществява достъп до определени данни.
С други думи, компилаторът извършва предварителен анализ и генерира код, който при изпълнение води до желаното поведение на кеша . Операционната система сътрудничи, като установява атрибути на паметта (кешируеми или некешируеми области, политики за запис и др.) и предоставя примитиви за синхронизация, но не „чете“ специални инструкции в смисъл на семантичната им интерпретация, както би направил компилатор.
Възможно е също така хардуерът, след като види определени инструкции, да активира специфични механизми за кохерентност или синхронизация . Например, инструкциите тип „ограда“ или „бариера“ гарантират реда на достъп до паметта и налагат определени ефекти на видимост в йерархията на кеша. В този случай има тристранно сътрудничество: компилаторът решава къде да разположи тези инструкции, операционната система конфигурира средата за изпълнение, а хардуерът реализира действителното поведение на ниво кеш и шина на паметта.
Заедно всички тези елементи гарантират, че дори с множество копия на едни и същи данни, разпределени в различни кешове и основна памет, паралелните програми се изпълняват с последователен модел на паметта . Кохерентността на кеша, далеч от това да е просто вътрешен детайл на процесора, се превръща в централен компонент за надеждна и ефективна работа на многоядрените системи.
Разбирането на това как се комбинират йерархията на кеша, протоколите за хардуерна кохерентност и техниките за софтуерна поддръжка прави по-ясно защо съвременните дизайни на процесори споделят толкова сходна структура и защо малък отказ във всеки от тези механизми може да предизвика хаотично поведение в едновременни приложения , които зависят изцяло от това всички ядра да виждат едни и същи данни в точното време.