直接映射4条 cacheline，每条cacheline32位数据（混乱版）

🕗 发布于 2024-11-18 05:42 java spring 后端

第一版

如果 cacheline 是 32位，包含：

1-bit valid
1-bit modified
20-bit tag
2-bit index
8-bit 数据

并且缓存是 直接映射 (Direct-Mapped)，这意味着每个内存地址直接映射到特定的一条 cacheline。

直接映射缓存的关键点

直接映射：
- 每个地址唯一映射到一条缓存行。
- 使用 Index 来选择缓存行。
缓存结构：
- 4条 cacheline，即缓存有 4 行。
- 每条 cacheline 存储：
  - 1-bit valid
  - 1-bit modified
  - 20-bit tag
  - 8-bit 数据
- Index (2 bits) 用于选择 4 行中的一行。
地址映射：
- 地址的低 2 位表示数据块偏移（无偏移时忽略）。
- 中间 2 位表示 Index，用于选择缓存行。
- 高位部分为 Tag，用于判断是否命中。

代码实现

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

#define NUM_CACHE_LINES 4  // 直接映射缓存行数

// 缓存行结构
typedef struct {
    uint8_t valid : 1;      // 1-bit valid
    uint8_t modified : 1;   // 1-bit modified
    uint32_t tag : 20;      // 20-bit tag
    uint8_t data;           // 8-bit 数据
} CacheLine;

// 整体缓存结构
typedef struct {
    CacheLine lines[NUM_CACHE_LINES];  // 4 条缓存行
} Cache;

// 初始化缓存
void initializeCache(Cache *cache) {
    for (int i = 0; i < NUM_CACHE_LINES; i++) {
        cache->lines[i].valid = 0;
        cache->lines[i].modified = 0;
        cache->lines[i].tag = 0;
        cache->lines[i].data = 0;
    }
}

// 打印缓存状态
void printCache(Cache *cache) {
    printf("Cache State:\n");
    for (int i = 0; i < NUM_CACHE_LINES; i++) {
        CacheLine *line = &cache->lines[i];
        printf("Cache Line %d -> Valid: %d, Modified: %d, Tag: 0x%05X, Data: 0x%02X\n",
               i, line->valid, line->modified, line->tag, line->data);
    }
}

// 模拟访问缓存
bool accessCache(Cache *cache, uint32_t address, uint8_t memory[256]) {
    uint8_t index = (address >> 2) & 0x3;     // 提取中间 2 位作为 Index
    uint32_t tag = address >> 4;              // 提取高 20 位作为 Tag
    uint8_t data = memory[address & 0xFF];    // 从内存中获取数据

    CacheLine *line = &cache->lines[index];   // 找到对应的缓存行

    // 判断是否命中
    if (line->valid && line->tag == tag) {
        // 命中
        printf("Cache Hit! Address: 0x%X, Data: 0x%X\n", address, line->data);
        return true;
    }

    // 缺失，更新缓存行
    printf("Cache Miss! Address: 0x%X\n", address);
    line->valid = 1;
    line->modified = 0;
    line->tag = tag;
    line->data = data;

    return false;
}

int main() {
    Cache cache;
    uint8_t memory[256]; // 模拟主存

    // 初始化缓存和内存
    initializeCache(&cache);
    for (int i = 0; i < 256; i++) {
        memory[i] = i; // 内存中存储地址对应的值
    }

    // 模拟访问地址
    accessCache(&cache, 0x10, memory); // 访问地址 0x10
    accessCache(&cache, 0x14, memory); // 访问地址 0x14
    accessCache(&cache, 0x10, memory); // 访问地址 0x10
    accessCache(&cache, 0x18, memory); // 访问地址 0x18

    printCache(&cache); // 打印缓存状态

    return 0;
}

代码逻辑

地址解析：
- 4 条缓存行，使用 Index (2 bits)，取地址的第 2-3 位。
- Tag 为地址的高 20 位。
- Data 为低 8 位数据。
命中判断：
- 比较缓存行的 Valid 和 Tag。
- 如果匹配，则命中。
缺失处理：
- 更新对应的缓存行。
- 写入新 Tag 和 Data，并将 Valid 设置为 1。

输出示例

假设访问了地址 0x10, 0x14, 0x10, 0x18，输出可能如下：

