17040114484

Committed 18 Aug 2025 12:07PM UTC coverage: 86.042% (-1.9%) from 87.913%

Build # 17040114484

Build Type

Pull #4215

github

Committed by

web-flow

Commit Message

Merge 4600ca5c4 into cb1a92920

Pull Request Pull Request #4215: Ji/vectors

Run Details

132 of 1817 new or added lines in 42 files covered. (7.26%)

125 existing lines in 26 files now uncovered.

56932 of 66168 relevant lines covered (86.04%)

611735.65 hits per line

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

0.0

/vortex-vector/src/bits/view_mut.rs

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

use bitvec::array::BitArray;
use bitvec::order::Lsb0;

use crate::PIPELINE_STEP_COUNT;
use crate::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; PIPELINE_STEP_COUNT / 64], Lsb0>,
    true_count: usize,
}

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

    pub(crate) unsafe fn new_unchecked(
        bits: &'a mut BitArray<[u64; PIPELINE_STEP_COUNT / 64], Lsb0>,
        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 <= PIPELINE_STEP_COUNT,
            "BitViewMut::truncate: length exceeds N"
        );

        let bit_slice = self.bits.as_raw_mut_slice();

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

        if len > 0 {
            bit_slice[word] &= !(u64::MAX << len);
            true_count += bit_slice[word].count_ones() as usize;
            word += 1;
        }

        while word < PIPELINE_STEP_COUNT / 64 {
            bit_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..PIPELINE_STEP_COUNT / 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; PIPELINE_STEP_COUNT / 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::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(), PIPELINE_STEP_COUNT);

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

vortex-data / vortex / 17040114484

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