From 18daded1add0730fc519fd8d980e8d5472c99468 Mon Sep 17 00:00:00 2001 From: Bruce Mitchener Date: Sun, 29 Sep 2024 21:11:25 +0700 Subject: [PATCH] Fix typos. --- CHANGELOG.md | 2 +- communication/src/allocator/zero_copy/bytes_slab.rs | 2 +- communication/src/allocator/zero_copy/tcp.rs | 2 +- communication/src/message.rs | 2 +- container/src/lib.rs | 2 +- timely/examples/loopdemo.rs | 2 +- timely/examples/openloop.rs | 2 +- timely/src/progress/broadcast.rs | 2 +- timely/src/progress/change_batch.rs | 2 +- timely/src/progress/subgraph.rs | 2 +- timely/src/synchronization/sequence.rs | 2 +- timely/src/worker.rs | 2 +- 12 files changed, 12 insertions(+), 12 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 133dcaf37..9bd6df0cc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -50,7 +50,7 @@ The address associated with each operator, a `[usize]` used to start with the id The `Worker` and the `Subgraph` operator no longer schedules all of their child dataflows and scopes by default. Instead, they track "active" children and schedule only those. Operators become active by receiving a message, a progress update, or by explicit activation. Some operators, source as `source`, have no inputs and will require explicit activation to run more than once. Operators that yield before completing all of their work (good for you!) should explicitly re-activate themselves to ensure they are re-scheduled even if they receive no further messages or progress updates. Documentation examples for the `source` method demonstrate this. -The `dataflow_using` method has been generalized to support arbitrary dataflow names, loggers, and additional resources the dataflow should keep alive. Its name has been chaged to `dataflow_core`. +The `dataflow_using` method has been generalized to support arbitrary dataflow names, loggers, and additional resources the dataflow should keep alive. Its name has been changed to `dataflow_core`. You can now construct `feedback` operators with a `Default::default()` path summary, which has the ability to not increment timestamps. Instead of panicking, Timely's reachability module will inform you if a non-incrementing cycle is detected, at which point you should probably double check your code. It is not 100% known what the system will do in this case (e.g., the progress tracker may enter a non-terminating loop; this is on you, not us ;)). diff --git a/communication/src/allocator/zero_copy/bytes_slab.rs b/communication/src/allocator/zero_copy/bytes_slab.rs index 05d603def..84635a38d 100644 --- a/communication/src/allocator/zero_copy/bytes_slab.rs +++ b/communication/src/allocator/zero_copy/bytes_slab.rs @@ -10,7 +10,7 @@ use bytes::arc::Bytes; pub struct BytesSlab { buffer: Bytes, // current working buffer. in_progress: Vec>, // buffers shared with workers. - stash: Vec, // reclaimed and resuable buffers. + stash: Vec, // reclaimed and reusable buffers. shift: usize, // current buffer allocation size. valid: usize, // buffer[..valid] are valid bytes. } diff --git a/communication/src/allocator/zero_copy/tcp.rs b/communication/src/allocator/zero_copy/tcp.rs index f2099f516..92334c173 100644 --- a/communication/src/allocator/zero_copy/tcp.rs +++ b/communication/src/allocator/zero_copy/tcp.rs @@ -56,7 +56,7 @@ where // At the start of each iteration, `self.buffer[..self.length]` represents valid // data, and the remaining capacity is available for reading from the reader. // - // Once the buffer fills, we need to copy uncomplete messages to a new shared + // Once the buffer fills, we need to copy incomplete messages to a new shared // allocation and place the existing Bytes into `self.in_progress`, so that it // can be recovered once all readers have read what they need to. let mut active = true; diff --git a/communication/src/message.rs b/communication/src/message.rs index 8d3b325ba..4e126ae49 100644 --- a/communication/src/message.rs +++ b/communication/src/message.rs @@ -144,7 +144,7 @@ impl Message { impl ::std::ops::Deref for Message { type Target = T; fn deref(&self) -> &Self::Target { - // TODO: In principle we have aready decoded, but let's go again + // TODO: In principle we have already decoded, but let's go again match &self.payload { MessageContents::Owned(typed) => { typed }, MessageContents::Arc(typed) => { typed }, diff --git a/container/src/lib.rs b/container/src/lib.rs index a86c09b5a..e22b2471a 100644 --- a/container/src/lib.rs +++ b/container/src/lib.rs @@ -127,7 +127,7 @@ pub trait ContainerBuilder: Default + 'static { pub struct CapacityContainerBuilder{ /// Container that we're writing to. current: C, - /// Emtpy allocation. + /// Empty allocation. empty: Option, /// Completed containers pending to be sent. pending: VecDeque, diff --git a/timely/examples/loopdemo.rs b/timely/examples/loopdemo.rs index f0fcc934e..ad24a8d01 100644 --- a/timely/examples/loopdemo.rs +++ b/timely/examples/loopdemo.rs @@ -20,7 +20,7 @@ fn main() { let mut input = InputHandle::new(); let mut probe = ProbeHandle::new(); - // Create a dataflow that discards input data (just syncronizes). + // Create a dataflow that discards input data (just synchronizes). worker.dataflow(|scope| { let stream = scope.input_from(&mut input); diff --git a/timely/examples/openloop.rs b/timely/examples/openloop.rs index b027d2cee..5c2b07fb2 100644 --- a/timely/examples/openloop.rs +++ b/timely/examples/openloop.rs @@ -23,7 +23,7 @@ fn main() { let mut input = InputHandle::new(); let mut probe = ProbeHandle::new(); - // Create a dataflow that discards input data (just syncronizes). + // Create a dataflow that discards input data (just synchronizes). worker.dataflow(|scope| { scope .input_from(&mut input) // read input. diff --git a/timely/src/progress/broadcast.rs b/timely/src/progress/broadcast.rs index d83d190e1..9ca5e2cb1 100644 --- a/timely/src/progress/broadcast.rs +++ b/timely/src/progress/broadcast.rs @@ -62,7 +62,7 @@ impl Progcaster { self.progress_logging.as_ref().map(|l| { // Pre-allocate enough space; we transfer ownership, so there is not - // an apportunity to re-use allocations (w/o changing the logging + // an opportunity to re-use allocations (w/o changing the logging // interface to accept references). let mut messages = Box::new(Vec::with_capacity(changes.len())); let mut internal = Box::new(Vec::with_capacity(changes.len())); diff --git a/timely/src/progress/change_batch.rs b/timely/src/progress/change_batch.rs index 560df65fc..a78afd797 100644 --- a/timely/src/progress/change_batch.rs +++ b/timely/src/progress/change_batch.rs @@ -184,7 +184,7 @@ where /// Drains the set of updates. /// /// This operation first compacts the set of updates so that the drained results - /// have at most one occurence of each item. + /// have at most one occurrence of each item. /// /// # Examples /// diff --git a/timely/src/progress/subgraph.rs b/timely/src/progress/subgraph.rs index 68c3bf93d..dbe735655 100644 --- a/timely/src/progress/subgraph.rs +++ b/timely/src/progress/subgraph.rs @@ -158,7 +158,7 @@ where let inputs = self.input_messages.len(); let outputs = self.output_capabilities.len(); - // Create empty child zero represenative. + // Create empty child zero representative. self.children[0] = PerOperatorState::empty(outputs, inputs); let mut builder = reachability::Builder::new(); diff --git a/timely/src/synchronization/sequence.rs b/timely/src/synchronization/sequence.rs index a08920191..8c6c4954a 100644 --- a/timely/src/synchronization/sequence.rs +++ b/timely/src/synchronization/sequence.rs @@ -124,7 +124,7 @@ impl Sequencer { // a source that attempts to pull from `recv` and produce commands for everyone source(dataflow, "SequenceInput", move |capability, info| { - // intialize activator, now that we have the address + // initialize activator, now that we have the address activator_source .borrow_mut() .replace(CatchupActivator { diff --git a/timely/src/worker.rs b/timely/src/worker.rs index de335d734..b0af6363b 100644 --- a/timely/src/worker.rs +++ b/timely/src/worker.rs @@ -195,7 +195,7 @@ pub trait AsWorker : Scheduler { /// Constructs a pipeline channel from the worker to itself. /// /// By default this method uses the native channel allocation mechanism, but the expectation is - /// that this behavior will be overriden to be more efficient. + /// that this behavior will be overridden to be more efficient. fn pipeline(&mut self, identifier: usize, address: Rc<[usize]>) -> (ThreadPusher>, ThreadPuller>); /// Allocates a new worker-unique identifier.