代码生成（实现写回策略的 Cache）

下面是一个简单的 C++ 代码实现，用于说明实现写回策略的 Cache 的基本思路：

#include <iostream>
#include <map>

using namespace std;

const int CACHE_SIZE = 4; // 缓存大小
const int BLOCK_SIZE = 4; // 缓存块大小
const int MEM_SIZE = 16; // 内存大小

class Cache {
public:
    Cache() {
        for (int i = 0; i < CACHE_SIZE; i++) {
            valid[i] = false;
            dirty[i] = false;
        }
    }

    int read(int address) {
        int blockNumber = address / BLOCK_SIZE;
        int blockOffset = address % BLOCK_SIZE;
        int cacheIndex = findCacheBlock(blockNumber);
        if (cacheIndex == -1) {
            cacheIndex = allocateCacheBlock(blockNumber);
        }
        return cache[cacheIndex][blockOffset];
    }

    void write(int address, int value) {
        int blockNumber = address / BLOCK_SIZE;
        int blockOffset = address % BLOCK_SIZE;
        int cacheIndex = findCacheBlock(blockNumber);
        if (cacheIndex == -1) {
            cacheIndex = allocateCacheBlock(blockNumber);
        }
        dirty[cacheIndex] = true;
        cache[cacheIndex][blockOffset] = value;
    }

    void flush() {
        for (int i = 0; i < CACHE_SIZE; i++) {
            if (valid[i] && dirty[i]) {
                int blockNumber = tag[i];
                for (int j = 0; j < BLOCK_SIZE; j++) {
                    int address = blockNumber * BLOCK_SIZE + j;
                    memory[address] = cache[i][j];
                }
            }
            valid[i] = false;
            dirty[i] = false;
        }
    }

private:
    int tag[CACHE_SIZE];
    bool valid[CACHE_SIZE];
    bool dirty[CACHE_SIZE];
    int cache[CACHE_SIZE][BLOCK_SIZE];
    int memory[MEM_SIZE];

    int findCacheBlock(int blockNumber) {
        for (int i = 0; i < CACHE_SIZE; i++) {
            if (valid[i] && tag[i] == blockNumber) {
                return i;
            }
        }
        return -1;
    }

    int allocateCacheBlock(int blockNumber) {
        int cacheIndex = evictCacheBlock();
        if (valid[cacheIndex] && dirty[cacheIndex]) {
            writeBack(cacheIndex);
        }
        valid[cacheIndex] = true;
        tag[cacheIndex] = blockNumber;
        for (int i = 0; i < BLOCK_SIZE; i++) {
            int address = blockNumber * BLOCK_SIZE + i;
            cache[cacheIndex][i] = memory[address];
        }
        return cacheIndex;
    }

    int evictCacheBlock() {
        for (int i = 0; i < CACHE_SIZE; i++) {
            if (!valid[i]) {
                return i;
            }
        }
        return 0;
    }

    void writeBack(int cacheIndex) {
        int blockNumber = tag[cacheIndex];
        for (int i = 0; i < BLOCK_SIZE; i++) {
            int address = blockNumber * BLOCK_SIZE + i;
            memory[address] = cache[cacheIndex][i];
        }
    }
};

int main() {
    Cache cache;
    cache.write(0, 10);
    cache.write(1, 20);
    cache.write(2, 30);
    cache.write(3, 40);
    cout << cache.read(0) << endl; // 10
    cout << cache.read(1) << endl; // 20
    cache.write(1, 25);
    cache.flush();
    cout << cache.read(1) << endl; // 25
    return 0;
}

在这个例子中，我们实现了一个 4 个缓存块大小的 Cache，每个缓存块大小为 4 字节。当 CPU 需要读取或写入一个地址时，Cache 会根据地址的块号和块内偏移量找到相应的缓存块，如果该缓存块已经在 Cache 中，则直接读取或写入缓存；否则，Cache 会将该缓存块从主存中读入到 Cache 中，并将该缓存块标记为有效的。在写入缓存时，Cache 会将该缓存块标记为脏块，表示该缓存块已被修改过，需要在替换该缓存块时将其写回主存。在写回所有脏块时，Cache 会检查每个脏块是否在 Cache 中，并将其写回主存。