Method write_n

crates/virtual-machine/src/memory/cache.rs:250–321

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

        // 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)?;
            if miss {
                self.stats.write_misses += 1;
            } else {
                self.stats.write_hits += 1;
            }
            let offset = (addr & ((1u64 << self.block_bits) - 1)) as usize;
            let bytes = data.to_le_bytes();
            self.sets[set_idx].ways[way_idx].data[offset..offset + n].copy_from_slice(&bytes[..n]);

            if self.params.write_back {
                self.sets[set_idx].ways[way_idx].dirty = true;
            } else {
                match n {
                    2 => self.next.write_halfword(addr, data as u16)?,
                    4 => self.next.write_word(addr, data as u32)?,
                    8 => self.next.write_doubleword(addr, data)?,
                    _ => {
                        for i in 0..n {
                            self.next.write_byte(addr + i as u64, bytes[i])?;
                        }
                    }
                }
            }
            return Ok(());
        }

        let block_mask = !((1u64 << self.block_bits) - 1);
        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.write_misses += 1;
                } else {
                    self.stats.write_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;
            let byte = ((data >> (i * 8)) & 0xFF) as u8;
            self.sets[set_idx].ways[way_idx].data[offset] = byte;

            if self.params.write_back {
                self.sets[set_idx].ways[way_idx].dirty = true;