Cache Miss! Address: 0x10
Cache Miss! Address: 0x14
Cache Hit! Address: 0x10, Data: 0x10
Cache Miss! Address: 0x18
Cache State:
Cache Line 0 -> Valid: 1, Modified: 0, Tag: 0x01, Data: 0x18
Cache Line 1 -> Valid: 1, Modified: 0, Tag: 0x01, Data: 0x14
Cache Line 2 -> Valid: 0, Modified: 0, Tag: 0x00000, Data: 0x00
Cache Line 3 -> Valid: 0, Modified: 0, Tag: 0x00000, Data: 0x00

总结

直接映射缓存中，每个地址直接映射到一条缓存行。
使用地址的 Index 确定行号，Tag 确定是否命中。
此代码实现了完整的初始化、访问、命中和缺失处理流程。

第二版

根据这张图片中的数字，可以按照以下步骤创建缓存：

缓存参数解析

First Cache Size = 16 bytes
缓存总大小为 16 字节。
First Cache Line Size = 4 bytes
每条缓存行的大小为 4 字节。
First Cache Associativity = 1 (direct-mapped)
缓存是直接映射的，每个地址直接对应一条缓存行。
First Cache Access Latency = 1 cycle
每次缓存访问需要 1 个周期。

如何配置缓存

计算缓存行数
- 缓存总大小为 16 字节，每条缓存行大小为 4 字节：
  [
  \text{Number of Cache Lines} = \frac{\text{Cache Size}}{\text{Cache Line Size}} = \frac{16}{4} = 4
  ]
  缓存共有 4 条缓存行。
直接映射规则
- 每个地址通过索引部分（Index）对应到一条缓存行。
- 4 条缓存行，需要 2 位索引（因为 (2^2 = 4)）。
地址解析
- 地址结构（以 32 位地址为例）：
  - Offset (2 bits): 表示数据在缓存行中的偏移。
  - Index (2 bits): 表示映射到缓存行的编号。
  - Tag (其余位): 用于判断是否命中。

代码实现缓存

以下是直接映射缓存的 C 示例代码：

#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>

// 缓存行结构
typedef struct {
    bool valid;         // 1-bit valid
    uint32_t tag;       // 剩余位数作为 Tag
    uint8_t data[4];    // 每条缓存行存储 4 字节
} CacheLine;

// 缓存结构
typedef struct {
    CacheLine lines[4]; // 4 条缓存行
} Cache;

// 初始化缓存
void initializeCache(Cache *cache) {
    for (int i = 0; i < 4; i++) {
        cache->lines[i].valid = false;
        cache->lines[i].tag = 0;
        for (int j = 0; j < 4; j++) {
            cache->lines[i].data[j] = 0;
        }
    }
}

// 模拟访问缓存
bool accessCache(Cache *cache, uint32_t address, uint8_t memory[256]) {
    uint32_t offset = address & 0x3;           // 低 2 位为 Offset
    uint32_t index = (address >> 2) & 0x3;    // 中间 2 位为 Index
    uint32_t tag = address >> 4;              // 高位为 Tag

    CacheLine *line = &cache->lines[index];

    // 判断是否命中
    if (line->valid && line->tag == tag) {
        printf("Cache Hit! Address: 0x%X, Data: 0x%X\n", address, line->data[offset]);
        return true;
    }

    // 缺失，更新缓存行
    printf("Cache Miss! Address: 0x%X\n", address);
    line->valid = true;
    line->tag = tag;
    for (int i = 0; i < 4; i++) {
        line->data[i] = memory[(address & ~0x3) + i];
    }

    return false;
}

// 打印缓存状态
void printCache(Cache *cache) {
    printf("Cache State:\n");
    for (int i = 0; i < 4; i++) {
        CacheLine *line = &cache->lines[i];
        printf("Cache Line %d -> Valid: %d, Tag: 0x%X, Data: [", i, line->valid, line->tag);
        for (int j = 0; j < 4; j++) {
            printf("0x%X ", line->data[j]);
        }
        printf("]\n");
    }
}

int main() {
    Cache cache;
    uint8_t memory[256]; // 模拟主存

    // 初始化缓存和内存
    initializeCache(&cache);
    for (int i = 0; i < 256; i++) {
        memory[i] = i; // 内存中存储地址对应的值
    }

    // 模拟访问地址
    accessCache(&cache, 0x10, memory); // 访问地址 0x10
    accessCache(&cache, 0x14, memory); // 访问地址 0x14
    accessCache(&cache, 0x10, memory); // 访问地址 0x10
    accessCache(&cache, 0x18, memory); // 访问地址 0x18

    printCache(&cache); // 打印缓存状态

    return 0;
}

代码解释

