16969983197

Committed 14 Aug 2025 03:45PM UTC coverage: 85.882% (-1.8%) from 87.693%

Build # 16969983197

Build Type

Pull #4215

github

Committed by

web-flow

Commit Message

Merge 6636736da into f547cbca5

Pull Request Pull Request #4215: Ji/vectors

Run Details

80 of 1729 new or added lines in 38 files covered. (4.63%)

117 existing lines in 25 files now uncovered.

56994 of 66363 relevant lines covered (85.88%)

609331.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/vortex-array/src/pipeline/bits/view_mut.rs

// SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: Copyright the Vortex contributors

use bitvec::array::BitArray;
use bitvec::order::Msb0;

use crate::pipeline::N;
use crate::pipeline::bits::BitView;

/// A mutable borrowed fixed-size bit vector of length `N` bits, represented as an array of
/// 64-bit words.
#[derive(Debug)]
pub struct BitViewMut<'a> {
    bits: &'a mut BitArray<[u64; N / 64], Msb0>,
    true_count: usize,
}

impl<'a> BitViewMut<'a> {
    pub fn new(bits: &'a mut [u64; N / 64]) -> Self {
        let true_count = bits.iter().map(|&word| word.count_ones() as usize).sum();
        let bits: &mut BitArray<[u64; N / 64], Msb0> = unsafe { std::mem::transmute(bits) };
        BitViewMut { bits, true_count }
    }

    pub(crate) unsafe fn new_unchecked(
        bits: &'a mut BitArray<[u64; N / 64], Msb0>,
        true_count: usize,
    ) -> Self {
        BitViewMut { bits, true_count }
    }

    pub fn true_count(&self) -> usize {
        self.true_count
    }

    /// Mask the values in the mask up to the given length.
    pub fn intersect_prefix(&mut self, mut len: usize) {
        assert!(len <= N, "BitViewMut::truncate: length exceeds N");

        let mut word = 0;
        let mut true_count = 0;
        while len >= 64 {
            true_count += self.bits.as_raw_mut_slice()[word].count_ones() as usize;
            len -= 64;
            word += 1;
        }

        if len > 0 {
            self.bits.as_raw_mut_slice()[word] &= u64::MAX << (64 - len);
            word += 1;
            true_count += self.bits.as_raw_mut_slice()[word - 1].count_ones() as usize;
        }

        while word < N / 64 {
            self.bits.as_raw_mut_slice()[word] = 0;
            word += 1;
        }

        self.set_true_count(true_count);
    }

    pub fn clear(&mut self) {
        self.bits.as_raw_mut_slice().fill(0);
        self.set_true_count(0);
    }

    pub fn fill_with_words(&mut self, mut iter: impl Iterator<Item = u64>) {
        let mut true_count = 0;
        for word in 0..N / 64 {
            if let Some(value) = iter.next() {
                self.bits.as_raw_mut_slice()[word] = value;
                true_count += value.count_ones() as usize;
            } else {
                self.bits.as_raw_mut_slice()[word] = 0;
                break;
            }
        }
        self.set_true_count(true_count);
    }

