Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-07-13 20:18:12 -07:00
Code Issues Packages Projects Releases Wiki Activity

vec: moved compute functions to computer

Browse Source
This commit is contained in:
nym21
2025-03-11 16:27:45 +01:00
parent 64d73b93e4
commit b9e679a514
14 changed files with 413 additions and 350 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/brk_vec/src/lib.rs
+5 -233
View File
@@ -5,18 +5,16 @@
use std::{
cmp::Ordering,
error,
fmt::Debug,
fs::{self, File, OpenOptions},
io::{self, Read, Seek, SeekFrom, Write},
marker::PhantomData,
mem,
ops::{Add, Range, Sub},
ops::Range,
path::{Path, PathBuf},
sync::OnceLock,
};
use brk_core::CheckedSub;
use brk_exit::Exit;
pub use memmap2;
use rayon::prelude::*;
@@ -59,7 +57,6 @@ pub struct StorableVec<I, T> {
const MAX_PAGE_SIZE: usize = 4 * 4096;
const ONE_MB: usize = 1024 * 1024;
const MAX_CACHE_SIZE: usize = 100 * ONE_MB;
const FLUSH_EVERY: usize = 10_000;
impl<I, T> StorableVec<I, T>
where
@@ -272,7 +269,7 @@ where
}
}
fn read_last(&mut self) -> Result<Option<&T>> {
pub fn read_last(&mut self) -> Result<Option<&T>> {
let len = self.len();
if len == 0 {
return Ok(None);
@@ -376,27 +373,6 @@ where
}
}
#[inline]
fn push_and_flush_if_needed(&mut self, index: I, value: T, exit: &Exit) -> Result<()> {
match self.len().cmp(&Self::i_to_usize(index)?) {
Ordering::Less => {
return Err(Error::IndexTooHigh);
}
ord => {
if ord == Ordering::Greater {
self.safe_truncate_if_needed(index, exit)?;
}
self.pushed.push(value);
}
}
if self.pushed_len() >= FLUSH_EVERY {
Ok(self.safe_flush(exit)?)
} else {
Ok(())
}
}
#[inline]
pub fn len(&self) -> usize {
self.file_len + self.pushed_len()
@@ -462,15 +438,6 @@ where
Ok(())
}
fn validate_computed_version_or_reset_file(&mut self, version: Version) -> Result<()> {
let path = self.path_computed_version();
if version.validate(path.as_ref()).is_err() {
self.reset_file()?;
}
version.write(path.as_ref())?;
Ok(())
}
pub fn truncate_if_needed(&mut self, index: I) -> Result<Option<T>> {
let index = Self::i_to_usize(index)?;
@@ -497,7 +464,7 @@ where
}
#[inline]
fn i_to_usize(index: I) -> Result<usize> {
pub fn i_to_usize(index: I) -> Result<usize> {
index.try_into().map_err(|_| Error::FailedKeyTryIntoUsize)
}
@@ -558,207 +525,12 @@ where
path.join("version")
}
#[inline]
fn path_computed_version(&self) -> PathBuf {
self.path().join("computed_version")
}
pub fn index_type_to_string(&self) -> &str {
std::any::type_name::<I>()
}
pub fn compute_transform<A, B, F>(
&mut self,
max_from: A,
other: &mut StorableVec<A, B>,
mut t: F,
exit: &Exit,
) -> Result<()>
where
A: StoredIndex,
B: StoredType,
F: FnMut((A, &B, &mut Self, &mut StorableVec<A, B>)) -> (I, T),
{
self.validate_computed_version_or_reset_file(
Version::from(0) + self.version + other.version,
)?;
let index = max_from.min(A::from(self.len()));
other.iter_from(index, |(a, b, other)| {
let (i, v) = t((a, b, self, other));
self.push_and_flush_if_needed(i, v, exit)
})?;
Ok(self.safe_flush(exit)?)
}
pub fn compute_inverse_more_to_less(
&mut self,
max_from: T,
other: &mut StorableVec<T, I>,
exit: &Exit,
) -> Result<()>
where
I: StoredType + StoredIndex,
T: StoredIndex,
{
self.validate_computed_version_or_reset_file(
Version::from(0) + self.version + other.version,
)?;
let index = max_from.min(self.read_last()?.cloned().unwrap_or_default());
other.iter_from(index, |(v, i, ..)| {
let i = *i;
if self.read(i).unwrap().is_none_or(|old_v| *old_v > v) {
self.push_and_flush_if_needed(i, v, exit)
} else {
Ok(())
}
})?;
Ok(self.safe_flush(exit)?)
}
pub fn compute_inverse_less_to_more(
&mut self,
max_from: T,
first_indexes: &mut StorableVec<T, I>,
last_indexes: &mut StorableVec<T, I>,
exit: &Exit,
) -> Result<()>
where
I: StoredType,
T: StoredIndex,
{
self.validate_computed_version_or_reset_file(
Version::from(0) + self.version + first_indexes.version + last_indexes.version,
)?;
let index = max_from.min(T::from(self.len()));
first_indexes.iter_from(index, |(value, first_index, ..)| {
let first_index = Self::i_to_usize(*first_index)?;
let last_index = Self::i_to_usize(*last_indexes.read(value)?.unwrap())?;
(first_index..last_index)
.try_for_each(|index| self.push_and_flush_if_needed(I::from(index), value, exit))
})?;
Ok(self.safe_flush(exit)?)
}
pub fn compute_last_index_from_first(
&mut self,
max_from: I,
first_indexes: &mut StorableVec<I, T>,
final_len: usize,
exit: &Exit,
) -> Result<()>
where
T: Copy + From<usize> + CheckedSub<T> + StoredIndex,
{
self.validate_computed_version_or_reset_file(
Version::from(0) + self.version + first_indexes.version,
)?;
let index = max_from.min(I::from(self.len()));
let one = T::from(1);
let mut prev_index: Option<I> = None;
first_indexes.iter_from(index, |(i, v, ..)| {
if let Some(prev_index) = prev_index.take() {
self.push_and_flush_if_needed(prev_index, v.checked_sub(one).unwrap(), exit)?;
}
prev_index.replace(i);
Ok(())
})?;
if let Some(prev_index) = prev_index {
self.push_and_flush_if_needed(
prev_index,
T::from(final_len).checked_sub(one).unwrap(),
exit,
)?;
}
Ok(self.safe_flush(exit)?)
}
pub fn compute_count_from_indexes<T2>(
&mut self,
max_from: I,
first_indexes: &mut StorableVec<I, T2>,
last_indexes: &mut StorableVec<I, T2>,
exit: &Exit,
) -> Result<()>
where
T: From<T2>,
T2: StoredType + Copy + Add<usize, Output = T2> + Sub<T2, Output = T2> + TryInto<T>,
<T2 as TryInto<T>>::Error: error::Error + 'static,
{
self.validate_computed_version_or_reset_file(
Version::from(0) + self.version + first_indexes.version + last_indexes.version,
)?;
let index = max_from.min(I::from(self.len()));
first_indexes.iter_from(index, |(i, first_index, ..)| {
let last_index = last_indexes.read(i)?.unwrap();
let count = *last_index + 1_usize - *first_index;
self.push_and_flush_if_needed(i, count.into(), exit)
})?;
Ok(self.safe_flush(exit)?)
}
pub fn compute_is_first_ordered<A>(
&mut self,
max_from: I,
self_to_other: &mut StorableVec<I, A>,
other_to_self: &mut StorableVec<A, I>,
exit: &Exit,
) -> Result<()>
where
I: StoredType,
T: From<bool>,
A: StoredIndex + StoredType,
{
self.validate_computed_version_or_reset_file(
Version::from(0) + self.version + self_to_other.version + other_to_self.version,
)?;
let index = max_from.min(I::from(self.len()));
self_to_other.iter_from(index, |(i, other, ..)| {
self.push_and_flush_if_needed(
i,
T::from(other_to_self.read(*other)?.unwrap() == &i),
exit,
)
})?;
Ok(self.safe_flush(exit)?)
}
pub fn compute_sum_from_indexes<T2, F>(
&mut self,
max_from: I,
first_indexes: &mut StorableVec<I, T2>,
last_indexes: &mut StorableVec<I, T2>,
exit: &Exit,
) -> Result<()>
where
T: From<T2>,
T2: StoredType + Copy + Add<usize, Output = T2> + Sub<T2, Output = T2> + TryInto<T>,
<T2 as TryInto<T>>::Error: error::Error + 'static,
F: Fn(&T2) -> T,
{
self.validate_computed_version_or_reset_file(
Version::from(0) + self.version + first_indexes.version + last_indexes.version,
)?;
let index = max_from.min(I::from(self.len()));
first_indexes.iter_from(index, |(index, first_index, ..)| {
let last_index = last_indexes.read(index)?.unwrap();
let count = *last_index + 1_usize - *first_index;
self.push_and_flush_if_needed(index, count.into(), exit)
})?;
Ok(self.safe_flush(exit)?)
pub fn version(&self) -> Version {
self.version
}
}
crates/brk_vec/src/traits/bytes.rs
-11
View File
@@ -1,11 +0,0 @@
use std::sync::Arc;
use crate::Result;
pub trait Bytes: Sized {
const LEN: usize = size_of::<Self>();
fn to_bytes(&self) -> Arc<[u8]>;
fn try_from_bytes(bytes: &[u8]) -> Result<Self>;
}
pub trait UnsafeBytes {}