Skip to content

Commit

Permalink
Lots of small cleanups. Moved a lot of code from using old iter to Tr…
Browse files Browse the repository at this point in the history 
…ansformedOpsIterRaw
  • Loading branch information
@josephg
josephg committed Aug 7, 2024
1 parent 19721f5 commit 51e884a
Show file tree
Hide file tree
Showing 13 changed files with 292 additions and 362 deletions.
6 changes: 3 additions & 3 deletions src/dtrange.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -228,9 +228,9 @@ impl HasRleKey for DTRange {

pub(crate) const UNDERWATER_START: usize = usize::MAX / 4;

pub(crate) fn is_underwater(lv: LV) -> bool {
lv >= UNDERWATER_START
}
// pub(crate) fn is_underwater(lv: LV) -> bool {
// lv >= UNDERWATER_START
// }

// #[derive(Debug)]
// struct RootTime;
Expand Down
112 changes: 56 additions & 56 deletions src/frontier.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -405,62 +405,62 @@ pub fn local_frontier_is_root(branch: &[LV]) -> bool {
}


// This walks both frontiers and finds how the frontier has changed. There's probably a better way
// to implement this.
struct FrontierDiff<'a> {
a: &'a [LV],
b: &'a [LV],
}

pub(crate) fn diff_frontier_entries<'a>(a: &'a [LV], b: &'a [LV]) -> impl Iterator<Item = (DiffFlag, LV)> + 'a {
FrontierDiff { a, b }
}


fn slice_take_first(slice: &mut &[LV]) -> Option<LV> {
if let [first, tail @ ..] = slice {
*slice = tail;
Some(*first)
} else { None }
}

impl<'a> Iterator for FrontierDiff<'a> {
type Item = (DiffFlag, LV);

fn next(&mut self) -> Option<Self::Item> {
match (self.a.split_first(), self.b.split_first()) {
(None, None) => None,
(Some((a, rest)), None) => {
self.a = rest;
Some((DiffFlag::OnlyA, *a))
},
(None, Some((b, rest))) => {
self.b = rest;
Some((DiffFlag::OnlyB, *b))
},
(Some((a, a_rest)), Some((b, b_rest))) => {
match a.cmp(b) {
Ordering::Equal => {
// Take from both.
self.a = a_rest;
self.b = b_rest;
Some((DiffFlag::Shared, *a))
}
Ordering::Less => {
// Take from a.
self.a = a_rest;
Some((DiffFlag::OnlyA, *a))
}
Ordering::Greater => {
// Take from b.
self.b = b_rest;
Some((DiffFlag::OnlyB, *a))
}
}
}
}
}
}
// // This walks both frontiers and finds how the frontier has changed. There's probably a better way
// // to implement this.
// struct FrontierDiff<'a> {
// a: &'a [LV],
// b: &'a [LV],
// }
//
// pub(crate) fn diff_frontier_entries<'a>(a: &'a [LV], b: &'a [LV]) -> impl Iterator<Item = (DiffFlag, LV)> + 'a {
// FrontierDiff { a, b }
// }
//
//
// fn slice_take_first(slice: &mut &[LV]) -> Option<LV> {
// if let [first, tail @ ..] = slice {
// *slice = tail;
// Some(*first)
// } else { None }
// }
//
// impl<'a> Iterator for FrontierDiff<'a> {
// type Item = (DiffFlag, LV);
//
// fn next(&mut self) -> Option<Self::Item> {
// match (self.a.split_first(), self.b.split_first()) {
// (None, None) => None,
// (Some((a, rest)), None) => {
// self.a = rest;
// Some((DiffFlag::OnlyA, *a))
// },
// (None, Some((b, rest))) => {
// self.b = rest;
// Some((DiffFlag::OnlyB, *b))
// },
// (Some((a, a_rest)), Some((b, b_rest))) => {
// match a.cmp(b) {
// Ordering::Equal => {
// // Take from both.
// self.a = a_rest;
// self.b = b_rest;
// Some((DiffFlag::Shared, *a))
// }
// Ordering::Less => {
// // Take from a.
// self.a = a_rest;
// Some((DiffFlag::OnlyA, *a))
// }
// Ordering::Greater => {
// // Take from b.
// self.b = b_rest;
// Some((DiffFlag::OnlyB, *a))
// }
// }
// }
// }
// }
// }

