Mirror/brk
1
0
Fork 0
mirror of https://github.com/bitcoinresearchkit/brk.git synced 2026-07-05 08:08:15 -07:00
Code Issues Packages Projects Releases Wiki Activity

global: adding support for safe lengths

Browse Source
This commit is contained in:
nym21
2026-05-06 15:33:07 +02:00
parent da7671744f
commit 086bfd9938
177 changed files with 2445 additions and 2049 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/brk_computer/src/blocks/compute.rs
+7 -9
View File
@@ -2,7 +2,6 @@ use std::thread;
use brk_error::Result;
use brk_indexer::Indexer;
use brk_types::Indexes;
use vecdb::Exit;
use crate::indexes;
@@ -14,13 +13,12 @@ impl Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
self.db.sync_bg_tasks()?;
// lookback depends on indexes.timestamp.monotonic
self.lookback.compute(indexes, starting_indexes, exit)?;
self.lookback.compute(indexer, indexes, exit)?;
// Parallel: remaining sub-modules are independent of each other.
// size depends on lookback (already computed above).
@@ -35,12 +33,12 @@ impl Vecs {
..
} = self;
thread::scope(|s| -> Result<()> {
let r1 = s.spawn(|| count.compute(indexer, starting_indexes, exit));
let r2 = s.spawn(|| interval.compute(indexer, starting_indexes, exit));
let r3 = s.spawn(|| weight.compute(indexer, starting_indexes, exit));
let r4 = s.spawn(|| difficulty.compute(indexer, indexes, starting_indexes, exit));
let r5 = s.spawn(|| halving.compute(indexes, starting_indexes, exit));
size.compute(indexer, &*lookback, starting_indexes, exit)?;
let r1 = s.spawn(|| count.compute(indexer, exit));
let r2 = s.spawn(|| interval.compute(indexer, exit));
let r3 = s.spawn(|| weight.compute(indexer, exit));
let r4 = s.spawn(|| difficulty.compute(indexer, indexes, exit));
let r5 = s.spawn(|| halving.compute(indexer, indexes, exit));
size.compute(indexer, &*lookback, exit)?;
r1.join().unwrap()?;
r2.join().unwrap()?;
r3.join().unwrap()?;
crates/brk_computer/src/blocks/count/compute.rs
+5 -10
View File
@@ -1,25 +1,20 @@
use brk_error::Result;
use brk_indexer::Indexer;
use brk_types::{Indexes, StoredU32};
use brk_types::StoredU32;
use vecdb::Exit;
use super::Vecs;
impl Vecs {
pub(crate) fn compute(
&mut self,
indexer: &Indexer,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
// Block count raw + cumulative
pub(crate) fn compute(&mut self, indexer: &Indexer, exit: &Exit) -> Result<()> {
let starting_height = indexer.safe_lengths().height;
self.total.block.compute_range(
starting_indexes.height,
starting_height,
&indexer.vecs.blocks.weight,
|h| (h, StoredU32::from(1_u32)),
exit,
)?;
self.total.compute_rest(starting_indexes.height, exit)?;
self.total.compute_rest(starting_height, exit)?;
Ok(())
}
crates/brk_computer/src/blocks/difficulty/compute.rs
+5 -5
View File
@@ -1,6 +1,6 @@
use brk_error::Result;
use brk_indexer::Indexer;
use brk_types::{Indexes, StoredU32};
use brk_types::StoredU32;
use vecdb::Exit;
use super::Vecs;
@@ -11,25 +11,25 @@ impl Vecs {
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
let starting_height = indexer.safe_lengths().height;
self.adjustment.bps.height.compute_ratio_change(
starting_indexes.height,
starting_height,
&indexer.vecs.blocks.difficulty,
2016,
exit,
)?;
self.epoch.height.compute_transform(
starting_indexes.height,
starting_height,
&indexes.height.epoch,
|(h, epoch, ..)| (h, epoch),
exit,
)?;
self.blocks_to_retarget.height.compute_transform(
starting_indexes.height,
starting_height,
&indexes.height.epoch,
|(h, ..)| (h, StoredU32::from(h.left_before_next_diff_adj())),
exit,
crates/brk_computer/src/blocks/halving/compute.rs
+6 -4
View File
@@ -1,5 +1,6 @@
use brk_error::Result;
use brk_types::{Indexes, StoredU32};
use brk_indexer::Indexer;
use brk_types::StoredU32;
use vecdb::Exit;
use super::Vecs;
@@ -8,19 +9,20 @@ use crate::indexes;
impl Vecs {
pub(crate) fn compute(
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
let starting_height = indexer.safe_lengths().height;
self.epoch.height.compute_transform(
starting_indexes.height,
starting_height,
&indexes.height.halving,
|(h, epoch, ..)| (h, epoch),
exit,
)?;
self.blocks_to_halving.height.compute_transform(
starting_indexes.height,
starting_height,
&indexes.height.halving,
|(h, ..)| (h, StoredU32::from(h.left_before_next_halving())),
exit,
crates/brk_computer/src/blocks/interval/compute.rs
+5 -9
View File
@@ -1,21 +1,17 @@
use brk_error::Result;
use brk_indexer::Indexer;
use brk_types::{CheckedSub, Indexes, Timestamp};
use brk_types::{CheckedSub, Timestamp};
use vecdb::{Exit, ReadableVec};
use super::Vecs;
impl Vecs {
pub(crate) fn compute(
&mut self,
indexer: &Indexer,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
pub(crate) fn compute(&mut self, indexer: &Indexer, exit: &Exit) -> Result<()> {
let starting_height = indexer.safe_lengths().height;
let mut prev_timestamp = None;
self.0.compute(starting_indexes.height, exit, |vec| {
self.0.compute(starting_height, exit, |vec| {
vec.compute_transform(
starting_indexes.height,
starting_height,
&indexer.vecs.blocks.timestamp,
|(h, timestamp, ..)| {
let interval = if let Some(prev_h) = h.decremented() {
crates/brk_computer/src/blocks/lookback.rs
+58 -64
View File
@@ -1,6 +1,7 @@
use brk_error::Result;
use brk_indexer::Indexer;
use brk_traversable::Traversable;
use brk_types::{Height, Indexes, Timestamp, Version};
use brk_types::{Height, Timestamp, Version};
use vecdb::{
AnyVec, CachedVec, Cursor, Database, EagerVec, Exit, ImportableVec, PcoVec, ReadableVec, Rw,
StorageMode, VecIndex,
@@ -219,53 +220,54 @@ impl Vecs {
pub(crate) fn compute(
&mut self,
indexer: &Indexer,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
self.compute_rolling_start_hours(indexes, starting_indexes, exit, 1, |s| &mut s._1h)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 1, |s| &mut s._24h.inner)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 3, |s| &mut s._3d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 7, |s| &mut s._1w.inner)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 8, |s| &mut s._8d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 9, |s| &mut s._9d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 12, |s| &mut s._12d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 13, |s| &mut s._13d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 14, |s| &mut s._2w)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 21, |s| &mut s._21d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 26, |s| &mut s._26d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 30, |s| &mut s._1m.inner)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 34, |s| &mut s._34d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 55, |s| &mut s._55d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 60, |s| &mut s._2m)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 63, |s| &mut s._9w)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 84, |s| &mut s._12w)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 89, |s| &mut s._89d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 90, |s| &mut s._3m)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 98, |s| &mut s._14w)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 111, |s| &mut s._111d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 144, |s| &mut s._144d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 180, |s| &mut s._6m)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 182, |s| &mut s._26w)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 200, |s| &mut s._200d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 270, |s| &mut s._9m)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 350, |s| &mut s._350d)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 360, |s| &mut s._12m)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 365, |s| &mut s._1y.inner)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 420, |s| &mut s._14m)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 730, |s| &mut s._2y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 780, |s| &mut s._26m)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 1095, |s| &mut s._3y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 1400, |s| &mut s._200w)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 1460, |s| &mut s._4y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 1825, |s| &mut s._5y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 2190, |s| &mut s._6y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 2920, |s| &mut s._8y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 3285, |s| &mut s._9y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 3650, |s| &mut s._10y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 4380, |s| &mut s._12y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 5110, |s| &mut s._14y)?;
self.compute_rolling_start(indexes, starting_indexes, exit, 9490, |s| &mut s._26y)?;
let starting_height = indexer.safe_lengths().height;
self.compute_rolling_start_hours(indexes, starting_height, exit, 1, |s| &mut s._1h)?;
self.compute_rolling_start(indexes, starting_height, exit, 1, |s| &mut s._24h.inner)?;
self.compute_rolling_start(indexes, starting_height, exit, 3, |s| &mut s._3d)?;
self.compute_rolling_start(indexes, starting_height, exit, 7, |s| &mut s._1w.inner)?;
self.compute_rolling_start(indexes, starting_height, exit, 8, |s| &mut s._8d)?;
self.compute_rolling_start(indexes, starting_height, exit, 9, |s| &mut s._9d)?;
self.compute_rolling_start(indexes, starting_height, exit, 12, |s| &mut s._12d)?;
self.compute_rolling_start(indexes, starting_height, exit, 13, |s| &mut s._13d)?;
self.compute_rolling_start(indexes, starting_height, exit, 14, |s| &mut s._2w)?;
self.compute_rolling_start(indexes, starting_height, exit, 21, |s| &mut s._21d)?;
self.compute_rolling_start(indexes, starting_height, exit, 26, |s| &mut s._26d)?;
self.compute_rolling_start(indexes, starting_height, exit, 30, |s| &mut s._1m.inner)?;
self.compute_rolling_start(indexes, starting_height, exit, 34, |s| &mut s._34d)?;
self.compute_rolling_start(indexes, starting_height, exit, 55, |s| &mut s._55d)?;
self.compute_rolling_start(indexes, starting_height, exit, 60, |s| &mut s._2m)?;
self.compute_rolling_start(indexes, starting_height, exit, 63, |s| &mut s._9w)?;
self.compute_rolling_start(indexes, starting_height, exit, 84, |s| &mut s._12w)?;
self.compute_rolling_start(indexes, starting_height, exit, 89, |s| &mut s._89d)?;
self.compute_rolling_start(indexes, starting_height, exit, 90, |s| &mut s._3m)?;
self.compute_rolling_start(indexes, starting_height, exit, 98, |s| &mut s._14w)?;
self.compute_rolling_start(indexes, starting_height, exit, 111, |s| &mut s._111d)?;
self.compute_rolling_start(indexes, starting_height, exit, 144, |s| &mut s._144d)?;
self.compute_rolling_start(indexes, starting_height, exit, 180, |s| &mut s._6m)?;
self.compute_rolling_start(indexes, starting_height, exit, 182, |s| &mut s._26w)?;
self.compute_rolling_start(indexes, starting_height, exit, 200, |s| &mut s._200d)?;
self.compute_rolling_start(indexes, starting_height, exit, 270, |s| &mut s._9m)?;
self.compute_rolling_start(indexes, starting_height, exit, 350, |s| &mut s._350d)?;
self.compute_rolling_start(indexes, starting_height, exit, 360, |s| &mut s._12m)?;
self.compute_rolling_start(indexes, starting_height, exit, 365, |s| &mut s._1y.inner)?;
self.compute_rolling_start(indexes, starting_height, exit, 420, |s| &mut s._14m)?;
self.compute_rolling_start(indexes, starting_height, exit, 730, |s| &mut s._2y)?;
self.compute_rolling_start(indexes, starting_height, exit, 780, |s| &mut s._26m)?;
self.compute_rolling_start(indexes, starting_height, exit, 1095, |s| &mut s._3y)?;
self.compute_rolling_start(indexes, starting_height, exit, 1400, |s| &mut s._200w)?;
self.compute_rolling_start(indexes, starting_height, exit, 1460, |s| &mut s._4y)?;
self.compute_rolling_start(indexes, starting_height, exit, 1825, |s| &mut s._5y)?;
self.compute_rolling_start(indexes, starting_height, exit, 2190, |s| &mut s._6y)?;
self.compute_rolling_start(indexes, starting_height, exit, 2920, |s| &mut s._8y)?;
self.compute_rolling_start(indexes, starting_height, exit, 3285, |s| &mut s._9y)?;
self.compute_rolling_start(indexes, starting_height, exit, 3650, |s| &mut s._10y)?;
self.compute_rolling_start(indexes, starting_height, exit, 4380, |s| &mut s._12y)?;
self.compute_rolling_start(indexes, starting_height, exit, 5110, |s| &mut s._14y)?;
self.compute_rolling_start(indexes, starting_height, exit, 9490, |s| &mut s._26y)?;
Ok(())
}
@@ -273,7 +275,7 @@ impl Vecs {
fn compute_rolling_start<F>(
&mut self,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
starting_height: Height,
exit: &Exit,
days: usize,
get_field: F,
@@ -281,19 +283,15 @@ impl Vecs {
where
F: FnOnce(&mut Self) -> &mut EagerVec<PcoVec<Height, Height>>,
{
self.compute_rolling_start_inner(
indexes,
starting_indexes,
exit,
get_field,
|t, prev_ts| t.difference_in_days_between(prev_ts) >= days,
)
self.compute_rolling_start_inner(indexes, starting_height, exit, get_field, |t, prev_ts| {
t.difference_in_days_between(prev_ts) >= days
})
}
fn compute_rolling_start_hours<F>(
&mut self,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
starting_height: Height,
exit: &Exit,
hours: usize,
get_field: F,
@@ -301,19 +299,15 @@ impl Vecs {
where
F: FnOnce(&mut Self) -> &mut EagerVec<PcoVec<Height, Height>>,
{
self.compute_rolling_start_inner(
indexes,
starting_indexes,
exit,
get_field,
|t, prev_ts| t.difference_in_hours_between(prev_ts) >= hours,
)
self.compute_rolling_start_inner(indexes, starting_height, exit, get_field, |t, prev_ts| {
t.difference_in_hours_between(prev_ts) >= hours
})
}
fn compute_rolling_start_inner<F, D>(
&mut self,
indexes: &indexes::Vecs,
starting_indexes: &Indexes,
starting_height: Height,
exit: &Exit,
get_field: F,
expired: D,
@@ -323,7 +317,7 @@ impl Vecs {
D: Fn(Timestamp, Timestamp) -> bool,
{
let field = get_field(self);
let resume_from = field.len().min(starting_indexes.height.to_usize());
let resume_from = field.len().min(starting_height.to_usize());
let mut prev = if resume_from > 0 {
field.collect_one_at(resume_from - 1).unwrap()
} else {
@@ -333,7 +327,7 @@ impl Vecs {
cursor.advance(prev.to_usize());
let mut prev_ts = cursor.next().unwrap();
Ok(field.compute_transform(
starting_indexes.height,
starting_height,
&indexes.timestamp.monotonic,
|(h, t, ..)| {
while expired(t, prev_ts) {
crates/brk_computer/src/blocks/size/compute.rs
+5 -7
View File
@@ -1,6 +1,6 @@
use brk_error::Result;
use brk_indexer::Indexer;
use brk_types::{Indexes, StoredU64};
use brk_types::StoredU64;
use vecdb::Exit;
use super::Vecs;
@@ -11,25 +11,23 @@ impl Vecs {
&mut self,
indexer: &Indexer,
lookback: &blocks::LookbackVecs,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
let starting_height = indexer.safe_lengths().height;
let window_starts = lookback.window_starts();
// vbytes = floor(weight / 4), stored at height level
self.vbytes
.compute(starting_indexes.height, &window_starts, exit, |height| {
.compute(starting_height, &window_starts, exit, |height| {
Ok(height.compute_transform(
starting_indexes.height,
starting_height,
&indexer.vecs.blocks.weight,
|(h, weight, ..)| (h, StoredU64::from(weight.to_vbytes_floor())),
exit,
)?)
})?;
// size from indexer total_size
self.size.compute(
starting_indexes.height,
starting_height,
&window_starts,
&indexer.vecs.blocks.total,
exit,
crates/brk_computer/src/blocks/weight/compute.rs
+4 -8
View File
@@ -1,19 +1,15 @@
use brk_error::Result;
use brk_indexer::Indexer;
use brk_types::{BasisPoints16, Indexes};
use brk_types::BasisPoints16;
use vecdb::Exit;
use super::Vecs;
impl Vecs {
pub(crate) fn compute(
&mut self,
indexer: &Indexer,
starting_indexes: &Indexes,
exit: &Exit,
) -> Result<()> {
pub(crate) fn compute(&mut self, indexer: &Indexer, exit: &Exit) -> Result<()> {
let starting_height = indexer.safe_lengths().height;
self.fullness.bps.compute_transform(
starting_indexes.height,
starting_height,
&indexer.vecs.blocks.weight,
|(h, weight, ..)| (h, BasisPoints16::from(weight.fullness())),
exit,