Method read_n

crates/virtual-machine/src/memory/cache.rs:202–248

(&mut self, addr: u64, n: usize)

            let (set_idx, way_idx, miss) = self.resolve_line(addr)?;
            if miss {
                self.stats.read_misses += 1;
            } else {
                self.stats.read_hits += 1;
            }
            let offset = (addr & ((1u64 << self.block_bits) - 1)) as usize;
            let mut buf = [0u8; 8];
            buf[..n].copy_from_slice(&self.sets[set_idx].ways[way_idx].data[offset..offset + n]);
            return Ok(u64::from_le_bytes(buf));
        }

        let block_mask = !((1u64 << self.block_bits) - 1);
        let mut result = 0u64;
        let mut last_block = u64::MAX;
        let mut last_set = 0usize;
        let mut last_way = 0usize;

        for i in 0..n {
            let byte_addr = addr + i as u64;
            let block = byte_addr & block_mask;

            let (set_idx, way_idx) = if block != last_block {
                let (si, wi, miss) = self.resolve_line(byte_addr)?;
                if miss {
                    self.stats.read_misses += 1;
                } else {
                    self.stats.read_hits += 1;
                }
                last_block = block;
                last_set = si;
                last_way = wi;
                (si, wi)
            } else {
                (last_set, last_way)
            };

            let offset = (byte_addr & !block_mask) as usize;
            result |= (self.sets[set_idx].ways[way_idx].data[offset] as u64) << (i * 8);
        }
        Ok(result)
    }

    fn write_n(&mut self, addr: u64, data: u64, n: usize) -> Result<(), VmError> {
        if self.params.read_only {
            return Err(VmError::WriteToRom);
        }

        // Aligned 2/4/8-byte writes stay inside one line: resolve once and, when
        // write-through, issue one sized store instead of a write_byte per byte.
        if n > 1 && addr & (n as u64 - 1) == 0 {
            let (set_idx, way_idx, miss) = self.resolve_line(addr)?;