/// This method clones a version or parents vector. Its slightly faster and smaller than just
/// calling v.clone() directly.
Expand Down
45 changes: 31 additions & 14 deletions src/list/encoding/save_transformed.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -3,7 +3,7 @@ use crate::encoding::Merger;
use crate::list::encoding::leb::num_encode_zigzag_isize_old;
use crate::list::encoding::encode_tools::{push_leb_usize, write_leb_bit_run};
use crate::list::ListOpLog;
use crate::listmerge::merge::TransformedResult;
use crate::listmerge::merge::{TransformedResult, TransformedResultRaw};
use crate::LV;

/// *** This is EXPERIMENTAL work-in-progress code to save transformed positions ***
Expand Down Expand Up @@ -36,22 +36,39 @@ impl ListOpLog {
// });
// }


for (_, op, xf) in self.get_xf_operations_full_old(from_version, self.cg.version.as_ref()) {
let val = match xf {
TransformedResult::BaseMoved(xf_pos) => {
let origin_pos = op.start() as isize;
XFState::XFBy(xf_pos as isize - origin_pos)
},
TransformedResult::DeleteAlreadyHappened => XFState::Cancelled,

for op in self.get_xf_operations_full_raw(from_version, self.cg.version.as_ref()) {
let (val, len) = match op {
TransformedResultRaw::FF(range) => {
(XFState::XFBy(0), range.len())
}
TransformedResultRaw::Apply { xf_pos, op } => {
let origin_pos = op.1.start() as isize;
(XFState::XFBy(xf_pos as isize - origin_pos), op.len())
}
TransformedResultRaw::DeleteAlreadyHappened(range) => {
(XFState::Cancelled, range.len())
}
};

tn_ops.push_rle(RleRun {
val,
len: op.len()
});

tn_ops.push_rle(RleRun { val, len });
}

// for (_, op, xf) in self.get_xf_operations_full_old(from_version, self.cg.version.as_ref()) {
// let val = match xf {
// TransformedResult::BaseMoved(xf_pos) => {
// let origin_pos = op.start() as isize;
// XFState::XFBy(xf_pos as isize - origin_pos)
// },
// TransformedResult::DeleteAlreadyHappened => XFState::Cancelled,
// };
//
// tn_ops.push_rle(RleRun {
// val,
// len: op.len()
// });
// }

dbg!(&tn_ops.len());

// First pass: just write it.
Expand Down
74 changes: 39 additions & 35 deletions src/list/merge.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -81,9 +81,12 @@ impl ListOpLog {

#[cfg(feature = "merge_conflict_checks")]
pub fn has_conflicts_when_merging(&self) -> bool {
let mut iter = TransformedOpsIter::new(&self.cg.graph, &self.cg.agent_assignment,
let mut iter = TransformedOpsIterRaw::new(&self.cg.graph, &self.cg.agent_assignment,
&self.operation_ctx, &self.operations,
&[], self.cg.version.as_ref());
// let mut iter = TransformedOpsIter::new(&self.cg.graph, &self.cg.agent_assignment,
// &self.operation_ctx, &self.operations,
// &[], self.cg.version.as_ref());
for _ in &mut iter {}
iter.concurrent_inserts_collided()
}
Expand Down Expand Up @@ -146,39 +149,40 @@ impl ListOpLog {

(clears, normal_advances, ff)
}
pub fn get_size_stats_during_xf(&self, samples: usize, allow_ff: bool) -> Vec<(LV, usize)> {
let every = usize::max(self.cg.len() / samples, 1);

let (plan, common) = self.cg.graph.make_m1_plan(Some(&self.operations), &[], self.cg.version.as_ref(), allow_ff);
let mut iter = TransformedOpsIter::from_plan(&self.cg.graph, &self.cg.agent_assignment,
&self.operation_ctx, &self.operations,
plan, common);

let mut result = vec![];

let mut emit_next = 0; // Absolute LV.
while let Some((lv, _origin_op, _xf)) = iter.next() {
while emit_next <= lv {
result.push((emit_next, iter.tracker_count()));
emit_next += every;
}
}
// let mut emit_next: isize = 0;
// while let Some((lv, origin_op, _xf)) = iter.next() {
// let len_here = origin_op.len();
// // println!("op {}", len_here);
//
// emit_next -= len_here as isize;
//
// while emit_next < 0 {
// // emit the size now
// result.push((lv, iter.tracker_count()));
// emit_next += every as isize;
// }
// }

result
}
// pub fn get_size_stats_during_xf(&self, samples: usize, allow_ff: bool) -> Vec<(LV, usize)> {
// let every = usize::max(self.cg.len() / samples, 1);
//
// let (plan, common) = self.cg.graph.make_m1_plan(Some(&self.operations), &[], self.cg.version.as_ref(), allow_ff);
// let mut iter = TransformedOpsIter::from_plan(&self.cg.graph, &self.cg.agent_assignment,
// &self.operation_ctx, &self.operations,
// plan, common);
//
// let mut result = vec![];
//
// let mut emit_next = 0; // Absolute LV.
// while let Some((lv, _origin_op, _xf)) = iter.next() {
// while emit_next <= lv {
// result.push((emit_next, iter.tracker_count()));
// emit_next += every;
// }
// }
// // let mut emit_next: isize = 0;
// // while let Some((lv, origin_op, _xf)) = iter.next() {
// // let len_here = origin_op.len();
// // // println!("op {}", len_here);
// //
// // emit_next -= len_here as isize;
// //
// // while emit_next < 0 {
// // // emit the size now
// // result.push((lv, iter.tracker_count()));
// // emit_next += every as isize;
// // }
// // }
//
// result
// }
}


Expand Down Expand Up @@ -206,10 +210,10 @@ impl ListBranch {

pub fn merge(&mut self, oplog: &ListOpLog, merge_frontier: &[LV]) {
// let mut iter = oplog.get_xf_operations_full_raw(self.version.as_ref(), merge_frontier).merge_spans();
let mut iter = oplog.get_xf_operations_full_raw(self.version.as_ref(), merge_frontier);
let iter = oplog.get_xf_operations_full_raw(self.version.as_ref(), merge_frontier);
// println!("merge '{}' at {:?} + {:?}", self.content.to_string(), self.version, merge_frontier);

for xf in &mut iter {
for xf in iter {
// dbg!(&xf);
// dbg!(_lv, &origin_op, &xf);
match xf {
Expand Down
2 changes: 1 addition & 1 deletion src/list_fuzzer_tools.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -12,7 +12,7 @@ use rle::zip::{rle_zip, rle_zip3};
use crate::{AgentId, LV};
use crate::listmerge::simple_oplog::*;

const USE_UNICODE: bool = true;
// const USE_UNICODE: bool = true;

const UCHARS: [char; 23] = [
'a', 'b', 'c', '1', '2', '3', ' ', '\n', // ASCII
Expand Down
25 changes: 3 additions & 22 deletions src/listmerge/advance_retreat.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -69,7 +69,7 @@ impl M2Tracker {
}
}

fn adv_retreat_range(&mut self, mut range: DTRange, incr: i32) {
pub(super) fn adv_retreat_range(&mut self, mut range: DTRange, incr: i32) {
// This method handles both advancing and retreating. In either case, because of the way
// SpanState is designed, we need to either increment or decrement the state of every
// visited item in the LV range.
Expand Down Expand Up @@ -152,32 +152,13 @@ impl M2Tracker {

}

#[inline]
pub(crate) fn advance_by_range(&mut self, range: DTRange) {
self.adv_retreat_range(range, 1);
}

#[inline]
pub(crate) fn retreat_by_range(&mut self, range: DTRange) {
self.adv_retreat_range(range, -1);
}

// // if let Some(mut cursor) = self.range_tree.try_find_item(last_lv) {
// // // Try just modifying the item directly.
// // //
// // // The item will only exist in the range tree at all if it was an insert.
// // let (e, _offset) = cursor.0.get_item(&self.range_tree);
// // // let chunk_start = last_lv - offset;
// // let start = range.start.max(e.id.start);
// // cursor.0.offset = start - e.id.start;
// // let max_len = range.end - start;
// //
// // range.end -= self.range_tree.mutate_entry(
// // &mut cursor,
// // max_len,
// // &mut notify_for(&mut self.index),
// // |e| {
// // e.current_state.mark_not_inserted_yet();
// // }
// // ).0;
// // self.range_tree.emplace_cursor_unknown(cursor);
// // } else {
}
Loading

0 comments on commit 51e884a

Please sign in to comment.