Renamed OrderedColumnLeaf to ColumnLayer

`OrderedColumnLeaf` was a bit of a misnomer, it implies that the collection
is inherently ordered when it isn't. This pivots `OrderedColumnLeaf` to
be more of a general purpose collection primitive that's used as a building
block of other things, such as `OrdZSet`, `IndexedOrdZSet`, `HashedKVBatch`
and unordered batches

Author: Kixiron

benches/column_leaf.rs

@@ -2,7 +2,7 @@ use criterion::{black_box, criterion_group, criterion_main, BatchSize, Criterion
 use dbsp::{
     algebra::{AddAssignByRef, AddByRef, MonoidValue, NegByRef},
     trace::layers::{
-        column_leaf::{OrderedColumnLeaf, OrderedColumnLeafBuilder, UnorderedColumnLeafBuilder},
+        column_layer::{ColumnLayer, ColumnLayerBuilder, UnorderedColumnLayerBuilder},
         Builder, MergeBuilder, Trie, TupleBuilder,
     },
 };
@@ -25,37 +25,37 @@ where
     data
 }
 
-fn data_builder<K, R>(length: usize) -> UnorderedColumnLeafBuilder<K, R>
+fn data_builder<K, R>(length: usize) -> UnorderedColumnLayerBuilder<K, R>
 where
     K: Ord + Clone,
     R: MonoidValue,
     Standard: Distribution<(K, R)>,
 {
     let mut rng = Xoshiro256StarStar::from_seed(SEED);
 
-    let mut builder = UnorderedColumnLeafBuilder::new();
+    let mut builder = UnorderedColumnLayerBuilder::new();
     for _ in 0..length {
         builder.push_tuple(rng.gen());
     }
     builder
 }
 
-fn data_leaf<K, R>(length: usize) -> OrderedColumnLeaf<K, R>
+fn data_leaf<K, R>(length: usize) -> ColumnLayer<K, R>
 where
     K: Ord + Clone,
     R: MonoidValue,
     Standard: Distribution<(K, R)>,
 {
     let mut rng = Xoshiro256StarStar::from_seed(SEED);
 
-    let mut builder = UnorderedColumnLeafBuilder::with_capacity(length);
+    let mut builder = UnorderedColumnLayerBuilder::with_capacity(length);
     for _ in 0..length {
         builder.push_tuple(rng.gen());
     }
     builder.done()
 }
 
-fn data_leaves<K, R>(length: usize) -> (OrderedColumnLeaf<K, R>, OrderedColumnLeaf<K, R>)
+fn data_leaves<K, R>(length: usize) -> (ColumnLayer<K, R>, ColumnLayer<K, R>)
 where
     K: Ord + Clone,
     R: MonoidValue,
