src/librustc_data_structures/bitvec.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 use std::iter::FromIterator;
  12
  13 /// A very simple BitVector type.
  14 #[derive(Clone, Debug, PartialEq)]
  15 pub struct BitVector {
  16     data: Vec<u64>,
  17 }
  18
  19 impl BitVector {
  20     pub fn new(num_bits: usize) -> BitVector {
  21         let num_words = u64s(num_bits);
  22         BitVector { data: vec![0; num_words] }
  23     }
  24
  25     pub fn clear(&mut self) {
  26         for p in &mut self.data {
  27             *p = 0;
  28         }
  29     }
  30
  31     pub fn contains(&self, bit: usize) -> bool {
  32         let (word, mask) = word_mask(bit);
  33         (self.data[word] & mask) != 0
  34     }
  35
  36     /// Returns true if the bit has changed.
  37     pub fn insert(&mut self, bit: usize) -> bool {
  38         let (word, mask) = word_mask(bit);
  39         let data = &mut self.data[word];
  40         let value = *data;
  41         let new_value = value | mask;
  42         *data = new_value;
  43         new_value != value
  44     }
  45
  46     pub fn insert_all(&mut self, all: &BitVector) -> bool {
  47         assert!(self.data.len() == all.data.len());
  48         let mut changed = false;
  49         for (i, j) in self.data.iter_mut().zip(&all.data) {
  50             let value = *i;
  51             *i = value | *j;
  52             if value != *i {
  53                 changed = true;
  54             }
  55         }
  56         changed
  57     }
  58
  59     pub fn grow(&mut self, num_bits: usize) {
  60         let num_words = u64s(num_bits);
  61         if self.data.len() < num_words {
  62             self.data.resize(num_words, 0)
  63         }
  64     }
  65
  66     /// Iterates over indexes of set bits in a sorted order
  67     pub fn iter<'a>(&'a self) -> BitVectorIter<'a> {
  68         BitVectorIter {
  69             iter: self.data.iter(),
  70             current: 0,
  71             idx: 0,
  72         }
  73     }
  74 }
  75
  76 pub struct BitVectorIter<'a> {
  77     iter: ::std::slice::Iter<'a, u64>,
  78     current: u64,
  79     idx: usize,
  80 }
  81
  82 impl<'a> Iterator for BitVectorIter<'a> {
  83     type Item = usize;
  84     fn next(&mut self) -> Option<usize> {
  85         while self.current == 0 {
  86             self.current = if let Some(&i) = self.iter.next() {
  87                 if i == 0 {
  88                     self.idx += 64;
  89                     continue;
  90                 } else {
  91                     self.idx = u64s(self.idx) * 64;
  92                     i
  93                 }
  94             } else {
  95                 return None;
  96             }
  97         }
  98         let offset = self.current.trailing_zeros() as usize;
  99         self.current >>= offset;
 100         self.current >>= 1; // shift otherwise overflows for 0b1000_0000_…_0000
 101         self.idx += offset + 1;
 102         return Some(self.idx - 1);
 103     }
 104 }
 105
 106 impl FromIterator<bool> for BitVector {
 107     fn from_iter<I>(iter: I) -> BitVector where I: IntoIterator<Item=bool> {
 108         let iter = iter.into_iter();
 109         let (len, _) = iter.size_hint();
 110         // Make the minimum length for the bitvector 64 bits since that's
 111         // the smallest non-zero size anyway.
 112         let len = if len < 64 { 64 } else { len };
 113         let mut bv = BitVector::new(len);
 114         for (idx, val) in iter.enumerate() {
 115             if idx > len {
 116                 bv.grow(idx);
 117             }
 118             if val {
 119                 bv.insert(idx);
 120             }
 121         }
 122
 123         bv
 124     }
 125 }
 126
 127 /// A "bit matrix" is basically a matrix of booleans represented as
 128 /// one gigantic bitvector. In other words, it is as if you have
 129 /// `rows` bitvectors, each of length `columns`.
 130 #[derive(Clone)]
 131 pub struct BitMatrix {
 132     columns: usize,
 133     vector: Vec<u64>,
 134 }
 135
 136 impl BitMatrix {
 137     // Create a new `rows x columns` matrix, initially empty.
 138     pub fn new(rows: usize, columns: usize) -> BitMatrix {
 139         // For every element, we need one bit for every other
 140         // element. Round up to an even number of u64s.
 141         let u64s_per_row = u64s(columns);
 142         BitMatrix {
 143             columns: columns,
 144             vector: vec![0; rows * u64s_per_row],
 145         }
 146     }
 147
 148     /// The range of bits for a given row.
 149     fn range(&self, row: usize) -> (usize, usize) {
 150         let u64s_per_row = u64s(self.columns);
 151         let start = row * u64s_per_row;
 152         (start, start + u64s_per_row)
 153     }
 154
 155     pub fn add(&mut self, source: usize, target: usize) -> bool {
 156         let (start, _) = self.range(source);
 157         let (word, mask) = word_mask(target);
 158         let mut vector = &mut self.vector[..];
 159         let v1 = vector[start + word];
 160         let v2 = v1 | mask;
 161         vector[start + word] = v2;
 162         v1 != v2
 163     }
 164
 165     /// Do the bits from `source` contain `target`?
 166     ///
 167     /// Put another way, if the matrix represents (transitive)
 168     /// reachability, can `source` reach `target`?
 169     pub fn contains(&self, source: usize, target: usize) -> bool {
 170         let (start, _) = self.range(source);
 171         let (word, mask) = word_mask(target);
 172         (self.vector[start + word] & mask) != 0
 173     }
 174
 175     /// Returns those indices that are reachable from both `a` and
 176     /// `b`. This is an O(n) operation where `n` is the number of
 177     /// elements (somewhat independent from the actual size of the
 178     /// intersection, in particular).
 179     pub fn intersection(&self, a: usize, b: usize) -> Vec<usize> {
 180         let (a_start, a_end) = self.range(a);
 181         let (b_start, b_end) = self.range(b);
 182         let mut result = Vec::with_capacity(self.columns);
 183         for (base, (i, j)) in (a_start..a_end).zip(b_start..b_end).enumerate() {
 184             let mut v = self.vector[i] & self.vector[j];
 185             for bit in 0..64 {
 186                 if v == 0 {
 187                     break;
 188                 }
 189                 if v & 0x1 != 0 {
 190                     result.push(base * 64 + bit);
 191                 }
 192                 v >>= 1;
 193             }
 194         }
 195         result
 196     }
 197
 198     /// Add the bits from `read` to the bits from `write`,
 199     /// return true if anything changed.
 200     ///
 201     /// This is used when computing transitive reachability because if
 202     /// you have an edge `write -> read`, because in that case
 203     /// `write` can reach everything that `read` can (and
 204     /// potentially more).
 205     pub fn merge(&mut self, read: usize, write: usize) -> bool {
 206         let (read_start, read_end) = self.range(read);
 207         let (write_start, write_end) = self.range(write);
 208         let vector = &mut self.vector[..];
 209         let mut changed = false;
 210         for (read_index, write_index) in (read_start..read_end).zip(write_start..write_end) {
 211             let v1 = vector[write_index];
 212             let v2 = v1 | vector[read_index];
 213             vector[write_index] = v2;
 214             changed = changed | (v1 != v2);
 215         }
 216         changed
 217     }
 218
 219     pub fn iter<'a>(&'a self, row: usize) -> BitVectorIter<'a> {
 220         let (start, end) = self.range(row);
 221         BitVectorIter {
 222             iter: self.vector[start..end].iter(),
 223             current: 0,
 224             idx: 0,
 225         }
 226     }
 227 }
 228
 229 fn u64s(elements: usize) -> usize {
 230     (elements + 63) / 64
 231 }
 232
 233 fn word_mask(index: usize) -> (usize, u64) {
 234     let word = index / 64;
 235     let mask = 1 << (index % 64);
 236     (word, mask)
 237 }
 238
 239 #[test]
 240 fn bitvec_iter_works() {
 241     let mut bitvec = BitVector::new(100);
 242     bitvec.insert(1);
 243     bitvec.insert(10);
 244     bitvec.insert(19);
 245     bitvec.insert(62);
 246     bitvec.insert(63);
 247     bitvec.insert(64);
 248     bitvec.insert(65);
 249     bitvec.insert(66);
 250     bitvec.insert(99);
 251     assert_eq!(bitvec.iter().collect::<Vec<_>>(),
 252                [1, 10, 19, 62, 63, 64, 65, 66, 99]);
 253 }
 254
 255
 256 #[test]
 257 fn bitvec_iter_works_2() {
 258     let mut bitvec = BitVector::new(319);
 259     bitvec.insert(0);
 260     bitvec.insert(127);
 261     bitvec.insert(191);
 262     bitvec.insert(255);
 263     bitvec.insert(319);
 264     assert_eq!(bitvec.iter().collect::<Vec<_>>(), [0, 127, 191, 255, 319]);
 265 }
 266
 267 #[test]
 268 fn union_two_vecs() {
 269     let mut vec1 = BitVector::new(65);
 270     let mut vec2 = BitVector::new(65);
 271     assert!(vec1.insert(3));
 272     assert!(!vec1.insert(3));
 273     assert!(vec2.insert(5));
 274     assert!(vec2.insert(64));
 275     assert!(vec1.insert_all(&vec2));
 276     assert!(!vec1.insert_all(&vec2));
 277     assert!(vec1.contains(3));
 278     assert!(!vec1.contains(4));
 279     assert!(vec1.contains(5));
 280     assert!(!vec1.contains(63));
 281     assert!(vec1.contains(64));
 282 }
 283
 284 #[test]
 285 fn grow() {
 286     let mut vec1 = BitVector::new(65);
 287     for index in 0 .. 65 {
 288         assert!(vec1.insert(index));
 289         assert!(!vec1.insert(index));
 290     }
 291     vec1.grow(128);
 292
 293     // Check if the bits set before growing are still set
 294     for index in 0 .. 65 {
 295         assert!(vec1.contains(index));
 296     }
 297
 298     // Check if the new bits are all un-set
 299     for index in 65 .. 128 {
 300         assert!(!vec1.contains(index));
 301     }
 302
 303     // Check that we can set all new bits without running out of bounds
 304     for index in 65 .. 128 {
 305         assert!(vec1.insert(index));
 306         assert!(!vec1.insert(index));
 307     }
 308 }
 309
 310 #[test]
 311 fn matrix_intersection() {
 312     let mut vec1 = BitMatrix::new(200, 200);
 313
 314     // (*) Elements reachable from both 2 and 65.
 315
 316     vec1.add(2, 3);
 317     vec1.add(2, 6);
 318     vec1.add(2, 10); // (*)
 319     vec1.add(2, 64); // (*)
 320     vec1.add(2, 65);
 321     vec1.add(2, 130);
 322     vec1.add(2, 160); // (*)
 323
 324     vec1.add(64, 133);
 325
 326     vec1.add(65, 2);
 327     vec1.add(65, 8);
 328     vec1.add(65, 10); // (*)
 329     vec1.add(65, 64); // (*)
 330     vec1.add(65, 68);
 331     vec1.add(65, 133);
 332     vec1.add(65, 160); // (*)
 333
 334     let intersection = vec1.intersection(2, 64);
 335     assert!(intersection.is_empty());
 336
 337     let intersection = vec1.intersection(2, 65);
 338     assert_eq!(intersection, &[10, 64, 160]);
 339 }
 340
 341 #[test]
 342 fn matrix_iter() {
 343     let mut matrix = BitMatrix::new(64, 100);
 344     matrix.add(3, 22);
 345     matrix.add(3, 75);
 346     matrix.add(2, 99);
 347     matrix.add(4, 0);
 348     matrix.merge(3, 5);
 349
 350     let expected = [99];
 351     let mut iter = expected.iter();
 352     for i in matrix.iter(2) {
 353         let j = *iter.next().unwrap();
 354         assert_eq!(i, j);
 355     }
 356     assert!(iter.next().is_none());
 357
 358     let expected = [22, 75];
 359     let mut iter = expected.iter();
 360     for i in matrix.iter(3) {
 361         let j = *iter.next().unwrap();
 362         assert_eq!(i, j);
 363     }
 364     assert!(iter.next().is_none());
 365
 366     let expected = [0];
 367     let mut iter = expected.iter();
 368     for i in matrix.iter(4) {
 369         let j = *iter.next().unwrap();
 370         assert_eq!(i, j);
 371     }
 372     assert!(iter.next().is_none());
 373
 374     let expected = [22, 75];
 375     let mut iter = expected.iter();
 376     for i in matrix.iter(5) {
 377         let j = *iter.next().unwrap();
 378         assert_eq!(i, j);
 379     }
 380     assert!(iter.next().is_none());
 381 }