16991469020

Committed 15 Aug 2025 01:54PM UTC coverage: 86.018% (-1.8%) from 87.855%

Build # 16991469020

Build Type

Pull #4215

github

Committed by

web-flow

Commit Message

Merge 58201b202 into 62e231a41

Pull Request Pull Request #4215: Ji/vectors

Run Details

90 of 1746 new or added lines in 40 files covered. (5.15%)

117 existing lines in 25 files now uncovered.

56661 of 65871 relevant lines covered (86.02%)

614266.74 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 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 < N / 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..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 bit_slice = self.bits.as_raw_mut_slice();	×
41
NEW 42	let mut word = 0;	×
NEW 43	let mut true_count = 0;	×
NEW 44	while len >= 64 {	×
NEW 45	true_count += bit_slice[word].count_ones() as usize;	×
NEW 46	len -= 64;	×
NEW 47	word += 1;	×
NEW 48	}	×
49
NEW 50	if len > 0 {	×
NEW 51	bit_slice[word] &= !(u64::MAX << len);	×
NEW 52	true_count += bit_slice[word].count_ones() as usize;	×
NEW 53	word += 1;	×
NEW 54	}	×
55
NEW 56	while word < N / 64 {	×
NEW 57	bit_slice[word] = 0;	×
NEW 58	word += 1;	×
NEW 59	}	×
60
NEW 61	self.set_true_count(true_count);	×
NEW 62	}	×
63
NEW 64	pub fn clear(&mut self) {	×
NEW 65	self.bits.as_raw_mut_slice().fill(0);	×
NEW 66	self.set_true_count(0);	×
NEW 67	}	×
68
NEW 69	pub fn fill_with_words(&mut self, mut iter: impl Iterator<Item = u64>) {	×
NEW 70	let mut true_count = 0;	×
NEW 71	for word in 0..N / 64 {	×
NEW 72	if let Some(value) = iter.next() {	×
NEW 73	self.bits.as_raw_mut_slice()[word] = value;	×
NEW 74	true_count += value.count_ones() as usize;	×
NEW 75	} else {	×
NEW 76	self.bits.as_raw_mut_slice()[word] = 0;	×
NEW 77	break;	×
78	}
79	}
NEW 80	self.set_true_count(true_count);	×
NEW 81	}	×
82
NEW 83	pub fn as_view(&self) -> BitView<'_> {	×
NEW 84	unsafe { BitView::new_unchecked(self.bits, self.true_count) }	×
NEW 85	}	×
86
NEW 87	pub fn as_raw_mut(&mut self) -> &mut [u64; N / 64] {	×
NEW 88	unsafe { std::mem::transmute(&mut self.bits) }	×
NEW 89	}	×
90
91	#[inline(always)]
NEW 92	fn set_true_count(&mut self, true_count: usize) {	×
NEW 93	self.true_count = true_count;	×
NEW 94	debug_assert_eq!(	×
95	self.true_count,
NEW 96	self.bits	×
NEW 97	.as_raw_slice()	×
NEW 98	.iter()	×
NEW 99	.map(\|&word\| word.count_ones() as usize)	×
NEW 100	.sum::<usize>()	×
101	);
NEW 102	}	×
103	}
104
105	#[cfg(test)]
106	mod tests {
107	use super::*;
108	use crate::pipeline::bits::BitVector;
109
110	#[test]
111	fn test_intersect_prefix() {
112	let mut bit_vec = BitVector::full().clone();
113
114	let mut view_mut = bit_vec.as_view_mut();
115	assert_eq!(view_mut.true_count(), N);
116
117	view_mut.intersect_prefix(N - 1);
118	assert_eq!(view_mut.true_count(), N - 1);
119
120	view_mut.intersect_prefix(64);
121	assert_eq!(view_mut.true_count(), 64);
122
123	view_mut.intersect_prefix(10);
124	assert_eq!(view_mut.true_count(), 10);
125
126	view_mut.intersect_prefix(0);
127	assert_eq!(view_mut.true_count(), 0);
128	}
129	}

vortex-data / vortex / 16991469020

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