@@ -64,8 +64,8 @@ where
     let mut rng = Xoshiro256StarStar::from_seed(SEED);
 
     let (mut right, mut left) = (
-        UnorderedColumnLeafBuilder::with_capacity(length / 2),
-        UnorderedColumnLeafBuilder::with_capacity(length / 2),
+        UnorderedColumnLayerBuilder::with_capacity(length / 2),
+        UnorderedColumnLayerBuilder::with_capacity(length / 2),
     );
     for _ in 0..length / 2 {
         left.push_tuple(rng.gen());

benches/gdelt/personal_network.rs

@@ -36,7 +36,7 @@ use dbsp::{
     trace::{
         consolidation,
         layers::{
-            column_leaf::{OrderedColumnLeaf, OrderedColumnLeafBuilder},
+            column_layer::{ColumnLayer, ColumnLayerBuilder},
             ordered::OrderedBuilder,
             Builder as LayerBuilder, MergeBuilder, OrdOffset, TupleBuilder,
         },
@@ -437,15 +437,15 @@ struct HashedKVBatch<K, V, R, O = usize> {
     offsets: Vec<O>,
     // The value+diff pairs associated with any given key can be fetched with
     // `values[offsets[keys[&key]]..offsets[keys[&key] + 1]]`
-    values: OrderedColumnLeaf<V, R>,
+    values: ColumnLayer<V, R>,
 }
 
 impl<K, V, R, O> HashedKVBatch<K, V, R, O> {
     fn probe(&self) -> HashedKVBatchProbe<'_, K, V, R, O> {
         HashedKVBatchProbe::new(self)
     }
 
-    fn from_builder(builder: OrderedBuilder<K, OrderedColumnLeafBuilder<V, R>, O>) -> Self
+    fn from_builder(builder: OrderedBuilder<K, ColumnLayerBuilder<V, R>, O>) -> Self
     where
         K: DBData,
         V: DBData,
@@ -551,8 +551,7 @@ where
         consolidation::consolidate(&mut inputs);
 
         let mut keys = HashMap::with_capacity_and_hasher(inputs.len(), Xxh3Builder::new());
-        let mut values =
-            <OrderedColumnLeafBuilder<_, _> as TupleBuilder>::with_capacity(inputs.len());
+        let mut values = <ColumnLayerBuilder<_, _> as TupleBuilder>::with_capacity(inputs.len());
         let mut offsets = Vec::with_capacity(inputs.len() + 1);
         offsets.push(O::zero());
 
@@ -762,7 +761,7 @@ impl<'a, V, R> ValueConsumer<'a, V, R, ()> for HashedValueConsumer<'a, V, R> {
     }
 }
 
-type RawKVBuilder<K, V, R, O> = OrderedBuilder<K, OrderedColumnLeafBuilder<V, R>, O>;
+type RawKVBuilder<K, V, R, O> = OrderedBuilder<K, ColumnLayerBuilder<V, R>, O>;
 
 #[derive(SizeOf)]
 struct HashedKVBuilder<K, V, R, O = usize>

src/operator/aggregate/average.rs

@@ -3,7 +3,7 @@ use crate::{
         AddAssignByRef, AddByRef, GroupValue, HasOne, HasZero, IndexedZSet, MulByRef, NegByRef,
         ZRingValue,
     },
-    trace::layers::{column_leaf::OrderedColumnLeaf, ordered::OrderedLayer},
+    trace::layers::{column_layer::ColumnLayer, ordered::OrderedLayer},
     utils::VecExt,
     Circuit, DBData, DBTimestamp, OrdIndexedZSet, Stream,
 };
@@ -291,7 +291,7 @@ where
     }
 
     // Safety: `averages.len() == diffs.len()`
-    let averages = unsafe { OrderedColumnLeaf::from_parts(averages, diffs) };
+    let averages = unsafe { ColumnLayer::from_parts(averages, diffs) };
 
     // Create a new `OrdIndexedZSet` from our components, notably this doesn't touch
     // `keys`, `offs` or `diffs` which means we don't allocate new vectors for them

src/trace/cursor/mod.rs

@@ -89,9 +89,7 @@ pub trait Cursor<'s, K, V, T, R> {
     /// is more convenient (and potentially more efficient) than using
     /// [`Self::map_times`] to iterate over a single value.
     ///
-    /// # Panics
-    ///
-    /// Panics if not `self.key_valid() && self.val_valid()`.
+    /// If the current key and value are not valid, behavior is unspecified
     fn weight(&mut self) -> R
     where
         T: PartialEq<()>;
@@ -148,7 +146,7 @@ pub trait UnorderedCursor<'a, K, T, V, R> {
     ///
     /// A value of `false` indicates that the cursor has exhausted all values
     /// for this key.
-    fn value_valid(&self) -> bool;
+    fn val_valid(&self) -> bool;
 
     /// A reference to the current key. Panics if invalid.
     fn key(&self) -> &K;
@@ -162,8 +160,8 @@ pub trait UnorderedCursor<'a, K, T, V, R> {
     }
 
     /// Returns a reference to the current value, if valid.
