cache写策略伪代码

以下是一个基于LRU（最近最少使用）算法的cache写策略伪代码：

class Cache:
    def __init__(self, size):
        self.size = size
        self.cache = {}
        self.keys = []

    def set(self, key, value):
        if key in self.cache:
            self.keys.remove(key)
        elif len(self.cache) >= self.size:
            del self.cache[self.keys.pop(0)]
        self.cache[key] = value
        self.keys.append(key)

当写入一个新的键值对时，如果该键已经存在于cache中，则将其移动到最近使用的位置。如果cache已满，则删除最近最少使用的键值对。

相关问题

写一个cache模拟器的代码

以下是一个简单的cache模拟器的代码示例，仅供参考：

#include <iostream>
#include <vector>
using namespace std;

// 定义Cache块的结构体
struct CacheBlock {
    bool valid;     // 有效位
    int tag;        // 标记位
    int data;       // 数据
};

// 定义Cache结构体
struct Cache {
    int size;           // Cache总大小（字节）
    int block_size;     // 块大小（字节）
    int num_blocks;     // 块数
    int num_sets;       // 组数
    int blocks_per_set; // 每组块数
    vector<vector<CacheBlock>> sets; // Cache组
};

// 初始化Cache
void init_cache(Cache& cache) {
    // 计算块数和组数
    cache.num_blocks = cache.size / cache.block_size;
    cache.blocks_per_set = cache.num_blocks / cache.num_sets;
    // 初始化Cache组
    cache.sets.resize(cache.num_sets);
    for (int i = 0; i < cache.num_sets; i++) {
        cache.sets[i].resize(cache.blocks_per_set);
        for (int j = 0; j < cache.blocks_per_set; j++) {
            cache.sets[i][j].valid = false;
            cache.sets[i][j].tag = -1;
            cache.sets[i][j].data = 0;
        }
    }
}

// 读取Cache
bool read_cache(Cache& cache, int address) {
    int tag = address / cache.block_size;
    int set_index = tag % cache.num_sets;
    int block_offset = address % cache.block_size;
    // 查找Cache组
    for (int i = 0; i < cache.blocks_per_set; i++) {
        if (cache.sets[set_index][i].valid && cache.sets[set_index][i].tag == tag) {
            // 命中
            cout << "Cache hit: " << address << endl;
            return true;
        }
    }
    // 未命中，更新Cache
    cout << "Cache miss: " << address << endl;
    int block_index = -1;
    for (int i = 0; i < cache.blocks_per_set; i++) {
        if (!cache.sets[set_index][i].valid) {
            // 有空闲块
            block_index = i;
            break;
        }
    }
    if (block_index == -1) {
        // 没有空闲块，使用LRU替换
        block_index = 0;
        for (int i = 1; i < cache.blocks_per_set; i++) {
            if (cache.sets[set_index][i].valid && cache.sets[set_index][i].data < cache.sets[set_index][block_index].data) {
                block_index = i;
            }
        }
    }
    // 更新Cache块
    cache.sets[set_index][block_index].valid = true;
    cache.sets[set_index][block_index].tag = tag;
    cache.sets[set_index][block_index].data = 0; // TODO: 从主存中读取数据
    return false;
}

int main() {
    // 初始化Cache
    Cache cache;
    cache.size = 1024;
    cache.block_size = 32;
    cache.num_sets = 4;
    init_cache(cache);
    // 访问Cache
    read_cache(cache, 0x100);
    read_cache(cache, 0x200);
    read_cache(cache, 0x300);
    read_cache(cache, 0x110);
    read_cache(cache, 0x120);
    read_cache(cache, 0x130);
    return 0;
}

这个示例实现了一个简单的直接映射Cache模拟器，使用LRU替换策略。实际应用中，可以根据需要进行扩展和优化。

写出一个cache的代码

好的，以下是一个简单的cache实现的代码：

class Cache:
    def __init__(self, capacity):
        self.capacity = capacity
        self.cache = {}
        self.queue = []

    def get(self, key):
        if key in self.cache:
            self.queue.remove(key)
            self.queue.insert(0, key)
            return self.cache[key]
        else:
            return None

    def put(self, key, value):
        if key in self.cache:
            self.queue.remove(key)
        elif len(self.cache) >= self.capacity:
            evicted_key = self.queue.pop()
            del self.cache[evicted_key]
        self.cache[key] = value
        self.queue.insert(0, key)

这个cache实现了基本的get和put操作，并且使用了一个队列来记录最近使用的key，当cache满时，会将最久未使用的key从cache中删除。