写一个cache模拟器，模拟cache不同配置下的命中率。

以下是一个简单的Cache模拟器，可以模拟Cache不同配置下的命中率：

class CacheSimulator:
    def __init__(self, cache_size, block_size, associativity):
        self.cache_size = cache_size
        self.block_size = block_size
        self.associativity = associativity
        self.num_blocks = cache_size // block_size
        self.num_sets = self.num_blocks // associativity
        self.tag_array = [[None for _ in range(associativity)] for _ in range(self.num_sets)]
        self.valid_array = [[0 for _ in range(associativity)] for _ in range(self.num_sets)]
        self.lru_array = [[0 for _ in range(associativity)] for _ in range(self.num_sets)]
        self.hits = 0
        self.misses = 0

    def access(self, address):
        tag, index, offset = self.split_address(address)
        for i in range(self.associativity):
            if self.tag_array[index][i] == tag and self.valid_array[index][i] == 1:
                self.hits += 1
                self.update_lru(index, i)
                return
        self.misses += 1
        for i in range(self.associativity):
            if self.valid_array[index][i] == 0:
                self.tag_array[index][i] = tag
                self.valid_array[index][i] = 1
                self.update_lru(index, i)
                return
        lru_index = self.get_lru_index(index)
        self.tag_array[index][lru_index] = tag
        self.update_lru(index, lru_index)

    def split_address(self, address):
        offset_bits = int(math.log(self.block_size, 2))
        index_bits = int(math.log(self.num_sets, 2))
        tag_bits = 32 - offset_bits - index_bits
        offset = address & (self.block_size - 1)
        index = (address >> offset_bits) & (self.num_sets - 1)
        tag = address >> (offset_bits + index_bits)
        return tag, index, offset

    def update_lru(self, index, way):
        for i in range(self.associativity):
            if self.lru_array[index][i] < self.lru_array[index][way]:
                self.lru_array[index][i] += 1
        self.lru_array[index][way] = 0

    def get_lru_index(self, index):
        max_lru = max(self.lru_array[index])
        for i in range(self.associativity):
            if self.lru_array[index][i] == max_lru:
                return i

    def print_stats(self):
        total_accesses = self.hits + self.misses
        hit_rate = self.hits / total_accesses * 100
        miss_rate = self.misses / total_accesses * 100
        print(f"Cache size: {self.cache_size}")
        print(f"Block size: {self.block_size}")
        print(f"Associativity: {self.associativity}")
        print(f"Total accesses: {total_accesses}")
        print(f"Hits: {self.hits} ({hit_rate:.2f}%)")
        print(f"Misses: {self.misses} ({miss_rate:.2f}%)")

cache_sizes = [1024, 2048, 4096]
block_sizes = [16, 32, 64]
associativities = [1, 2, 4]

for cache_size in cache_sizes:
    for block_size in block_sizes:
        for associativity in associativities:
            cache = CacheSimulator(cache_size, block_size, associativity)
            # simulate cache accesses with different workloads
            # ...
            cache.print_stats()

在上面的代码中，`CacheSimulator` 类实现了一个 Cache 模拟器，其中 `cache_size`、`block_size`、`associativity` 分别表示 Cache 的大小、块大小和关联度。模拟器使用一个二维数组 `tag_array` 存储缓存中的标记信息，使用一个二维数组 `valid_array` 存储缓存中的有效位信息，使用一个二维数组 `lru_array` 存储缓存中的 LRU 信息。`access` 方法用于模拟 Cache 的读写操作，`split_address` 方法用于将地址分解为标记、索引和偏移量，`update_lru` 方法用于更新 LRU 信息，`get_lru_index` 方法用于获取 LRU 最大的块的索引。最后，`print_stats` 方法用于打印统计信息。

在上面的代码中，我们可以使用三重循环来模拟不同的 Cache 配置，然后调用 `CacheSimulator` 类的方法来模拟 Cache 的读写操作，并打印统计信息。在实际应用中，我们需要根据实际情况选择不同的工作负载数据集，以模拟不同的应用场景。