    pub fn as_view(&self) -> BitView<'_> {
        unsafe { BitView::new_unchecked(self.bits, self.true_count) }
    }

    pub fn as_raw_mut(&mut self) -> &mut [u64; N / 64] {
        unsafe { std::mem::transmute(&mut self.bits) }
    }

    #[inline(always)]
    fn set_true_count(&mut self, true_count: usize) {
        self.true_count = true_count;
        debug_assert_eq!(
            self.true_count,
            self.bits
                .as_raw_slice()
                .iter()
                .map(|&word| word.count_ones() as usize)
                .sum::<usize>()
        );
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::pipeline::bits::BitVector;

    #[test]
    fn test_intersect_prefix() {
        let mut bit_vec = BitVector::full().clone();

        let mut view_mut = bit_vec.as_view_mut();
        assert_eq!(view_mut.true_count(), N);

        view_mut.intersect_prefix(N - 1);
        assert_eq!(view_mut.true_count(), N - 1);

        view_mut.intersect_prefix(64);
        assert_eq!(view_mut.true_count(), 64);

        view_mut.intersect_prefix(10);
        assert_eq!(view_mut.true_count(), 10);

        view_mut.intersect_prefix(0);
        assert_eq!(view_mut.true_count(), 0);
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use bitvec::array::BitArray;
5	use bitvec::order::Msb0;
6
7	use crate::pipeline::N;
8	use crate::pipeline::bits::BitView;
9
10	/// A mutable borrowed fixed-size bit vector of length `N` bits, represented as an array of
11	/// 64-bit words.
12	#[derive(Debug)]
13	pub struct BitViewMut<'a> {
14	bits: &'a mut BitArray<[u64; N / 64], Msb0>,
15	true_count: usize,
16	}
17
18	impl<'a> BitViewMut<'a> {
NEW 19	pub fn new(bits: &'a mut [u64; N / 64]) -> Self {	×
NEW 20	let true_count = bits.iter().map(\|&word\| word.count_ones() as usize).sum();	×
NEW 21	let bits: &mut BitArray<[u64; N / 64], Msb0> = unsafe { std::mem::transmute(bits) };	×
NEW 22	BitViewMut { bits, true_count }	×
NEW 23	}	×
24
NEW 25	pub(crate) unsafe fn new_unchecked(	×
NEW 26	bits: &'a mut BitArray<[u64; N / 64], Msb0>,	×
NEW 27	true_count: usize,	×
NEW 28	) -> Self {	×
NEW 29	BitViewMut { bits, true_count }	×
NEW 30	}	×
31
NEW 32	pub fn true_count(&self) -> usize {	×
NEW 33	self.true_count	×
NEW 34	}	×
35
36	/// Mask the values in the mask up to the given length.
NEW 37	pub fn intersect_prefix(&mut self, mut len: usize) {	×
NEW 38	assert!(len <= N, "BitViewMut::truncate: length exceeds N");	×
39
NEW 40	let mut word = 0;	×
NEW 41	let mut true_count = 0;	×
NEW 42	while len >= 64 {	×
NEW 43	true_count += self.bits.as_raw_mut_slice()[word].count_ones() as usize;	×
NEW 44	len -= 64;	×
NEW 45	word += 1;	×
NEW 46	}	×
47
NEW 48	if len > 0 {	×
NEW 49	self.bits.as_raw_mut_slice()[word] &= u64::MAX << (64 - len);	×
NEW 50	word += 1;	×
NEW 51	true_count += self.bits.as_raw_mut_slice()[word - 1].count_ones() as usize;	×
NEW 52	}	×
53
NEW 54	while word < N / 64 {	×
NEW 55	self.bits.as_raw_mut_slice()[word] = 0;	×
NEW 56	word += 1;	×
NEW 57	}	×
58
NEW 59	self.set_true_count(true_count);	×
NEW 60	}	×
61
NEW 62	pub fn clear(&mut self) {	×
NEW 63	self.bits.as_raw_mut_slice().fill(0);	×
NEW 64	self.set_true_count(0);	×
NEW 65	}	×
66
NEW 67	pub fn fill_with_words(&mut self, mut iter: impl Iterator<Item = u64>) {	×
NEW 68	let mut true_count = 0;	×
NEW 69	for word in 0..N / 64 {	×
NEW 70	if let Some(value) = iter.next() {	×
NEW 71	self.bits.as_raw_mut_slice()[word] = value;	×
NEW 72	true_count += value.count_ones() as usize;	×
NEW 73	} else {	×
NEW 74	self.bits.as_raw_mut_slice()[word] = 0;	×
NEW 75	break;	×
76	}
77	}
NEW 78	self.set_true_count(true_count);	×
NEW 79	}	×
80
NEW 81	pub fn as_view(&self) -> BitView<'_> {	×
NEW 82	unsafe { BitView::new_unchecked(self.bits, self.true_count) }	×
NEW 83	}	×
84
NEW 85	pub fn as_raw_mut(&mut self) -> &mut [u64; N / 64] {	×
NEW 86	unsafe { std::mem::transmute(&mut self.bits) }	×
NEW 87	}	×
88
89	#[inline(always)]
NEW 90	fn set_true_count(&mut self, true_count: usize) {	×
NEW 91	self.true_count = true_count;	×
NEW 92	debug_assert_eq!(	×
93	self.true_count,
NEW 94	self.bits	×
NEW 95	.as_raw_slice()	×
NEW 96	.iter()	×
NEW 97	.map(\|&word\| word.count_ones() as usize)	×
NEW 98	.sum::<usize>()	×
99	);
NEW 100	}	×
101	}
102
103	#[cfg(test)]
104	mod tests {
105	use super::*;
106	use crate::pipeline::bits::BitVector;
107
108	#[test]
109	fn test_intersect_prefix() {
110	let mut bit_vec = BitVector::full().clone();
111
112	let mut view_mut = bit_vec.as_view_mut();
113	assert_eq!(view_mut.true_count(), N);
114
115	view_mut.intersect_prefix(N - 1);
116	assert_eq!(view_mut.true_count(), N - 1);
117
118	view_mut.intersect_prefix(64);
119	assert_eq!(view_mut.true_count(), 64);
120
121	view_mut.intersect_prefix(10);
122	assert_eq!(view_mut.true_count(), 10);
123
124	view_mut.intersect_prefix(0);
125	assert_eq!(view_mut.true_count(), 0);
126	}
127	}

vortex-data / vortex / 16969983197

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous