Struct rustc_passes::liveness::RWUTable

pub(in liveness) struct RWUTable {
    packed_rwus: Vec<u32>,
    unpacked_rwus: Vec<RWU>,
}

Conceptually, this is like a Vec<RWU>. But the number of RWUs can get very large, so it uses a more compact representation that takes advantage of the fact that when the number of RWUs is large, most of them have an invalid reader and an invalid writer.

Fields

packed_rwus: Vec<u32>

Each entry in packed_rwus is either INV_INV_FALSE, INV_INV_TRUE, or an index into unpacked_rwus. In the common cases, this compacts the 65 bits of data into 32; in the uncommon cases, it expands the 65 bits in 96.

More compact representations are possible -- e.g., use only 2 bits per packed RWU and make the secondary table a HashMap that maps from indices to RWUs -- but this one strikes a good balance between size and speed.

unpacked_rwus: Vec<RWU>

Implementations

impl RWUTable

pub(in liveness) fn new(
    num_rwus: usize
) -> RWUTable

pub(in liveness) fn get(
    &self,
    idx: usize
) -> RWU

pub(in liveness) fn get_reader(
    &self,
    idx: usize
) -> Option<LiveNode>

pub(in liveness) fn get_writer(
    &self,
    idx: usize
) -> Option<LiveNode>

pub(in liveness) fn get_used(
    &self,
    idx: usize
) -> bool

pub(in liveness) fn copy_packed(
    &mut self,
    dst_idx: usize,
    src_idx: usize
)

pub(in liveness) fn assign_unpacked(
    &mut self,
    idx: usize,
    rwu: RWU
)

pub(in liveness) fn assign_inv_inv(
    &mut self,
    idx: usize
)