Als je net begint te leren hoe multi-core CPU’s, caching, cache-coherentie en geheugen werken, kan het in eerste instantie een beetje verwarrend lijken. Met dat in gedachten bevat de SuperUser Q & A-post van vandaag antwoorden op de vraag van een nieuwsgierige lezer.
De vraag- en antwoordsessie van vandaag komt tot ons dankzij SuperUser – een onderdeel van Stack Exchange, een door de gemeenschap aangestuurde groepering van Q & A-websites.
De vraag
SuperUser-lezer CarmeloS wil weten wanneer de cache van een CPU wordt teruggespoeld naar het hoofdgeheugen:
Als ik een CPU met twee cores heb en elke core zijn eigen L1-cache heeft, is het dan mogelijk dat Core1 en Core2 beide hetzelfde deel van het geheugen tegelijkertijd cachen? Als het mogelijk is, wat is dan de waarde van het hoofdgeheugen als zowel Core1 als Core2 hun waarden in de cache hebben bewerkt?
Wanneer wordt de cache van een CPU teruggespoeld naar het hoofdgeheugen?
Het antwoord
SuperUser-bijdragers David Schwartz, sleske en Kimberly W hebben het antwoord voor ons. Ten eerste, David Schwartz:
Als ik een CPU met twee cores heb en elke core zijn eigen L1-cache heeft, is het dan mogelijk dat Core1 en Core2 beide hetzelfde deel van het geheugen tegelijkertijd cachen?
Ja, de prestaties zouden vreselijk zijn als dit niet het geval was. Overweeg twee threads met dezelfde code. U wilt die code in beide L1-caches.
Als het mogelijk is, wat is dan de waarde van het hoofdgeheugen als zowel Core1 als Core2 hun waarden in de cache hebben bewerkt?
De oude waarde bevindt zich in het hoofdgeheugen, wat niet uitmaakt, aangezien geen van beide kern deze zal lezen. Voordat een gewijzigde waarde uit de cache wordt verwijderd, moet deze naar het geheugen worden geschreven. Meestal wordt een variant van het MESI-protocol gebruikt. Als in de traditionele implementatie van MESI een waarde wordt gewijzigd in één cache, kan deze helemaal niet aanwezig zijn in een andere cache op hetzelfde niveau.
Gevolgd door het antwoord van sleske:
Ja, het kan voorkomen dat twee caches dezelfde geheugenregio cachen en is eigenlijk een probleem dat in de praktijk veel voorkomt. Er zijn verschillende oplossingen, bijvoorbeeld:
- De twee caches kunnen communiceren om ervoor te zorgen dat ze het niet oneens zijn
- U kunt een soort supervisor hebben die alle caches controleert en ze dienovereenkomstig bijwerkt
- Elke processor controleert de geheugengebieden die hij in de cache heeft opgeslagen, en wanneer hij een schrijfactie detecteert, gooit hij zijn (nu ongeldige) cache weg
Het probleem wordt cachecoherentie genoemd en het Wikipedia-artikel over het onderwerp geeft een mooi overzicht van het probleem en mogelijke oplossingen.
En ons laatste antwoord van Kimberly W:
Om de vraag in de titel van je bericht te beantwoorden, hangt het af van het cacheprotocol. Als het terugschrijven is, wordt de cache alleen teruggespoeld naar het hoofdgeheugen als de cachecontroller geen andere keus heeft dan een nieuw cacheblok in de reeds bezette ruimte te plaatsen. Het blok dat eerder de ruimte bezette, wordt verwijderd en de waarde wordt teruggeschreven naar het hoofdgeheugen.
Het andere protocol is doorschrijven. In dat geval wordt het cacheblok altijd op niveau geschreven n, het overeenkomstige blok op niveau n + 1 is geüpdatet. Het concept is vergelijkbaar met het invullen van een formulier met carbonpapier eronder; alles wat u bovenaan schrijft, wordt op het onderstaande blad gekopieerd. Dit is langzamer omdat het duidelijk meer schrijfbewerkingen met zich meebrengt, maar de waarden tussen caches zijn meer consistent. In het terugschrijfschema zou alleen de cache van het hoogste niveau de meest up-to-date waarde hebben voor een bepaald geheugenblok.
Iets toe te voegen aan de uitleg? Geluid uit in de reacties. Wilt u meer antwoorden lezen van andere technisch onderlegde Stack Exchange-gebruikers? Bekijk hier de volledige discussiethread.
Beeldcredits: Lemsipmatt (Flickr)
