Ik ben de logica van cachegeheugens aan het leren. Ik vraag me af of je kunt verifiëren dat ik het goed heb begrepen. Als een cachegeheugen in het tagveld heeft 16 bits, het ingestelde veld heeft 10 bits en de byte in het blokveld is 6 bits, dan kan ik alleen uit die informatie afleiden dat de capaciteit 128 kbyte is en het is 2-way set associatief met blokgrootte 64 byte omdat 2⁶ = 64 byte van de byte in blokveld. 2¹⁰ = 1024 maar zou een andere capaciteit met een ander associativiteitsnummer aan de vereisten kunnen voldoen?
Ik leer dat de formules zijn
aantal blokken = capaciteit / blokgrootte
aantal sets = aantal blokken / #associativiteit
Daarom Ik zou zowel de associativiteit naar 4-way kunnen verdubbelen, maar ik kon niet aan de vereisten voldoen met een 4-way cache omdat het wo uld vereist een ander aantal bits in het ingestelde veld.
Heb ik het goed begrepen?
Antwoord
Helpt deze afbeelding je te begrijpen hoe associatieve caches werken structureel?
geleend van hier
In een notendop bepalen de block offset bits je blokgrootte (hoeveel bytes zitten er in een cache-rij, hoeveel kolommen als je wilt). De indexbits bepalen hoeveel rijen er in elke set zitten. De capaciteit van de cache is dus 2 ^ (blockoffsetbits + indexbits) * #sets. In dit geval is dat 2 ^ (4 + 4) * 4 = 256 * 4 = 1 kilobyte.
Voor dezelfde grootte cache (capaciteit), als je zou gaan van 4-way naar two- way set associatief, het is tweericht associatief, je zou dit kunnen doen door ofwel de rijen in elke set te verdubbelen of door de kolommen in elke set te verdubbelen, dat wil zeggen door het aantal cache-regels te verdubbelen of de blokgrootte te verdubbelen.
Als je ervoor kiest om het aantal rijen te verdubbelen, zou je 12-bits adres worden opgesplitst in een 5-bits index en een 4-bits blok-offset, waardoor een 3-bits tag overblijft.
Als je ervoor kiest om de blokgrootte te verdubbelen, zou je eindigen met het opbreken van je 12-bits adres in een 4-bits index, een 5-bits blok-offset, waardoor er een 3-bits tag overblijft. / p>
Dus om het opnieuw te herhalen, denk ik dat de heersende formules voor associatieve caches zijn:
Cache Capacity = (Block Size in Bytes) * (Blocks per Set) * (Number of Sets) Index Bits = LOG2(Blocks per Set) Block Offset Bits = LOG2(Block Size in Bytes) Tag Bits = (Address Bits) - (Index Bits) - (Block Offset Bits) In je oorspronkelijk genoemde voorbeeld, ik niet ” Ik denk dat je de grootte van de cache kunt afleiden op basis van de grootte van je respectieve adresbitvelden zonder een aanname te doen ut de associativiteit. Als het associatief in twee richtingen is, dan zou je kunnen zeggen:
Cachecapaciteit = (2 ^ 6) * (2 ^ 10) * (2) = 2 ^ 18 = 2 ^ 8 kilobytes = 256 kilobytes. Ik weet niet zeker hoe je aan 128 kilobytes bent gekomen. Dat zou het geval zijn als het associatief in één richting (direct toegewezen) was.
Voor een cachecapaciteit van 128 kB (2 ^ 17 bytes) zou een 4-weg associatieve cache kunnen maken met een blokgrootte van 64 bytes door te zeggen:
2^17 = 2^6 * (Blocks per Set) * 4 Blocks per Set = 2^17 / 2^6 / 2^2 = 2^9 = 512 … en daarom 9 indexbits, 4 blokoffsetbits toe te wijzen , en de rest (19) tagbits.