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/buffers.rs

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

use std::hash::{Hash, Hasher};
use std::ops::Deref;
use std::sync::atomic::AtomicUsize;
use std::task::{Poll, ready};

use vortex_buffer::Buffer;
use vortex_error::{VortexResult, vortex_panic};

use crate::pipeline::KernelContext;

static NEXT_ID: AtomicUsize = AtomicUsize::new(0);

#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
pub struct BufferId(usize);

impl Default for BufferId {
    fn default() -> Self {
        Self::new()
    }
}

impl BufferId {
    /// Creates a new `BufferId` with a unique identifier.
    pub fn new() -> Self {
        BufferId(NEXT_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed))
    }
}

impl Deref for BufferId {
    type Target = usize;

    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

/// Wrapper for managed buffer access with automatic caching
#[derive(Debug, Clone)]
pub enum BufferHandle<T> {
    Pending(BufferId),
    Ready(Buffer<T>),
}

impl<T> Hash for BufferHandle<T> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        match self {
            BufferHandle::Pending(id) => id.hash(state),
            BufferHandle::Ready(buffer) => buffer.as_ptr().hash(state),
        }
    }
}

impl<T> PartialEq for BufferHandle<T> {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (BufferHandle::Pending(id1), BufferHandle::Pending(id2)) => id1 == id2,
            (BufferHandle::Ready(buf1), BufferHandle::Ready(buf2)) => {
                buf1.as_ptr() == buf2.as_ptr()
            }
            _ => false,
        }
    }
}

impl<T> BufferHandle<T> {
    pub fn new(buffer: Buffer<T>) -> Self {
        BufferHandle::Ready(buffer)
    }

    pub fn new_pending(id: BufferId) -> Self {
        BufferHandle::Pending(id)
    }

    pub fn into_typed<S>(self) -> BufferHandle<S> {
        match self {
            BufferHandle::Ready(buffer) => {
                BufferHandle::Ready(Buffer::<S>::from_byte_buffer(buffer.into_byte_buffer()))
            }
            BufferHandle::Pending(id) => BufferHandle::Pending(id),
        }
    }

    pub fn buffer(self) -> Option<Buffer<T>> {
        match self {
            BufferHandle::Ready(buffer) => Some(buffer),
            BufferHandle::Pending(_) => None,
        }
    }

    pub fn get_or_load(&mut self, ctx: &dyn KernelContext) -> Poll<VortexResult<&Buffer<T>>> {
        if let BufferHandle::Ready(buffer) = self {
            return Poll::Ready(Ok(buffer));
        }

        let buffer_id = match self {
            BufferHandle::Pending(id) => *id,
            BufferHandle::Ready(_) => unreachable!("BufferHandle should not be ready here"),
        };
        let buffer = ready!(ctx.buffer(buffer_id))?;
        *self = BufferHandle::Ready(Buffer::<T>::from_byte_buffer(buffer));

        if let BufferHandle::Ready(buffer) = self {
            Poll::Ready(Ok(buffer))
        } else {
            vortex_panic!("BufferHandle should be ready after loading");
        }
    }
}

1	// SPDX-License-Identifier: Apache-2.0
2	// SPDX-FileCopyrightText: Copyright the Vortex contributors
3
4	use std::hash::{Hash, Hasher};
5	use std::ops::Deref;
6	use std::sync::atomic::AtomicUsize;
7	use std::task::{Poll, ready};
8
9	use vortex_buffer::Buffer;
10	use vortex_error::{VortexResult, vortex_panic};
11
12	use crate::pipeline::KernelContext;
13
14	static NEXT_ID: AtomicUsize = AtomicUsize::new(0);
15
16	#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
17	pub struct BufferId(usize);
18
19	impl Default for BufferId {
NEW 20	fn default() -> Self {	×
NEW 21	Self::new()	×
NEW 22	}	×
23	}
24
25	impl BufferId {
26	/// Creates a new `BufferId` with a unique identifier.
NEW 27	pub fn new() -> Self {	×
NEW 28	BufferId(NEXT_ID.fetch_add(1, std::sync::atomic::Ordering::Relaxed))	×
NEW 29	}	×
30	}
31
32	impl Deref for BufferId {
33	type Target = usize;
34
NEW 35	fn deref(&self) -> &Self::Target {	×
NEW 36	&self.0	×
NEW 37	}	×
38	}
39
40	/// Wrapper for managed buffer access with automatic caching
41	#[derive(Debug, Clone)]
42	pub enum BufferHandle<T> {
43	Pending(BufferId),
44	Ready(Buffer<T>),
45	}
46
47	impl<T> Hash for BufferHandle<T> {
NEW 48	fn hash<H: Hasher>(&self, state: &mut H) {	×
NEW 49	match self {	×
NEW 50	BufferHandle::Pending(id) => id.hash(state),	×
NEW 51	BufferHandle::Ready(buffer) => buffer.as_ptr().hash(state),	×
52	}
NEW 53	}	×
54	}
55
56	impl<T> PartialEq for BufferHandle<T> {
NEW 57	fn eq(&self, other: &Self) -> bool {	×
NEW 58	match (self, other) {	×
NEW 59	(BufferHandle::Pending(id1), BufferHandle::Pending(id2)) => id1 == id2,	×
NEW 60	(BufferHandle::Ready(buf1), BufferHandle::Ready(buf2)) => {	×
NEW 61	buf1.as_ptr() == buf2.as_ptr()	×
62	}
NEW 63	_ => false,	×
64	}
NEW 65	}	×
66	}
67
68	impl<T> BufferHandle<T> {
NEW 69	pub fn new(buffer: Buffer<T>) -> Self {	×
NEW 70	BufferHandle::Ready(buffer)	×
NEW 71	}	×
72
NEW 73	pub fn new_pending(id: BufferId) -> Self {	×
NEW 74	BufferHandle::Pending(id)	×
NEW 75	}	×
76
NEW 77	pub fn into_typed<S>(self) -> BufferHandle<S> {	×
NEW 78	match self {	×
NEW 79	BufferHandle::Ready(buffer) => {	×
NEW 80	BufferHandle::Ready(Buffer::<S>::from_byte_buffer(buffer.into_byte_buffer()))	×
81	}
NEW 82	BufferHandle::Pending(id) => BufferHandle::Pending(id),	×
83	}
NEW 84	}	×
85
NEW 86	pub fn buffer(self) -> Option<Buffer<T>> {	×
NEW 87	match self {	×
NEW 88	BufferHandle::Ready(buffer) => Some(buffer),	×
NEW 89	BufferHandle::Pending(_) => None,	×
90	}
NEW 91	}	×
92
NEW 93	pub fn get_or_load(&mut self, ctx: &dyn KernelContext) -> Poll<VortexResult<&Buffer<T>>> {	×
NEW 94	if let BufferHandle::Ready(buffer) = self {	×
NEW 95	return Poll::Ready(Ok(buffer));	×
NEW 96	}	×
97
NEW 98	let buffer_id = match self {	×
NEW 99	BufferHandle::Pending(id) => *id,	×
NEW 100	BufferHandle::Ready(_) => unreachable!("BufferHandle should not be ready here"),	×
101	};
NEW 102	let buffer = ready!(ctx.buffer(buffer_id))?;	×
NEW 103	*self = BufferHandle::Ready(Buffer::<T>::from_byte_buffer(buffer));	×
104
NEW 105	if let BufferHandle::Ready(buffer) = self {	×
NEW 106	Poll::Ready(Ok(buffer))	×
107	} else {
NEW 108	vortex_panic!("BufferHandle should be ready after loading");	×
109	}
NEW 110	}	×
111	}

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