-    fn get_value(&self) -> Option<&V> {
-        self.value_valid().then(|| self.value())
+    fn get_val(&self) -> Option<&V> {
+        self.val_valid().then(|| self.value())
     }
 
     /// Returns the weight associated with the current key/value pair.

src/trace/layers/column_leaf/builders.rs renamed to src/trace/layers/column_layer/builders.rs

@@ -2,9 +2,7 @@ use crate::{
     algebra::{AddAssignByRef, HasZero},
     trace::{
         consolidation::consolidate_from,
-        layers::{
-            advance, column_leaf::OrderedColumnLeaf, Builder, MergeBuilder, Trie, TupleBuilder,
-        },
+        layers::{advance, column_layer::ColumnLayer, Builder, MergeBuilder, Trie, TupleBuilder},
     },
     utils::assume,
 };
@@ -16,13 +14,13 @@ use std::{
 
 /// A builder for ordered values
 #[derive(SizeOf)]
-pub struct OrderedColumnLeafBuilder<K, R> {
+pub struct ColumnLayerBuilder<K, R> {
     // Invariant: `keys.len() == diffs.len()`
     keys: Vec<K>,
     diffs: Vec<R>,
 }
 
-impl<K, R> OrderedColumnLeafBuilder<K, R> {
+impl<K, R> ColumnLayerBuilder<K, R> {
     /// Get the length of the current builder
     pub(crate) fn len(&self) -> usize {
         unsafe { self.assume_invariants() }
@@ -39,12 +37,12 @@ impl<K, R> OrderedColumnLeafBuilder<K, R> {
     }
 }
 
-impl<K, R> Builder for OrderedColumnLeafBuilder<K, R>
+impl<K, R> Builder for ColumnLayerBuilder<K, R>
 where
     K: Ord + Clone,
     R: Eq + HasZero + AddAssign + AddAssignByRef + Clone,
 {
-    type Trie = OrderedColumnLeaf<K, R>;
+    type Trie = ColumnLayer<K, R>;
 
     fn boundary(&mut self) -> usize {
         unsafe { self.assume_invariants() }
@@ -55,14 +53,14 @@ where
         unsafe { self.assume_invariants() }
 
         // TODO: Should we call `.shrink_to_fit()` here?
-        OrderedColumnLeaf {
+        ColumnLayer {
             keys: self.keys,
             diffs: self.diffs,
         }
     }
 }
 
-impl<K, R> MergeBuilder for OrderedColumnLeafBuilder<K, R>
+impl<K, R> MergeBuilder for ColumnLayerBuilder<K, R>
 where
     K: Ord + Clone,
     R: Eq + HasZero + AddAssign + AddAssignByRef + Clone,
@@ -171,7 +169,7 @@ where
     }
 }
 
-impl<K, R> TupleBuilder for OrderedColumnLeafBuilder<K, R>
+impl<K, R> TupleBuilder for ColumnLayerBuilder<K, R>
 where
     K: Ord + Clone,
     R: Eq + HasZero + AddAssign + AddAssignByRef + Clone,
@@ -220,13 +218,13 @@ where
 
 /// A builder for unordered values
 #[derive(Debug, Clone, SizeOf)]
-pub struct UnorderedColumnLeafBuilder<K, R> {
+pub struct UnorderedColumnLayerBuilder<K, R> {
     tuples: Vec<(K, R)>,
     boundary: usize,
 }
 
-impl<K, R> UnorderedColumnLeafBuilder<K, R> {
-    /// Create a new `UnorderedColumnLeafBuilder`
+impl<K, R> UnorderedColumnLayerBuilder<K, R> {
+    /// Create a new `UnorderedColumnLayerBuilder`
     pub const fn new() -> Self {
         Self {
             tuples: Vec::new(),
@@ -240,12 +238,12 @@ impl<K, R> UnorderedColumnLeafBuilder<K, R> {
     }
 }
 
-impl<K, R> Builder for UnorderedColumnLeafBuilder<K, R>
+impl<K, R> Builder for UnorderedColumnLayerBuilder<K, R>
 where
     K: Ord + Clone,
     R: HasZero + AddAssign + AddAssignByRef + Eq + Clone,
 {
-    type Trie = OrderedColumnLeaf<K, R>;
+    type Trie = ColumnLayer<K, R>;
 
     fn boundary(&mut self) -> usize {
         consolidate_from(&mut self.tuples, self.boundary);
@@ -258,11 +256,11 @@ where
 
         let (keys, diffs) = self.tuples.into_iter().unzip();
         // TODO: The indices buffer is dropped here, can we reuse it for other builders?
-        OrderedColumnLeaf { keys, diffs }
+        ColumnLayer { keys, diffs }
     }
 }
 
-impl<K, R> TupleBuilder for UnorderedColumnLeafBuilder<K, R>
+impl<K, R> TupleBuilder for UnorderedColumnLayerBuilder<K, R>
 where
     K: Ord + Clone,
     R: HasZero + AddAssign + AddAssignByRef + Eq + Clone,
@@ -303,7 +301,7 @@ where
     }
 }
 
-impl<K, R> Default for UnorderedColumnLeafBuilder<K, R> {
+impl<K, R> Default for UnorderedColumnLayerBuilder<K, R> {
     fn default() -> Self {
         Self::new()
     }

src/trace/layers/column_leaf/consumer.rs renamed to src/trace/layers/column_layer/consumer.rs

@@ -1,6 +1,6 @@
 use crate::{
     trace::{
-        layers::{advance, column_leaf::OrderedColumnLeaf},
+        layers::{advance, column_layer::ColumnLayer},
         Consumer, ValueConsumer,
     },
     utils::cursor_position_oob,
@@ -12,16 +12,16 @@ use std::mem::MaybeUninit;
 // TODO: Fuzz for panic and drop safety
 
 #[derive(Debug)]
-pub struct ColumnLeafConsumer<K, R> {
+pub struct ColumnLayerConsumer<K, R> {
     // Invariant: `storage.len <= self.position`, if `storage.len == self.position` the cursor is
     // exhausted
     position: usize,
     // Invariant: `storage.keys[position..]` and `storage.diffs[position..]` are all valid
-    storage: OrderedColumnLeaf<MaybeUninit<K>, MaybeUninit<R>>,
+    storage: ColumnLayer<MaybeUninit<K>, MaybeUninit<R>>,
 }
 
-impl<K, R> Consumer<K, (), R, ()> for ColumnLeafConsumer<K, R> {
-    type ValueConsumer<'a> = ColumnLeafValues<'a, K, R>
+impl<K, R> Consumer<K, (), R, ()> for ColumnLayerConsumer<K, R> {
+    type ValueConsumer<'a> = ColumnLayerValues<'a, K, R>
     where
         Self: 'a;
 
@@ -50,7 +50,7 @@ impl<K, R> Consumer<K, (), R, ()> for ColumnLeafConsumer<K, R> {
         // Copy out the key and diff
         let key = unsafe { self.storage.keys[idx].assume_init_read() };
 
-        (key, ColumnLeafValues::new(self))
+        (key, ColumnLayerValues::new(self))
     }
 
     fn seek_key(&mut self, key: &K)
@@ -75,40 +75,40 @@ impl<K, R> Consumer<K, (), R, ()> for ColumnLeafConsumer<K, R> {
     }
 }
 
-impl<K, R> From<OrderedColumnLeaf<K, R>> for ColumnLeafConsumer<K, R> {
+impl<K, R> From<ColumnLayer<K, R>> for ColumnLayerConsumer<K, R> {
     #[inline]
-    fn from(leaf: OrderedColumnLeaf<K, R>) -> Self {
+    fn from(leaf: ColumnLayer<K, R>) -> Self {
         Self {
             position: 0,
             storage: leaf.into_uninit(),
         }
     }
 }
 
-impl<K, R> Drop for ColumnLeafConsumer<K, R> {
+impl<K, R> Drop for ColumnLayerConsumer<K, R> {
     fn drop(&mut self) {
         // Drop all remaining elements
         unsafe { self.storage.drop_range(self.position..) }
     }
 }
 
 #[derive(Debug)]
-pub struct ColumnLeafValues<'a, K, R> {
+pub struct ColumnLayerValues<'a, K, R> {
     done: bool,
-    consumer: &'a mut ColumnLeafConsumer<K, R>,
+    consumer: &'a mut ColumnLayerConsumer<K, R>,
 }
 
-impl<'a, K, R> ColumnLeafValues<'a, K, R> {
+impl<'a, K, R> ColumnLayerValues<'a, K, R> {
     #[inline]
-    fn new(consumer: &'a mut ColumnLeafConsumer<K, R>) -> Self {
+    fn new(consumer: &'a mut ColumnLayerConsumer<K, R>) -> Self {
         Self {
             done: false,
             consumer,
         }
     }
 }
 
-impl<'a, K, R> ValueConsumer<'a, (), R, ()> for ColumnLeafValues<'a, K, R> {
+impl<'a, K, R> ValueConsumer<'a, (), R, ()> for ColumnLayerValues<'a, K, R> {
     fn value_valid(&self) -> bool {
         !self.done
     }
@@ -131,7 +131,7 @@ impl<'a, K, R> ValueConsumer<'a, (), R, ()> for ColumnLeafValues<'a, K, R> {
     }
 }
 
-impl<'a, K, R> Drop for ColumnLeafValues<'a, K, R> {
+impl<'a, K, R> Drop for ColumnLayerValues<'a, K, R> {
     fn drop(&mut self) {
         // If the value consumer was never used, drop the difference value
         if !self.done {