10796512144

Committed 10 Sep 2024 03:50PM UTC coverage: 91.037% (+0.03%) from 91.005%

Build # 10796512144

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #980 from geo-engine/remove-pro-feature

remove pro from datatypes and operators

Run Details

60 of 118 new or added lines in 7 files covered. (50.85%)

8 existing lines in 5 files now uncovered.

133668 of 146828 relevant lines covered (91.04%)

52534.71 hits per line

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

83.11

/operators/src/cache/util.rs

use geoengine_datatypes::util::ByteSize;
use snafu::ensure;

use super::error::CacheError;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub struct CacheSize {
    byte_size_total: usize,
    byte_size_used: usize,
}

impl CacheSize {
    pub fn new(byte_size_total: usize) -> Self {
        Self {
            byte_size_total,
            byte_size_used: 0,
        }
    }

    #[inline]
    pub fn total_byte_size(&self) -> usize {
        self.byte_size_total
    }

    #[inline]
    pub fn byte_size_used(&self) -> usize {
        self.byte_size_used
    }

    #[inline]
    pub fn byte_size_free(&self) -> usize {
        if self.byte_size_used > self.byte_size_total {
            0
        } else {
            self.byte_size_total - self.byte_size_used
        }
    }

    #[inline]
    pub fn size_used_fraction(&self) -> f64 {
        self.byte_size_used as f64 / self.byte_size_total as f64
    }

    #[inline]
    pub fn can_fit_bytes(&self, bytes: usize) -> bool {
        !self.is_overflowing() && self.byte_size_free() >= bytes
    }

    #[inline]
    pub fn can_fit_element_bytes<T: ByteSize>(&self, element: &T) -> bool {
        self.can_fit_bytes(element.byte_size())
    }

    #[inline]
    pub fn is_overflowing(&self) -> bool {
        self.byte_size_used > self.byte_size_total
    }

    #[inline]
    pub fn add_bytes(&mut self, bytes: usize) {
        debug_assert!(
            self.can_fit_bytes(bytes),
            "adding too many bytes {} for free capacity {}",
            bytes,
            self.byte_size_free()
        );
        self.byte_size_used += bytes;
    }

    #[inline]
    pub fn add_element_bytes<T: ByteSize>(&mut self, element: &T) {
        self.add_bytes(element.byte_size());
    }

    #[inline]
    pub fn remove_bytes(&mut self, bytes: usize) {
        debug_assert!(
            self.byte_size_used >= bytes,
            "removing more bytes {} than used {}",
            bytes,
            self.byte_size_used
        );
        self.byte_size_used -= bytes;
    }

    #[inline]
    pub fn remove_element_bytes<T: ByteSize>(&mut self, element: &T) {
        self.remove_bytes(element.byte_size());
    }

    #[inline]
    pub fn try_add_bytes(&mut self, bytes: usize) -> Result<(), CacheError> {
        ensure!(
            self.can_fit_bytes(bytes),
            crate::cache::error::NotEnoughSpaceInCache
        );
        self.add_bytes(bytes);
        Ok(())
    }

    #[inline]
    pub fn try_add_element_bytes<T: ByteSize>(&mut self, element: &T) -> Result<(), CacheError> {
        let bytes = element.byte_size();
        self.try_add_bytes(bytes)
    }

    #[inline]
    pub fn try_remove_bytes(&mut self, bytes: usize) -> Result<(), CacheError> {
        ensure!(
            self.byte_size_used >= bytes,
            crate::cache::error::NegativeSizeOfCache
        );
        self.remove_bytes(bytes);
        Ok(())
    }

    #[inline]
    pub fn try_remove_element_bytes<T: ByteSize>(&mut self, element: &T) -> Result<(), CacheError> {
        let bytes = element.byte_size();
        self.try_remove_bytes(bytes)
    }

