4

我试图了解缓存是如何工作的。我正在研究一个问题以更好地理解这个概念：

给定一个 2 路组关联缓存，块长度为 1 个字，总大小为 16 个长度为 32 位的字，最初为空，并使用最近最少使用的替换策略。显示以下地址是否命中或未命中并列出缓存的最终内容。

地址：

  1. 00010001
  2. 01101011
  3. 00111111
  4. 01001000
  5. 00011001
  6. 01000010
  7. 10001001
  8. 00000000
  9. 01001000
  10. 00011100
  11. 00110000
  12. 11111100
  13. 00111010

首先，根据给定的信息，在我看来，将按以下顺序（T=tag，S=set，O=offset）有 2 个偏移位、3 个设置位和 3 个标记位：TTTSSSOO

示例（地址 1）：

标签 = 000 (0)，设置 = 100 (4)，偏移 = 01 (1)

现在，假设这是正确的，在查找上述地址时应该会发生以下情况：

  1. Miss，存储在第 4 组，第 0 块
  2. Miss，存储在第 2 组，第 0 块
  3. 未命中，存储在第 7 组，第 0 块
  4. Miss，存储在第 2 组第 1 组中
  5. 未命中，存储在第 6 组，第 0 块
  6. Miss, 存储在 set 0, block 0
  7. Miss，存储在 set 2，block 0（block 0 是 LRU，现在 block 1 变成 LRU）
  8. Miss，存储在 set 0，block 1
  9. 击中第 2 组，第 1 组
  10. 小姐，存储在第 7 组，第 1 块
  11. Miss，存储在第 6 组，第 1 块
  12. Miss，存储在 set 7，block 0（block 0 是 LRU，现在 block 1 变成 LRU）
  13. Miss，存储在 set 6，block 0（block 0 是 LRU，现在 block 1 变成 LRU）

缓存的最终内容应如下所示：

设置 0：01000010、00000000

设置1：空的，空的

第 2 组：10001001、01001000

第 3 组：空的，空的

设置 4：00010001，空

第 5 组：空的，空的

第 6 组：00111010、00110000

第 7 组：11111100、00011100

我对此感到非常困难，所以希望有人可以让我知道我是否走在正确的轨道上。如果这些看起来没问题，我想尝试相同的练习，但使用不同的地址进行进一步练习，以确保我掌握了它。

EDIT1：新地址。

  1. 000_100_01
  2. 000_010_01
  3. 000_001_10
  4. 000_001_01
  5. 001_010_11
  6. 000_001_00
  7. 000_010_11
  8. 000_010_01
  9. 001_110_00
  10. 000_100_11
  11. 000_000_01
  12. 000_101_11
  13. 011_010_11

应该喜欢：

  1. 未命中，存储在第 4 组块 0 中
  2. 未命中，存储在第 2 组块 0 中
  3. 未命中，存储在 set 1 块 0 中
  4. Miss，存入set 1 block 1，block 0变成LRU
  5. Miss，存入set 2 block 1，block 0变成LRU
  6. Miss，存入set 1 block 0，block 1变成LRU
  7. Miss，存入set 2 block 0，block 1变成LRU
  8. 命中，set 2 block 0 变成 LRU
  9. 未命中，存储在第 6 组块 0 中
  10. 小姐，存储在第 4 组第 1 组中
  11. 未命中，存储在 set 0 块 0 中
  12. 未命中，存储在第 5 组块 0 中
  13. Miss，存入set 2 block 0，block 1变成LRU
4

0 回答 0