Non-working moment

Author: frankmcsherry

differential-dataflow/src/operators/arrange/agent.rs

@@ -36,13 +36,12 @@ pub struct TraceAgent<Tr: TraceReader> {
     logging: Option<crate::logging::Logger>,
 }
 
+use crate::trace::implementations::LaidOut;
+impl<Tr: TraceReader> LaidOut for TraceAgent<Tr> {
+    type Layout = Tr::Layout;
+}
+
 impl<Tr: TraceReader> TraceReader for TraceAgent<Tr> {
-    type Key<'a> = Tr::Key<'a>;
-    type Val<'a> = Tr::Val<'a>;
-    type Time = Tr::Time;
-    type TimeGat<'a> = Tr::TimeGat<'a>;
-    type Diff = Tr::Diff;
-    type DiffGat<'a> = Tr::DiffGat<'a>;
 
     type Batch = Tr::Batch;
     type Storage = Tr::Storage;

differential-dataflow/src/trace/implementations/mod.rs

@@ -100,7 +100,7 @@ pub trait Layout {
     /// Container for times.
     type TimeContainer: BatchContainer<Owned: Lattice + timely::progress::Timestamp>;
     /// Container for diffs.
-    type DiffContainer: BatchContainer<Owned: Semigroup>;
+    type DiffContainer: BatchContainer<Owned: Semigroup + 'static>;
     /// Container for offsets.
     type OffsetContainer: for<'a> BatchContainer<ReadItem<'a> = usize>;
 }
@@ -126,7 +126,7 @@ pub trait LayoutExt : LaidOut<Layout: Layout<KeyContainer = Self::KeyContainer,
     /// Alias for an borrowed time of a layout.
     type TimeGat<'a>: Copy + Ord;
     /// Alias for an owned diff of a layout.
-    type Diff: Semigroup;
+    type Diff: Semigroup + 'static;
     /// Alias for an borrowed diff of a layout.
     type DiffGat<'a>: Copy + Ord;
 

differential-dataflow/src/trace/implementations/ord_neu.rs

@@ -322,13 +322,11 @@ pub mod val_batch {
         pub updates: usize,
     }
 
+    impl<L: Layout> LaidOut for OrdValBatch<L> {
+        type Layout = L;
+    }
+
     impl<L: Layout> BatchReader for OrdValBatch<L> {
-        type Key<'a> = layout::KeyRef<'a, L>;
-        type Val<'a> = layout::ValRef<'a, L>;
-        type Time = layout::Time<L>;
-        type TimeGat<'a> = layout::TimeRef<'a, L>;
-        type Diff = layout::Diff<L>;
-        type DiffGat<'a> = layout::DiffRef<'a, L>;
 
         type Cursor = OrdValCursor<L>;
         fn cursor(&self) -> Self::Cursor {
@@ -796,14 +794,11 @@ pub mod key_batch {
         pub updates: usize,
     }
 
-    impl<L: for<'a> Layout<ValContainer: BatchContainer<ReadItem<'a> = &'a ()>>> BatchReader for OrdKeyBatch<L> {
+    impl<L: for<'a> Layout<ValContainer: BatchContainer<ReadItem<'a> = &'a ()>>> LaidOut for OrdKeyBatch<L> {
+        type Layout = L;
+    }
 
-        type Key<'a> = layout::KeyRef<'a, L>;
-        type Val<'a> = &'a ();
-        type Time = layout::Time<L>;
-        type TimeGat<'a> = layout::TimeRef<'a, L>;
-        type Diff = layout::Diff<L>;
-        type DiffGat<'a> = layout::DiffRef<'a, L>;
+    impl<L: for<'a> Layout<ValContainer: BatchContainer<ReadItem<'a> = &'a ()>>> BatchReader for OrdKeyBatch<L> {
 
         type Cursor = OrdKeyCursor<L>;
         fn cursor(&self) -> Self::Cursor {

differential-dataflow/src/trace/implementations/rhh.rs

@@ -273,18 +273,19 @@ mod val_batch {
         pub updates: usize,
     }
 
-    impl<L: Layout> BatchReader for RhhValBatch<L>
+    impl<L: Layout> LaidOut for RhhValBatch<L>
     where
         layout::Key<L>: Default + HashOrdered,
         for<'a> layout::KeyRef<'a, L>: HashOrdered,
     {
-        type Key<'a> = layout::KeyRef<'a, L>;
-        type Val<'a> = layout::ValRef<'a, L>;
-        type Time = layout::Time<L>;
-        type TimeGat<'a> = layout::TimeRef<'a, L>;
-        type Diff = layout::Diff<L>;
-        type DiffGat<'a> = layout::DiffRef<'a, L>;
+        type Layout = L;
+    }
 
+    impl<L: Layout> BatchReader for RhhValBatch<L>
+    where
+        layout::Key<L>: Default + HashOrdered,
+        for<'a> layout::KeyRef<'a, L>: HashOrdered,
+    {
         type Cursor = RhhValCursor<L>;
         fn cursor(&self) -> Self::Cursor {
             let mut cursor = RhhValCursor {

differential-dataflow/src/trace/implementations/spine_fueled.rs

@@ -99,13 +99,18 @@ pub struct Spine<B: Batch> {
     exert_logic: Option<ExertionLogic>,
 }
 
+use crate::trace::LaidOut;
+impl<B: Batch> LaidOut for Spine<B> {
+    type Layout = B::Layout;
+}
+
 impl<B: Batch+Clone+'static> TraceReader for Spine<B> {
-    type Key<'a> = B::Key<'a>;
-    type Val<'a> = B::Val<'a>;
-    type Time = B::Time;
-    type TimeGat<'a> = B::TimeGat<'a>;
-    type Diff = B::Diff;
-    type DiffGat<'a> = B::DiffGat<'a>;
+    // type Key<'a> = B::Key<'a>;
+    // type Val<'a> = B::Val<'a>;
+    // type Time = B::Time;
+    // type TimeGat<'a> = B::TimeGat<'a>;
+    // type Diff = B::Diff;
+    // type DiffGat<'a> = B::DiffGat<'a>;
 
     type Batch = B;
     type Storage = Vec<B>;

differential-dataflow/src/trace/mod.rs

@@ -16,8 +16,6 @@ use timely::progress::{Antichain, frontier::AntichainRef};
 use timely::progress::Timestamp;
 
 use crate::logging::Logger;
-use crate::difference::Semigroup;
-use crate::lattice::Lattice;
 pub use self::cursor::Cursor;
 pub use self::description::Description;
 
@@ -46,34 +44,48 @@ pub type ExertionLogic = std::sync::Arc<dyn for<'a> Fn(&'a [(usize, usize, usize
 /// This is a restricted interface to the more general `Trace` trait, which extends this trait with further methods
 /// to update the contents of the trace. These methods are used to examine the contents, and to update the reader's
 /// capabilities (which may release restrictions on the mutations to the underlying trace and cause work to happen).
-pub trait TraceReader {
-
-    /// Key by which updates are indexed.
-    type Key<'a>: Copy + Clone + Ord;
-    /// Values associated with keys.
-    type Val<'a>: Copy + Clone;
-    /// Timestamps associated with updates
-    type Time: Timestamp + Lattice + Ord + Clone;
-    /// Borrowed form of timestamp.
-    type TimeGat<'a>: Copy;
-    /// Owned form of update difference.
-    type Diff: Semigroup + 'static;
-    /// Borrowed form of update difference.
-    type DiffGat<'a> : Copy;
-
-    /// An owned copy of a reference to a time.
-    #[inline(always)] fn owned_time(time: Self::TimeGat<'_>) -> Self::Time { Self::Cursor::owned_time(time) }
-    /// An owned copy of a reference to a diff.
-    #[inline(always)] fn owned_diff(diff: Self::DiffGat<'_>) -> Self::Diff { Self::Cursor::owned_diff(diff) }
+pub trait TraceReader : LayoutExt {
 
     /// The type of an immutable collection of updates.
-    type Batch: for<'a> BatchReader<Key<'a> = Self::Key<'a>, Val<'a> = Self::Val<'a>, Time = Self::Time, TimeGat<'a> = Self::TimeGat<'a>, Diff = Self::Diff, DiffGat<'a> = Self::DiffGat<'a>>+Clone+'static;
+    type Batch:
+        'static +
+        Clone +
+        BatchReader +
+        LaidOut<Layout = Self::Layout> +
+        for<'a> LayoutExt<
+            Key<'a> = Self::Key<'a>,
+            Val<'a> = Self::Val<'a>,
+            Time = Self::Time,
+            TimeGat<'a> = Self::TimeGat<'a>,
+            Diff = Self::Diff,
+            DiffGat<'a> = Self::DiffGat<'a>,
+            KeyContainer = Self::KeyContainer,
+            ValContainer = Self::ValContainer,
+            TimeContainer = Self::TimeContainer,
+            DiffContainer = Self::DiffContainer,
+        >;
+
 
     /// Storage type for `Self::Cursor`. Likely related to `Self::Batch`.
     type Storage;
 
     /// The type used to enumerate the collections contents.
-    type Cursor: for<'a> Cursor<Storage=Self::Storage, Key<'a> = Self::Key<'a>, Val<'a> = Self::Val<'a>, Time = Self::Time, TimeGat<'a> = Self::TimeGat<'a>, Diff = Self::Diff, DiffGat<'a> = Self::DiffGat<'a>>;
+    type Cursor:
+        Cursor<Storage=Self::Storage> +
+        LaidOut<Layout = Self::Layout> +
+        for<'a> LayoutExt<
+            Key<'a> = Self::Key<'a>,
+            Val<'a> = Self::Val<'a>,
+            Time = Self::Time,
+            TimeGat<'a> = Self::TimeGat<'a>,
+            Diff = Self::Diff,
+            DiffGat<'a> = Self::DiffGat<'a>,
+            KeyContainer = Self::KeyContainer,
+            ValContainer = Self::ValContainer,
+            TimeContainer = Self::TimeContainer,
+            DiffContainer = Self::DiffContainer,
+        >;
+
 
     /// Provides a cursor over updates contained in the trace.
     fn cursor(&mut self) -> (Self::Cursor, Self::Storage) {
@@ -221,34 +233,34 @@ pub trait Trace : TraceReader<Batch: Batch> {
     fn close(&mut self);
 }
 
+use crate::trace::implementations::LaidOut;
+
 /// A batch of updates whose contents may be read.
 ///
 /// This is a restricted interface to batches of updates, which support the reading of the batch's contents,
 /// but do not expose ways to construct the batches. This trait is appropriate for views of the batch, and is
 /// especially useful for views derived from other sources in ways that prevent the construction of batches
 /// from the type of data in the view (for example, filtered views, or views with extended time coordinates).
-pub trait BatchReader : Sized {
-    /// Key by which updates are indexed.
-    type Key<'a>: Copy + Clone + Ord;
-    /// Values associated with keys.
-    type Val<'a>: Copy + Clone;
-    /// Timestamps associated with updates
-    type Time: Timestamp + Lattice + Ord + Clone;
-    /// Borrowed form of timestamp.
-    type TimeGat<'a>: Copy;
-    /// Owned form of update difference.
-    type Diff: Semigroup + 'static;
-    /// Borrowed form of update difference.
-    type DiffGat<'a> : Copy;
-
-    /// An owned copy of a reference to a time.
-    #[inline(always)] fn owned_time(time: Self::TimeGat<'_>) -> Self::Time { Self::Cursor::owned_time(time) }
-    /// An owned copy of a reference to a diff.
-    #[inline(always)] fn owned_diff(diff: Self::DiffGat<'_>) -> Self::Diff { Self::Cursor::owned_diff(diff) }
+pub trait BatchReader : LayoutExt + Sized {
 
     /// The type used to enumerate the batch's contents.
-    type Cursor: for<'a> Cursor<Storage=Self, Key<'a> = Self::Key<'a>, Val<'a> = Self::Val<'a>, Time = Self::Time, TimeGat<'a> = Self::TimeGat<'a>, Diff = Self::Diff, DiffGat<'a> = Self::DiffGat<'a>>;
-    /// Acquires a cursor to the batch's contents.
+    type Cursor:
+        Cursor<Storage=Self> +
+        LaidOut<Layout = Self::Layout> +
+        for<'a> LayoutExt<
+            Key<'a> = Self::Key<'a>,
+            Val<'a> = Self::Val<'a>,
+            Time = Self::Time,
+            TimeGat<'a> = Self::TimeGat<'a>,
+            Diff = Self::Diff,
+            DiffGat<'a> = Self::DiffGat<'a>,
+            KeyContainer = Self::KeyContainer,
+            ValContainer = Self::ValContainer,
+            TimeContainer = Self::TimeContainer,
+            DiffContainer = Self::DiffContainer,
+        >;
+
+      /// Acquires a cursor to the batch's contents.
     fn cursor(&self) -> Self::Cursor;
     /// The number of updates in the batch.
     fn len(&self) -> usize;
@@ -359,13 +371,11 @@ pub mod rc_blanket_impls {
     use timely::progress::{Antichain, frontier::AntichainRef};
     use super::{Batch, BatchReader, Builder, Merger, Cursor, Description};
 
+    impl<B: BatchReader> LaidOut for Rc<B> {
+        type Layout = B::Layout;
+    }
+
     impl<B: BatchReader> BatchReader for Rc<B> {
-        type Key<'a> = B::Key<'a>;
-        type Val<'a> = B::Val<'a>;
-        type Time = B::Time;
-        type TimeGat<'a> = B::TimeGat<'a>;
-        type Diff = B::Diff;
-        type DiffGat<'a> = B::DiffGat<'a>;
 
         /// The type used to enumerate the batch's contents.
         type Cursor = RcBatchCursor<B::Cursor>;

differential-dataflow/src/trace/wrappers/enter.rs

@@ -25,18 +25,25 @@ impl<Tr: TraceReader + Clone, TInner> Clone for TraceEnter<Tr, TInner> {
     }
 }
 
-impl<Tr, TInner> TraceReader for TraceEnter<Tr, TInner>
+impl<Tr, TInner> LaidOut for TraceEnter<Tr, TInner>
 where
     Tr: TraceReader<Batch: Clone>,
     TInner: Refines<Tr::Time>+Lattice,
 {
-    type Key<'a> = Tr::Key<'a>;
-    type Val<'a> = Tr::Val<'a>;
-    type Time = TInner;
-    type TimeGat<'a> = &'a TInner;
-    type Diff = Tr::Diff;
-    type DiffGat<'a> = Tr::DiffGat<'a>;
+    type Layout = (
+        <Tr::Layout as Layout>::KeyContainer,
+        <Tr::Layout as Layout>::ValContainer,
+        Vec<TInner>,
+        <Tr::Layout as Layout>::DiffContainer,
+        <Tr::Layout as Layout>::OffsetContainer,
+    );
+}
 
+impl<Tr, TInner> TraceReader for TraceEnter<Tr, TInner>
+where
+    Tr: TraceReader<Batch: Clone>,
+    TInner: Refines<Tr::Time>+Lattice,
+{
     type Batch = BatchEnter<Tr::Batch, TInner>;
     type Storage = Tr::Storage;
     type Cursor = CursorEnter<Tr::Cursor, TInner>;
@@ -109,18 +116,25 @@ pub struct BatchEnter<B, TInner> {
     description: Description<TInner>,
 }
 
-impl<B, TInner> BatchReader for BatchEnter<B, TInner>
+impl<B, TInner> LaidOut for BatchEnter<B, TInner>
 where
     B: BatchReader,
     TInner: Refines<B::Time>+Lattice,
 {
-    type Key<'a> = B::Key<'a>;
-    type Val<'a> = B::Val<'a>;
-    type Time = TInner;
-    type TimeGat<'a> = &'a TInner;
-    type Diff = B::Diff;
-    type DiffGat<'a> = B::DiffGat<'a>;
+    type Layout = (
+        <B::Layout as Layout>::KeyContainer,
+        <B::Layout as Layout>::ValContainer,
+        Vec<TInner>,
+        <B::Layout as Layout>::DiffContainer,
+        <B::Layout as Layout>::OffsetContainer,
+    );
+}
 
+impl<B, TInner> BatchReader for BatchEnter<B, TInner>
+where
+    B: BatchReader,
+    TInner: Refines<B::Time>+Lattice,
+{
     type Cursor = BatchCursorEnter<B::Cursor, TInner>;
 
     fn cursor(&self) -> Self::Cursor {