如何根据入参修改或创建struct以支持多类型缓存模拟

1. 统一缓存数据结构设计 #

抛弃分类型定义struct的思路，三类缓存映射逻辑本质可以复用同一套结构：

• 直接映射等价于1路组相联
• 全相联等价于1组N路组相联
  所以直接定义通用缓存结构体，所有参数改为动态成员，不用#define硬编码：

// 缓存块结构
typedef struct {
    uint8_t valid;
    uint8_t dirty;
    uint64_t tag;
    uint32_t last_access_ts; // LRU替换用时间戳
} cache_block_t;

// 缓存类型枚举
typedef enum {
    CACHE_DIRECT,
    CACHE_NWAY,
    CACHE_FULLY_ASSOC
} cache_type_t;

// 通用缓存结构体
typedef struct {
    cache_type_t type;
    size_t block_size;    // 块大小
    size_t way_cnt;       // 路数
    size_t set_cnt;       // 组数
    size_t total_size;    // 总缓存大小
    uint32_t offset_mask; // 块内偏移掩码
    uint32_t index_mask;  // 组索引掩码
    uint8_t offset_bit;   // 偏移位宽
    uint8_t index_bit;    // 索引位宽
    cache_block_t **sets; // 二级指针：sets[组号][路号]定位缓存块
} cache_t;

2. 实现动态初始化函数模拟构造能力 #

C语言没有内置构造函数，通过自定义初始化工厂函数实现运行时参数生效、内存动态分配：

cache_t *cache_init(cache_type_t type, size_t block_size, size_t way_cnt, size_t total_size) {
    cache_t *cache = malloc(sizeof(cache_t));
    if (!cache) return NULL;

    // 填充基础参数
    cache->type = type;
    cache->block_size = block_size;
    cache->total_size = total_size;
    
    // 根据缓存类型修正路数/组数
    if (type == CACHE_DIRECT) {
        cache->way_cnt = 1;
        cache->set_cnt = total_size / block_size;
    } else if (type == CACHE_FULLY_ASSOC) {
        cache->way_cnt = total_size / block_size;
        cache->set_cnt = 1;
    } else { // n路组相联
        cache->way_cnt = way_cnt;
        cache->set_cnt = total_size / (block_size * way_cnt);
    }

    // 计算位宽和掩码，运行时计算替代预处理宏
    cache->offset_bit = __builtin_ctz(block_size);
    cache->offset_mask = block_size - 1;
    cache->index_bit = __builtin_ctz(cache->set_cnt);
    cache->index_mask = cache->set_cnt - 1;

    // 动态分配缓存组和块内存
    cache->sets = malloc(sizeof(cache_block_t*) * cache->set_cnt);
    for (int i = 0; i < cache->set_cnt; i++) {
        cache->sets[i] = calloc(cache->way_cnt, sizeof(cache_block_t)); // 初始valid/dirty都为0
    }
    return cache;
}

需要释放缓存时配套实现void cache_destroy(cache_t *cache)函数，按分配顺序反向释放内存即可。

3. 统一缓存操作接口 #

对外暴露通用的访问、刷新等接口，内部根据缓存类型调用对应处理逻辑，也可以把处理函数指针作为成员存在cache_t结构体中，初始化时绑定对应映射类型的处理函数，避免运行时分支判断损耗：

// 缓存访问接口，返回是否命中，同时处理命中/未命中逻辑
bool cache_access(cache_t *cache, uint64_t addr, bool is_write) {
    // 解析地址得到偏移、索引、tag
    uint64_t offset = addr & cache->offset_mask;
    uint64_t index = (addr >> cache->offset_bit) & cache->index_mask;
    uint64_t tag = addr >> (cache->offset_bit + cache->index_bit);

    cache_block_t *set = cache->sets[index];
    // 遍历对应组的所有路查找匹配块
    for (int i = 0; i < cache->way_cnt; i++) {
        if (set[i].valid && set[i].tag == tag) {
            // 命中逻辑，更新LRU时间戳、处理脏位
            set[i].last_access_ts = get_current_ts();
            if (is_write) set[i].dirty = 1;
            return true;
        }
    }
    // 未命中逻辑，调用对应替换策略换入块
    cache_replace(cache, index, tag, is_write);
    return false;
}

替换策略也可以做成可配置项，初始化时指定LRU、FIFO、RANDOM等策略即可。

4. 运行时参数传入方法 #

主函数接收命令行参数，解析得到缓存类型、块大小、路数、总大小等参数后，直接传入cache_init函数即可实现运行时动态配置，完全不需要修改代码重新编译。

内容的提问来源于stack exchange，提问作者Silver