Method dump_gap_interference

src/internal/allocator/split.rs:541–578

Prints the maximum spill weight of interference that needs to be evicted from a virtual register in order to allocate each gap.

(
        reg: PhysReg,
        splitter: &Splitter,
        reg_matrix: &RegMatrix,
        virt_regs: &VirtRegs,
        reginfo: &impl RegInfo,
    )

    /// Prints the maximum spill weight of interference that needs to be
    /// evicted from a virtual register in order to allocate each gap.
    fn dump_gap_interference(
        reg: PhysReg,
        splitter: &Splitter,
        reg_matrix: &RegMatrix,
        virt_regs: &VirtRegs,
        reginfo: &impl RegInfo,
    ) {
        if !trace_enabled!() {
            return;
        }

        let mut gap_interference_weights = vec![0.0; splitter.gaps.len()];

        _ = reg_matrix.check_interference(
            &splitter.gap_segments,
            reg,
            reginfo,
            &mut Default::default(),
            true,
            |interference| {
                // Fixed interference has a infinite spill weight since it cannot be
                // evicted.
                let weight = match interference.kind {
                    InterferenceKind::Fixed => f32::INFINITY,
                    InterferenceKind::VirtReg(virt_reg) => virt_regs[virt_reg].spill_weight,
                };
                let gap_interference_weight =
                    &mut gap_interference_weights[interference.segment.gap_idx as usize];
                *gap_interference_weight = weight.max(*gap_interference_weight);
                ControlFlow::<()>::Continue(())
            },
        );

        trace!("Gap interference for {reg}:");
        for (idx, weight) in gap_interference_weights.iter().enumerate() {
            trace!("  {idx}: {weight}");
        }
    }

    /// Builds a proposed split region starting from the best use that is small
    /// enough to evict any interference in the given physical register.