    #[inline]
    pub fn add_bytes_allow_overflow(&mut self, bytes: usize) {
        self.byte_size_used += bytes;
        if self.is_overflowing() {
            log::trace!(
                "overflowing cache size by {} bytes, total size: {}, added bytes: {}",
                self.byte_size_used - self.byte_size_total,
                self.byte_size_total,
                bytes
            );
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn tile_cache_backend_size_init() {
        let CacheSize {
            byte_size_total,
            byte_size_used,
        } = CacheSize::new(123);
        assert_eq!(byte_size_total, 123);
        assert_eq!(byte_size_used, 0);
    }

    #[test]
    #[allow(clippy::float_cmp)]
    fn tile_cache_backend_size_add_remove() {
        let mut size = CacheSize::new(100);
        size.add_bytes(10);
        assert_eq!(size.byte_size_total, 100);
        assert_eq!(size.byte_size_used, 10);
        assert_eq!(size.total_byte_size(), 100);
        assert_eq!(size.byte_size_used(), 10);
        assert_eq!(size.byte_size_free(), 100 - 10);
        assert_eq!(size.size_used_fraction(), 0.1);

        size.add_bytes(20);
        assert_eq!(size.byte_size_total, 100);
        assert_eq!(size.byte_size_used, 30);
        assert_eq!(size.total_byte_size(), 100);
        assert_eq!(size.byte_size_used(), 30);
        assert_eq!(size.byte_size_free(), 100 - 30);
        assert_eq!(size.size_used_fraction(), 0.3);

        size.remove_bytes(10);
        assert_eq!(size.byte_size_total, 100);
        assert_eq!(size.byte_size_used, 20);
        assert_eq!(size.total_byte_size(), 100);
        assert_eq!(size.byte_size_used(), 20);
        assert_eq!(size.byte_size_free(), 100 - 20);
        assert_eq!(size.size_used_fraction(), 0.2);
    }

    #[test]
    #[allow(clippy::float_cmp)]
    fn tile_cache_backend_size_add_remove_overflow() {
        let mut size = CacheSize::new(100);
        size.add_bytes_allow_overflow(110);
        assert_eq!(size.byte_size_total, 100);
        assert_eq!(size.byte_size_used, 110);
        assert_eq!(size.total_byte_size(), 100);
        assert_eq!(size.byte_size_used(), 110);
        assert_eq!(size.byte_size_free(), 0);
        assert!(size.is_overflowing());

        size.remove_bytes(110);
        assert_eq!(size.byte_size_total, 100);
        assert_eq!(size.byte_size_used, 0);
        assert_eq!(size.total_byte_size(), 100);
        assert_eq!(size.byte_size_used(), 0);
        assert_eq!(size.byte_size_free(), 100);
        assert_eq!(size.size_used_fraction(), 0.0);
        assert!(!size.is_overflowing());
    }

    #[test]
    fn tile_cache_backend_element_size() {
        let tile = vec![0u8; 1001];
        let tile_size = tile.byte_size();
        let mut size = CacheSize::new(100_000);
        size.add_element_bytes(&tile);
        assert!(size.byte_size_used() == tile_size);
        assert!(size.byte_size_free() == 100_000 - tile_size);
        size.remove_element_bytes(&tile);
        assert!(size.byte_size_used() == 0);
    }

    #[test]
    fn tile_cache_backend_can_fit() {
        let tile_size = 1001;
        let mut size = CacheSize::new(2000);
        assert!(size.can_fit_bytes(tile_size));
        size.add_bytes(tile_size);
        assert!(!size.can_fit_bytes(tile_size));
        size.remove_bytes(tile_size);
        assert!(size.can_fit_bytes(tile_size));
    }
}

1	use geoengine_datatypes::util::ByteSize;
2	use snafu::ensure;
3
4	use super::error::CacheError;
5
6	#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
7	pub struct CacheSize {
8	byte_size_total: usize,
9	byte_size_used: usize,
10	}
11
12	impl CacheSize {
13	pub fn new(byte_size_total: usize) -> Self {	201✔
14	Self {	201✔
15	byte_size_total,	201✔
16	byte_size_used: 0,	201✔
17	}	201✔
18	}	201✔
19
20	#[inline]
21	pub fn total_byte_size(&self) -> usize {	7✔
22	self.byte_size_total	7✔
23	}	7✔
24
25	#[inline]
26	pub fn byte_size_used(&self) -> usize {	8✔
27	self.byte_size_used	8✔
28	}	8✔
29
30	#[inline]
31	pub fn byte_size_free(&self) -> usize {	69✔
32	if self.byte_size_used > self.byte_size_total {	69✔
33	0	1✔
34	} else {
35	self.byte_size_total - self.byte_size_used	68✔
36	}
37	}	69✔
38
39	#[inline]
40	pub fn size_used_fraction(&self) -> f64 {	4✔
41	self.byte_size_used as f64 / self.byte_size_total as f64	4✔
42	}	4✔
43
44	#[inline]
45	pub fn can_fit_bytes(&self, bytes: usize) -> bool {	64✔
46	!self.is_overflowing() && self.byte_size_free() >= bytes	64✔
47	}	64✔
48
49	#[inline]
50	pub fn can_fit_element_bytes<T: ByteSize>(&self, element: &T) -> bool {	×
51	self.can_fit_bytes(element.byte_size())	×
52	}	×
53
54	#[inline]
55	pub fn is_overflowing(&self) -> bool {	72✔
56	self.byte_size_used > self.byte_size_total	72✔
57	}	72✔
58
59	#[inline]
60	pub fn add_bytes(&mut self, bytes: usize) {	27✔
61	debug_assert!(	27✔
62	self.can_fit_bytes(bytes),	27✔
63	"adding too many bytes {} for free capacity {}",	×
64	bytes,	×
65	self.byte_size_free()	×
66	);
67	self.byte_size_used += bytes;	27✔
68	}	27✔
69
70	#[inline]
71	pub fn add_element_bytes<T: ByteSize>(&mut self, element: &T) {	1✔
72	self.add_bytes(element.byte_size());	1✔
73	}	1✔
74
75	#[inline]
76	pub fn remove_bytes(&mut self, bytes: usize) {	24✔
77	debug_assert!(	24✔
78	self.byte_size_used >= bytes,	24✔
79	"removing more bytes {} than used {}",	×
80	bytes,
81	self.byte_size_used
82	);
83	self.byte_size_used -= bytes;	24✔
84	}	24✔
85
86	#[inline]
87	pub fn remove_element_bytes<T: ByteSize>(&mut self, element: &T) {	21✔
88	self.remove_bytes(element.byte_size());	21✔
89	}	21✔
90
91	#[inline]
92	pub fn try_add_bytes(&mut self, bytes: usize) -> Result<(), CacheError> {	23✔
93	ensure!(	23✔
94	self.can_fit_bytes(bytes),	23✔
NEW 95	crate::cache::error::NotEnoughSpaceInCache	×
96	);
97	self.add_bytes(bytes);	23✔
98	Ok(())	23✔
99	}	23✔
100
101	#[inline]
102	pub fn try_add_element_bytes<T: ByteSize>(&mut self, element: &T) -> Result<(), CacheError> {	×
103	let bytes = element.byte_size();	×
104	self.try_add_bytes(bytes)	×
105	}	×
106
107	#[inline]
108	pub fn try_remove_bytes(&mut self, bytes: usize) -> Result<(), CacheError> {	×
109	ensure!(	×
110	self.byte_size_used >= bytes,	×
NEW 111	crate::cache::error::NegativeSizeOfCache	×
112	);
113	self.remove_bytes(bytes);	×
114	Ok(())	×
115	}	×
116
117	#[inline]
118	pub fn try_remove_element_bytes<T: ByteSize>(&mut self, element: &T) -> Result<(), CacheError> {	×
119	let bytes = element.byte_size();	×
120	self.try_remove_bytes(bytes)	×
121	}	×
122
123	#[inline]
124	pub fn add_bytes_allow_overflow(&mut self, bytes: usize) {	6✔
125	self.byte_size_used += bytes;	6✔
126	if self.is_overflowing() {	6✔
127	log::trace!(	2✔
128	"overflowing cache size by {} bytes, total size: {}, added bytes: {}",	×
129	self.byte_size_used - self.byte_size_total,	×
130	self.byte_size_total,
131	bytes
132	);
133	}	4✔
134	}	6✔
135	}
136
137	#[cfg(test)]
138	mod tests {
139	use super::*;
140
141	#[test]
142	fn tile_cache_backend_size_init() {	1✔
143	let CacheSize {	1✔
144	byte_size_total,	1✔
145	byte_size_used,	1✔
146	} = CacheSize::new(123);	1✔
147	assert_eq!(byte_size_total, 123);	1✔
148	assert_eq!(byte_size_used, 0);	1✔
149	}	1✔
150
151	#[test]
152	#[allow(clippy::float_cmp)]
153	fn tile_cache_backend_size_add_remove() {	1✔
154	let mut size = CacheSize::new(100);	1✔
155	size.add_bytes(10);	1✔
156	assert_eq!(size.byte_size_total, 100);	1✔
157	assert_eq!(size.byte_size_used, 10);	1✔
158	assert_eq!(size.total_byte_size(), 100);	1✔
159	assert_eq!(size.byte_size_used(), 10);	1✔
160	assert_eq!(size.byte_size_free(), 100 - 10);	1✔
161	assert_eq!(size.size_used_fraction(), 0.1);	1✔
162
163	size.add_bytes(20);	1✔
164	assert_eq!(size.byte_size_total, 100);	1✔
165	assert_eq!(size.byte_size_used, 30);	1✔
166	assert_eq!(size.total_byte_size(), 100);	1✔
167	assert_eq!(size.byte_size_used(), 30);	1✔
168	assert_eq!(size.byte_size_free(), 100 - 30);	1✔
169	assert_eq!(size.size_used_fraction(), 0.3);	1✔
170
171	size.remove_bytes(10);	1✔
172	assert_eq!(size.byte_size_total, 100);	1✔
173	assert_eq!(size.byte_size_used, 20);	1✔
174	assert_eq!(size.total_byte_size(), 100);	1✔
175	assert_eq!(size.byte_size_used(), 20);	1✔
176	assert_eq!(size.byte_size_free(), 100 - 20);	1✔
177	assert_eq!(size.size_used_fraction(), 0.2);	1✔
178	}	1✔
179
180	#[test]
181	#[allow(clippy::float_cmp)]
182	fn tile_cache_backend_size_add_remove_overflow() {	1✔
183	let mut size = CacheSize::new(100);	1✔
184	size.add_bytes_allow_overflow(110);	1✔
185	assert_eq!(size.byte_size_total, 100);	1✔
186	assert_eq!(size.byte_size_used, 110);	1✔
187	assert_eq!(size.total_byte_size(), 100);	1✔
188	assert_eq!(size.byte_size_used(), 110);	1✔
189	assert_eq!(size.byte_size_free(), 0);	1✔
190	assert!(size.is_overflowing());	1✔
191
192	size.remove_bytes(110);	1✔
193	assert_eq!(size.byte_size_total, 100);	1✔
194	assert_eq!(size.byte_size_used, 0);	1✔
195	assert_eq!(size.total_byte_size(), 100);	1✔
196	assert_eq!(size.byte_size_used(), 0);	1✔
197	assert_eq!(size.byte_size_free(), 100);	1✔
198	assert_eq!(size.size_used_fraction(), 0.0);	1✔
199	assert!(!size.is_overflowing());	1✔
200	}	1✔
201
202	#[test]
203	fn tile_cache_backend_element_size() {	1✔
204	let tile = vec![0u8; 1001];	1✔
205	let tile_size = tile.byte_size();	1✔
206	let mut size = CacheSize::new(100_000);	1✔
207	size.add_element_bytes(&tile);	1✔
208	assert!(size.byte_size_used() == tile_size);	1✔
209	assert!(size.byte_size_free() == 100_000 - tile_size);	1✔
210	size.remove_element_bytes(&tile);	1✔
211	assert!(size.byte_size_used() == 0);	1✔
212	}	1✔
213
214	#[test]
215	fn tile_cache_backend_can_fit() {	1✔
216	let tile_size = 1001;	1✔
217	let mut size = CacheSize::new(2000);	1✔
218	assert!(size.can_fit_bytes(tile_size));	1✔
219	size.add_bytes(tile_size);	1✔
220	assert!(!size.can_fit_bytes(tile_size));	1✔
221	size.remove_bytes(tile_size);	1✔
222	assert!(size.can_fit_bytes(tile_size));	1✔
223	}	1✔
224	}

geo-engine / geoengine / 10796512144

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