地址解析：
- Offset: 数据块内的偏移量，用低 2 位表示。
- Index: 选择缓存行，用地址第 2-3 位表示。
- Tag: 地址的高位，用于判断是否命中。
缓存命中和缺失：
- 如果 Valid 位为真，且 Tag 匹配，则命中。
- 如果缺失，从主存加载数据并更新缓存行。
打印缓存状态：
- 显示每条缓存行的有效位、Tag 和数据内容。

运行示例

假设访问地址 0x10, 0x14, 0x10, 0x18：

Cache Miss! Address: 0x10
Cache Miss! Address: 0x14
Cache Hit! Address: 0x10, Data: 0x10
Cache Miss! Address: 0x18
Cache State:
Cache Line 0 -> Valid: 1, Tag: 0x1, Data: [0x18 0x19 0x1A 0x1B]
Cache Line 1 -> Valid: 1, Tag: 0x1, Data: [0x14 0x15 0x16 0x17]
Cache Line 2 -> Valid: 0, Tag: 0x0, Data: [0x0 0x0 0x0 0x0]
Cache Line 3 -> Valid: 0, Tag: 0x0, Data: [0x0 0x0 0x0 0x0]

总结

缓存有 4 条直接映射的行，每行大小为 4 字节。
地址被拆分为 Offset、Index 和 Tag，用于解析和匹配。
缺失时从主存加载数据，并更新缓存行内容。

原文地址：https://blog.csdn.net/xiong_xin/article/details/143841017

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：排序算法——直接插入排序详细讲解
下一篇：SQL注入注入方式（大纲）

【jvm】new对象的过程
如果堆内存中的内存并不是规整的，已被使用的内存和空闲的内存相互交错在一起，JVM就必须维护一个列表，记录上哪些内存块是可用的。：如果堆内存是绝对规整的，所有被使用过的内存都被放在一边，空闲的内存被放在
阅读更多2024-11-25
tcpdump使用方法
是一个强大的命令行工具，用于捕获和分析网络流量。的详细使用说明，包括安装、基本命令、高级用法和过滤示例。保存的数据可用 Wireshark 等工具进行分析。捕获10个数据包后停止。
阅读更多2024-11-25
功能强大的stringstream类
是 C++ 标准库<sstream>中的一个类，它允许我们像操作流一样操作字符串。这意味着我们可以方便地进行字符串与其他数据类型之间的转换、字符串的拼接、分割等一系列操作，极大地提高了字符
阅读更多2024-11-25
住宅IP怎么在指纹浏览器设置运营矩阵账号
然而，随着平台对账号关联的限制越来越严格，如何安全、有效地运营这些矩阵账号成为了一个亟待解决的问题。住宅IP可以提供与用户实际所在地理位置相匹配的IP地址，避免了通过使用非法代理IP等方式所带来的地理
阅读更多2024-11-25
壹肆柒·2025台球展：春季台球行业的璀璨盛会
国内外近三百家行业企业和品牌将齐聚一堂，展示包括台球连锁品牌、各类台球及球桌、精致球杆、舒适观球沙发、实用球杆柜、巧克、台尼、石板、球杆包、摆球框、台球袋、皮头、杆架、延长杆、手套、赛服、先进运营系统
阅读更多2024-11-25
stm32 点亮LED
包含1. 打开LED灯 2. 关闭LED灯 3. 翻转LED灯写入高低电平主要用 GPIO的此函数HAL_GPIO_WritePin（GPIOB, GPIO_PIN_8, GPI
阅读更多2024-11-25
C语言蓝桥杯组题目
C语言蓝桥杯题目
阅读更多2024-11-25
聚水潭与MySQL数据集成案例分享
高吞吐量的数据写入能力：通过批量插入和事务管理，实现高效的数据写入。定制化的数据转换逻辑：灵活应对不同业务需求。实时监控与告警系统：保障整个ETL过程的稳定性和可靠性。异常处理与重试机制：提高系统容错
阅读更多2024-11-25
【Ubuntu24.04】服务部署（虚拟机）
本文主要介绍了如何安装VMware软件，如何在VMware中安装并配置虚拟机，以及部分组件的安装脚本以供参考。
阅读更多2024-11-25
如何在 Ubuntu 22.04 上安装 Metabase 数据可视化分析工具
Metabase提供了一个简单易用的界面，让你能够轻松地对数据进行探索和分析。通过本文的指导，你将能够在 Ubuntu 22.04 系统上安装并配置 Metabase，并通过 Nginx 进行反向代理
阅读更多2024-11-25