RELEASES.md

Release rayon 1.9.0 (2024-02-27)

• The new methods IndexedParallelIterator::by_exponential_blocks and by_uniform_blocks allow processing items in smaller groups at a time.
• The new iter::walk_tree, walk_tree_prefix, and walk_tree_postfix functions enable custom parallel iteration over tree-like structures.
• The new method ParallelIterator::collect_vec_list returns items as a linked list of vectors, which is an efficient mode of parallel collection used by many of the internal implementations of collect.
• The new methods ParallelSliceMut::par_split_inclusive_mut, ParallelSlice::par_split_inclusive, and ParallelString::par_split_inclusive all work like a normal split but keeping the separator as part of the left slice.
• The new ParallelString::par_split_ascii_whitespace splits only on ASCII whitespace, which is faster than including Unicode multi-byte whitespace.
• OsString now implements FromParallelIterator<_> and ParallelExtend<_> for a few item types similar to the standard FromIterator and Extend.
• The internal Pattern trait for string methods is now implemented for [char; N] and &[char; N], matching any of the given characters.

Release rayon 1.8.1 / rayon-core 1.12.1 (2024-01-17)

• The new "web_spin_lock" crate feature makes mutexes spin on the main browser thread in WebAssembly, rather than suffer an error about forbidden atomics.wait if they were to block in that context. Thanks @RReverser!

Release rayon 1.8.0 / rayon-core 1.12.0 (2023-09-20)

• The minimum supported rustc is now 1.63.
• Added ThreadPoolBuilder::use_current_thread to use the builder thread as part of the new thread pool. That thread does not run the pool's main loop, but it may participate in work-stealing if it yields to rayon in some way.
• Implemented FromParallelIterator<T> for Box<[T]>, Rc<[T]>, and Arc<[T]>, as well as FromParallelIterator<Box<str>> and ParallelExtend<Box<str>> for String.
• ThreadPoolBuilder::build_scoped now uses std::thread::scope.
• The default number of threads is now determined using std::thread::available_parallelism instead of the num_cpus crate.
• The internal logging facility has been removed, reducing bloat for all users.
• Many smaller performance tweaks and documentation updates.

Release rayon 1.7.0 / rayon-core 1.11.0 (2023-03-03)

• The minimum supported rustc is now 1.59.
• Added a fallback when threading is unsupported.
• The new ParallelIterator::take_any and skip_any methods work like unordered IndexedParallelIterator::take and skip, counting items in whatever order they are visited in parallel.
• The new ParallelIterator::take_any_while and skip_any_while methods work like unordered Iterator::take_while and skip_while, which previously had no parallel equivalent. The "while" condition may be satisfied from anywhere in the parallel iterator, affecting all future items regardless of position.
• The new yield_now and yield_local functions will cooperatively yield execution to Rayon, either trying to execute pending work from the entire pool or from just the local deques of the current thread, respectively.

Release rayon-core 1.10.2 (2023-01-22)

• Fixed miri-reported UB for SharedReadOnly tags protected by a call.

Release rayon 1.6.1 (2022-12-09)

• Simplified par_bridge to only pull one item at a time from the iterator, without batching. Threads that are waiting for iterator items will now block appropriately rather than spinning CPU. (Thanks @njaard!)
• Added protection against recursion in par_bridge, so iterators that also invoke rayon will not cause mutex recursion deadlocks.

Release rayon-core 1.10.1 (2022-11-18)

• Fixed a race condition with threads going to sleep while a broadcast starts.

Release rayon 1.6.0 / rayon-core 1.10.0 (2022-11-18)

• The minimum supported rustc is now 1.56.
• The new IndexedParallelIterator::fold_chunks and fold_chunks_with methods work like ParallelIterator::fold and fold_with with fixed-size chunks of items. This may be useful for predictable batching performance, without the allocation overhead of IndexedParallelIterator::chunks.
• New "broadcast" methods run a given function on all threads in the pool. These run at a sort of reduced priority after each thread has exhausted their local work queue, but before they attempt work-stealing from other threads.
  • The global broadcast function and ThreadPool::broadcast method will block until completion, returning a Vec of all return values.
  • The global spawn_broadcast function and methods on ThreadPool, Scope, and ScopeFifo will run detached, without blocking the current thread.
• Panicking methods now use #[track_caller] to report the caller's location.
• Fixed a truncated length in vec::Drain when given an empty range.

Contributors

Thanks to all of the contributors for this release!

• @cuviper
• @idanmuze
• @JoeyBF
• @JustForFun88
• @kianmeng
• @kornelski
• @ritchie46
• @ryanrussell
• @steffahn
• @TheIronBorn
• @willcrozi

Release rayon 1.5.3 (2022-05-13)

• The new ParallelSliceMut::par_sort_by_cached_key is a stable sort that caches the keys for each item -- a parallel version of slice::sort_by_cached_key.

Release rayon-core 1.9.3 (2022-05-13)

• Fixed a use-after-free race in job notification.

Release rayon 1.5.2 / rayon-core 1.9.2 (2022-04-13)

• The new ParallelSlice::par_rchunks() and par_rchunks_exact() iterate slice chunks in reverse, aligned the against the end of the slice if the length is not a perfect multiple of the chunk size. The new ParallelSliceMut::par_rchunks_mut() and par_rchunks_exact_mut() are the same for mutable slices.
• The ParallelIterator::try_* methods now support std::ops::ControlFlow and std::task::Poll items, mirroring the unstable Try implementations in the standard library.
• The ParallelString pattern-based methods now support &[char] patterns, which match when any character in that slice is found in the string.
• A soft limit is now enforced on the number of threads allowed in a single thread pool, respecting internal bit limits that already existed. The current maximum is publicly available from the new function max_num_threads().
• Fixed several Stacked Borrow and provenance issues found by cargo miri.

Contributors

Thanks to all of the contributors for this release!

• @atouchet
• @bluss
• @cuviper
• @fzyzcjy
• @nyanzebra
• @paolobarbolini
• @RReverser
• @saethlin

Release rayon 1.5.1 / rayon-core 1.9.1 (2021-05-18)

• The new in_place_scope and in_place_scope_fifo are variations of scope and scope_fifo, running the initial non-Send callback directly on the current thread, rather than moving execution to the thread pool.
• With Rust 1.51 or later, arrays now implement IntoParallelIterator.
• New implementations of FromParallelIterator make it possible to collect complicated nestings of items.
  • FromParallelIterator<(A, B)> for (FromA, FromB) works like unzip.
  • FromParallelIterator<Either<L, R>> for (A, B) works like partition_map.
• Type inference now works better with parallel Range and RangeInclusive.
• The implementation of FromParallelIterator and ParallelExtend for Vec<T> now uses MaybeUninit<T> internally to avoid creating any references to uninitialized data.
• ParallelBridge fixed a bug with threads missing available work.

Contributors

Thanks to all of the contributors for this release!

• @atouchet
• @cuviper
• @Hywan
• @iRaiko
• @Qwaz
• @rocallahan

Release rayon 1.5.0 / rayon-core 1.9.0 (2020-10-21)

• Update crossbeam dependencies.
• The minimum supported rustc is now 1.36.

Contributors

Thanks to all of the contributors for this release!

• @cuviper
• @mbrubeck
• @mrksu

Release rayon 1.4.1 (2020-09-29)

• The new flat_map_iter and flatten_iter methods can be used to flatten sequential iterators, which may perform better in cases that don't need the nested parallelism of flat_map and flatten.
• The new par_drain method is a parallel version of the standard drain for collections, removing items while keeping the original capacity. Collections that implement this through ParallelDrainRange support draining items from arbitrary index ranges, while ParallelDrainFull always drains everything.
• The new positions method finds all items that match the given predicate and returns their indices in a new iterator.

Release rayon-core 1.8.1 (2020-09-17)

• Fixed an overflow panic on high-contention workloads, for a counter that was meant to simply wrap. This panic only occurred with debug assertions enabled, and was much more likely on 32-bit targets.

Release rayon 1.4.0 / rayon-core 1.8.0 (2020-08-24)

• Implemented a new thread scheduler, RFC 5, which uses targeted wakeups for new work and for notifications of completed stolen work, reducing wasteful CPU usage in idle threads.
• Implemented IntoParallelIterator for Range<char> and RangeInclusive<char> with the same iteration semantics as Rust 1.45.
• Relaxed the lifetime requirements of the initial scope closure.

Contributors

Thanks to all of the contributors for this release!

• @CAD97
• @cuviper
• @kmaork
• @nikomatsakis
• @SuperFluffy

Release rayon 1.3.1 / rayon-core 1.7.1 (2020-06-15)

• Fixed a use-after-free race in calls blocked between two rayon thread pools.
• Collecting to an indexed Vec now drops any partial writes while unwinding, rather than just leaking them. If dropping also panics, Rust will abort.
  • Note: the old leaking behavior is considered safe, just not ideal.
• The new IndexedParallelIterator::step_by() adapts an iterator to step through items by the given count, like Iterator::step_by().
• The new ParallelSlice::par_chunks_exact() and mutable equivalent ParallelSliceMut::par_chunks_exact_mut() ensure that the chunks always have the exact length requested, leaving any remainder separate, like the slice methods chunks_exact() and chunks_exact_mut().

Contributors

Thanks to all of the contributors for this release!

• @adrian5
• @bluss
• @cuviper
• @FlyingCanoe
• @GuillaumeGomez
• @matthiasbeyer
• @picoHz
• @zesterer

Release rayon 1.3.0 / rayon-core 1.7.0 (2019-12-21)

• Tuples up to length 12 now implement IntoParallelIterator, creating a MultiZip iterator that produces items as similarly-shaped tuples.
• The --cfg=rayon_unstable supporting code for rayon-futures is removed.
• The minimum supported rustc is now 1.31.

Contributors

Thanks to all of the contributors for this release!

• @cuviper
• @c410-f3r
• @silwol

Release rayon-futures 0.1.1 (2019-12-21)

• Send bounds have been added for the Item and Error associated types on all generic F: Future interfaces. While technically a breaking change, this is a soundness fix, so we are not increasing the semantic version for this.
• This crate is now deprecated, and the --cfg=rayon_unstable supporting code will be removed in rayon-core 1.7.0. This only supported the now-obsolete Future from futures 0.1, while support for std::future::Future is expected to come directly in rayon-core -- although that is not ready yet.

Contributors

Thanks to all of the contributors for this release!

• @cuviper
• @kornelski
• @jClaireCodesStuff
• @jwass
• @seanchen1991

Release rayon 1.2.1 / rayon-core 1.6.1 (2019-11-20)

• Update crossbeam dependencies.
• Add top-level doc links for the iterator traits.
• Document that the iterator traits are not object safe.

Contributors

Thanks to all of the contributors for this release!

• @cuviper
• @dnaka91
• @matklad
• @nikomatsakis
• @Qqwy
• @vorner

Release rayon 1.2.0 / rayon-core 1.6.0 (2019-08-30)

• The new ParallelIterator::copied() converts an iterator of references into copied values, like Iterator::copied().
• ParallelExtend is now implemented for the unit ().
• Internal updates were made to improve test determinism, reduce closure type sizes, reduce task allocations, and update dependencies.
• The minimum supported rustc is now 1.28.

Contributors

Thanks to all of the contributors for this release!

• @Aaron1011
• @cuviper
• @ralfbiedert

Release rayon 1.1.0 / rayon-core 1.5.0 (2019-06-12)

• FIFO spawns are now supported using the new spawn_fifo() and scope_fifo() global functions, and their corresponding ThreadPool methods.
  • Normally when tasks are queued on a thread, the most recent is processed first (LIFO) while other threads will steal the oldest (FIFO). With FIFO spawns, those tasks are processed locally in FIFO order too.
  • Regular spawns and other tasks like join are not affected.
  • The breadth_first configuration flag, which globally approximated this effect, is now deprecated.
  • For more design details, please see RFC 1.
• ThreadPoolBuilder can now take a custom spawn_handler to control how threads will be created in the pool.
  • ThreadPoolBuilder::build_scoped() uses this to create a scoped thread pool, where the threads are able to use non-static data.
  • This may also be used to support threading in exotic environments, like WebAssembly, which don't support the normal std::thread.
• ParallelIterator has 3 new methods: find_map_any(), find_map_first(), and find_map_last(), like Iterator::find_map() with ordering constraints.
• The new ParallelIterator::panic_fuse() makes a parallel iterator halt as soon as possible if any of its threads panic. Otherwise, the panic state is not usually noticed until the iterator joins its parallel tasks back together.
• IntoParallelIterator is now implemented for integral RangeInclusive.
• Several internal Folders now have optimized consume_iter implementations.
• rayon_core::current_thread_index() is now re-exported in rayon.
• The minimum rustc is now 1.26, following the update policy defined in RFC 3.

Contributors

Thanks to all of the contributors for this release!

• @cuviper
• @didroe
• @GuillaumeGomez
• @huonw
• @janriemer
• @kornelski
• @nikomatsakis
• @seanchen1991
• @yegeun542

Release rayon 1.0.3 (2018-11-02)

• ParallelExtend is now implemented for tuple pairs, enabling nested unzip() and partition_map() operations. For instance, (A, (B, C)) items can be unzipped into (Vec<A>, (Vec<B>, Vec<C>)).
  • ParallelExtend<(A, B)> works like unzip().
  • ParallelExtend<Either<A, B>> works like partition_map().
• ParallelIterator now has a method map_init() which calls an init function for a value to pair with items, like map_with() but dynamically constructed. That value type has no constraints, not even Send or Sync.
  • The new for_each_init() is a variant of this for simple iteration.
  • The new try_for_each_init() is a variant for fallible iteration.

Contributors

Thanks to all of the contributors for this release!

• @cuviper
• @dan-zheng
• @dholbert
• @ignatenkobrain
• @mdonoughe

Release rayon 1.0.2 / rayon-core 1.4.1 (2018-07-17)

• The ParallelBridge trait with method par_bridge() makes it possible to use any Sendable Iterator in parallel!
  • This trait has been added to rayon::prelude.
  • It automatically implements internal synchronization and queueing to spread the Items across the thread pool. Iteration order is not preserved by this adaptor.
  • "Native" Rayon iterators like par_iter() should still be preferred when possible for better efficiency.
• ParallelString now has additional methods for parity with std string iterators: par_char_indices(), par_bytes(), par_encode_utf16(), par_matches(), and par_match_indices().
• ParallelIterator now has fallible methods try_fold(), try_reduce(), and try_for_each, plus *_with() variants of each, for automatically short-circuiting iterators on None or Err values. These are inspired by Iterator::try_fold() and try_for_each() that were stabilized in Rust 1.27.
• Range<i128> and Range<u128> are now supported with Rust 1.26 and later.
• Small improvements have been made to the documentation.
• rayon-core now only depends on rand for testing.
• Rayon tests now work on stable Rust.

Contributors

Thanks to all of the contributors for this release!

• @AndyGauge
• @cuviper
• @ignatenkobrain
• @LukasKalbertodt
• @MajorBreakfast
• @nikomatsakis
• @paulkernfeld
• @QuietMisdreavus

Release rayon 1.0.1 (2018-03-16)

• Added more documentation for rayon::iter::split().
• Corrected links and typos in documentation.

Contributors

Thanks to all of the contributors for this release!

• @cuviper
• @HadrienG2
• @matthiasbeyer
• @nikomatsakis

Release rayon 1.0.0 / rayon-core 1.4.0 (2018-02-15)

• ParallelIterator added the update method which applies a function to mutable references, inspired by itertools.
• IndexedParallelIterator added the chunks method which yields vectors of consecutive items from the base iterator, inspired by itertools.
• String now implements FromParallelIterator<Cow<str>> and ParallelExtend<Cow<str>>, inspired by std.
• () now implements FromParallelIterator<()>, inspired by std.
• The new ThreadPoolBuilder replaces and deprecates Configuration.
  • Errors from initialization now have the concrete ThreadPoolBuildError type, rather than Box<Error>, and this type implements Send and Sync.
  • ThreadPool::new is deprecated in favor of ThreadPoolBuilder::build.
  • initialize is deprecated in favor of ThreadPoolBuilder::build_global.
• Examples have been added to most of the parallel iterator methods.
• A lot of the documentation has been reorganized and extended.

Breaking changes

• Rayon now requires rustc 1.13 or greater.
• IndexedParallelIterator::len and ParallelIterator::opt_len now operate on &self instead of &mut self.
• IndexedParallelIterator::collect_into is now collect_into_vec.
• IndexedParallelIterator::unzip_into is now unzip_into_vecs.
• Rayon no longer exports the deprecated Configuration and initialize from rayon-core.

Contributors

Thanks to all of the contributors for this release!

• @Bilkow
• @cuviper
• @Enet4
• @ignatenkobrain
• @iwillspeak
• @jeehoonkang
• @jwass
• @Kerollmops
• @KodrAus
• @kornelski
• @MaloJaffre
• @nikomatsakis
• @obv-mikhail
• @oddg
• @phimuemue
• @stjepang
• @tmccombs
• bors[bot]

Release rayon 0.9.0 / rayon-core 1.3.0 / rayon-futures 0.1.0 (2017-11-09)

• Configuration now has a build method.
• ParallelIterator added flatten and intersperse, both inspired by itertools.
• IndexedParallelIterator added interleave, interleave_shortest, and zip_eq, all inspired by itertools.
• The new functions iter::empty and once create parallel iterators of exactly zero or one item, like their std counterparts.
• The new functions iter::repeat and repeatn create parallel iterators repeating an item indefinitely or n times, respectively.
• The new function join_context works like join, with an added FnContext parameter that indicates whether the job was stolen.
• Either (used by ParallelIterator::partition_map) is now re-exported from the either crate, instead of defining our own type.
  • Either also now implements ParallelIterator, IndexedParallelIterator, and ParallelExtend when both of its Left and Right types do.
• All public types now implement Debug.
• Many of the parallel iterators now implement Clone where possible.
• Much of the documentation has been extended. (but still could use more help!)
• All rayon crates have improved metadata.
• Rayon was evaluated in the Libz Blitz, leading to many of these improvements.
• Rayon pull requests are now guarded by bors-ng.

Futures

The spawn_future() method has been refactored into its own rayon-futures crate, now through a ScopeFutureExt trait for ThreadPool and Scope. The supporting rayon-core APIs are still gated by --cfg rayon_unstable.

Breaking changes

• Two breaking changes have been made to rayon-core, but since they're fixing soundness bugs, we are considering these minor changes for semver.
  • Scope::spawn now requires Send for the closure.
  • ThreadPool::install now requires Send for the return value.
• The iter::internal module has been renamed to iter::plumbing, to hopefully indicate that while these are low-level details, they're not really internal or private to rayon. The contents of that module are needed for third-parties to implement new parallel iterators, and we'll treat them with normal semver stability guarantees.
• The function rayon::iter::split is no longer re-exported as rayon::split.

Contributors

Thanks to all of the contributors for this release!

• @AndyGauge
• @ChristopherDavenport
• @chrisvittal
• @cuviper
• @dns2utf8
• @dtolnay
• @frewsxcv
• @gsquire
• @Hittherhod
• @jdr023
• @laumann
• @leodasvacas
• @lvillani
• @MajorBreakfast
• @mamuleanu
• @marmistrz
• @mbrubeck
• @mgattozzi
• @nikomatsakis
• @smt923
• @stjepang
• @tmccombs
• @vishalsodani
• bors[bot]

Release rayon 0.8.2 (2017-06-28)

• ParallelSliceMut now has six parallel sorting methods with the same variations as the standard library.
  • par_sort, par_sort_by, and par_sort_by_key perform stable sorts in parallel, using the default order, a custom comparator, or a key extraction function, respectively.
  • par_sort_unstable, par_sort_unstable_by, and par_sort_unstable_by_key perform unstable sorts with the same comparison options.
  • Thanks to @stjepang!

Release rayon 0.8.1 / rayon-core 1.2.0 (2017-06-14)

• The following core APIs are being stabilized:
  • rayon::spawn() -- spawns a task into the Rayon threadpool; as it is contained in the global scope (rather than a user-created scope), the task cannot capture anything from the current stack frame.
  • ThreadPool::join(), ThreadPool::spawn(), ThreadPool::scope() -- convenience APIs for launching new work within a thread-pool.
• The various iterator adapters are now tagged with #[must_use]
• Parallel iterators now offer a for_each_with adapter, similar to map_with.
• We are adopting a new approach to handling the remaining unstable APIs (which primarily pertain to futures integration). As awlays, unstable APIs are intended for experimentation, but do not come with any promise of compatibility (in other words, we might change them in arbitrary ways in any release). Previously, we designated such APIs using a Cargo feature "unstable". Now, we are using a regular #[cfg] flag. This means that to see the unstable APIs, you must do RUSTFLAGS='--cfg rayon_unstable' cargo build. This is intentionally inconvenient; in particular, if you are a library, then your clients must also modify their environment, signaling their agreement to instability.

Release rayon 0.8.0 / rayon-core 1.1.0 (2017-06-13)

Rayon 0.8.0

• Added the map_with and fold_with combinators, which help for passing along state (like channels) that cannot be shared between threads but which can be cloned on each thread split.
• Added the while_some combinator, which helps for writing short-circuiting iterators.
• Added support for "short-circuiting" collection: e.g., collecting from an iterator producing Option<T> or Result<T, E> into a Option<Collection<T>> or Result<Collection<T>, E>.
• Support FromParallelIterator for Cow.
• Removed the deprecated weight APIs.
• Simplified the parallel iterator trait hierarchy by removing the BoundedParallelIterator and ExactParallelIterator traits, which were not serving much purpose.
• Improved documentation.
• Added some missing Send impls.
• Fixed some small bugs.

Rayon-core 1.1.0

• We now have more documentation.
• Renamed the (unstable) methods spawn_async and spawn_future_async -- which spawn tasks that cannot hold references -- to simply spawn and spawn_future, respectively.
• We are now using the coco library for our deque.
• Individual threadpools can now be configured in "breadth-first" mode, which causes them to execute spawned tasks in the reverse order that they used to. In some specific scenarios, this can be a win (though it is not generally the right choice).
• Added top-level functions:
  • current_thread_index, for querying the index of the current worker thread within its thread-pool (previously available as thread_pool.current_thread_index());
  • current_thread_has_pending_tasks, for querying whether the current worker that has an empty task deque or not. This can be useful when deciding whether to spawn a task.
• The environment variables for controlling Rayon are now RAYON_NUM_THREADS and RAYON_LOG. The older variables (e.g., RAYON_RS_NUM_CPUS are still supported but deprecated).

Rayon-demo

• Added a new game-of-life benchmark.

Contributors

Thanks to the following contributors:

• @ChristopherDavenport
• @SuperFluffy
• @antoinewdg
• @crazymykl
• @cuviper
• @glandium
• @julian-seward1
• @leodasvacas
• @leshow
• @lilianmoraru
• @mschmo
• @nikomatsakis
• @stjepang

Release rayon 0.7.1 / rayon-core 1.0.2 (2017-05-30)

This release is a targeted performance fix for #343, an issue where rayon threads could sometimes enter into a spin loop where they would be unable to make progress until they are pre-empted.

Release rayon 0.7 / rayon-core 1.0 (2017-04-06)

This release marks the first step towards Rayon 1.0. For best performance, it is important that all Rayon users update to at least Rayon 0.7. This is because, as of Rayon 0.7, we have taken steps to ensure that, no matter how many versions of rayon are actively in use, there will only be a single global scheduler. This is achieved via the rayon-core crate, which is being released at version 1.0, and which encapsulates the core schedule APIs like join(). (Note: the rayon-core crate is, to some degree, an implementation detail, and not intended to be imported directly; it's entire API surface is mirrored through the rayon crate.)

We have also done a lot of work reorganizing the API for Rayon 0.7 in preparation for 1.0. The names of iterator types have been changed and reorganized (but few users are expected to be naming those types explicitly anyhow). In addition, a number of parallel iterator methods have been adjusted to match those in the standard iterator traits more closely. See the "Breaking Changes" section below for details.

Finally, Rayon 0.7 includes a number of new features and new parallel iterator methods. As of this release, Rayon's parallel iterators have officially reached parity with sequential iterators -- that is, every sequential iterator method that makes any sense in parallel is supported in some capacity.

New features and methods

• The internal Producer trait now features fold_with, which enables better performance for some parallel iterators.
• Strings now support par_split() and par_split_whitespace().
• The Configuration API is expanded and simplified:
  • num_threads(0) no longer triggers an error
  • you can now supply a closure to name the Rayon threads that get created by using Configuration::thread_name.
  • you can now inject code when Rayon threads start up and finish
  • you can now set a custom panic handler to handle panics in various odd situations
• Threadpools are now able to more gracefully put threads to sleep when not needed.
• Parallel iterators now support find_first(), find_last(), position_first(), and position_last().
• Parallel iterators now support rev(), which primarily affects subsequent calls to enumerate().
• The scope() API is now considered stable (and part of rayon-core).
• There is now a useful rayon::split function for creating custom Rayon parallel iterators.
• Parallel iterators now allow you to customize the min/max number of items to be processed in a given thread. This mechanism replaces the older weight mechanism, which is deprecated.
• sum() and friends now use the standard Sum traits

Breaking changes

In the move towards 1.0, there have been a number of minor breaking changes:

• Configuration setters like Configuration::set_num_threads() lost the set_ prefix, and hence become something like Configuration::num_threads().
• Configuration getters are removed
• Iterator types have been shuffled around and exposed more consistently:
  • combinator types live in rayon::iter, e.g. rayon::iter::Filter
  • iterators over various types live in a module named after their type, e.g. rayon::slice::Windows
• When doing a sum() or product(), type annotations are needed for the result since it is now possible to have the resulting sum be of a type other than the value you are iterating over (this mirrors sequential iterators).

Experimental features

Experimental features require the use of the unstable feature. Their APIs may change or disappear entirely in future releases (even minor releases) and hence they should be avoided for production code.

• We now have (unstable) support for futures integration. You can use Scope::spawn_future or rayon::spawn_future_async().
• There is now a rayon::spawn_async() function for using the Rayon threadpool to run tasks that do not have references to the stack.

Contributors

Thanks to the following people for their contributions to this release:

• @Aaronepower
• @ChristopherDavenport
• @bluss
• @cuviper
• @froydnj
• @gaurikholkar
• @hniksic
• @leodasvacas
• @leshow
• @martinhath
• @mbrubeck
• @nikomatsakis
• @pegomes
• @schuster
• @torkleyy

Release 0.6 (2016-12-21)

This release includes a lot of progress towards the goal of parity with the sequential iterator API, though there are still a few methods that are not yet complete. If you'd like to help with that effort, check out the milestone to see the remaining issues.

Announcement: @cuviper has been added as a collaborator to the Rayon repository for all of his outstanding work on Rayon, which includes both internal refactoring and helping to shape the public API. Thanks @cuviper! Keep it up.

• We now support collect() and not just collect_with(). You can use collect() to build a number of collections, including vectors, maps, and sets. Moreover, when building a vector with collect(), you are no longer limited to exact parallel iterators. Thanks @nikomatsakis, @cuviper!
• We now support skip() and take() on parallel iterators. Thanks @martinhath!
• Breaking change: We now match the sequential APIs for min() and max(). We also support min_by_key() and max_by_key(). Thanks @tapeinosyne!
• Breaking change: The mul() method is now renamed to product(), to match sequential iterators. Thanks @jonathandturner!
• We now support parallel iterator over ranges on u64 values. Thanks @cuviper!
• We now offer a par_chars() method on strings for iterating over characters in parallel. Thanks @cuviper!
• We now have new demos: a traveling salesman problem solver as well as matrix multiplication. Thanks @nikomatsakis, @edre!
• We are now documenting our minimum rustc requirement (currently v1.12.0). We will attempt to maintain compatibility with rustc stable v1.12.0 as long as it remains convenient, but if new features are stabilized or added that would be helpful to Rayon, or there are bug fixes that we need, we will bump to the most recent rustc. Thanks @cuviper!
• The reduce() functionality now has better inlining. Thanks @bluss!
• The join() function now has some documentation. Thanks @gsquire!
• The project source has now been fully run through rustfmt. Thanks @ChristopherDavenport!
• Exposed helper methods for accessing the current thread index. Thanks @bholley!

Release 0.5 (2016-11-04)

• Breaking change: The reduce method has been vastly simplified, and reduce_with_identity has been deprecated.
• Breaking change: The fold method has been changed. It used to always reduce the values, but now instead it is a combinator that returns a parallel iterator which can itself be reduced. See the docs for more information.
• The following parallel iterator combinators are now available (thanks @cuviper!):
  • find_any(): similar to find on a sequential iterator, but doesn't necessarily return the first matching item
  • position_any(): similar to position on a sequential iterator, but doesn't necessarily return the index of first matching item
  • any(), all(): just like their sequential counterparts
• The count() combinator is now available for parallel iterators.
• We now build with older versions of rustc again (thanks @durango!), as we removed a stray semicolon from thread_local!.
• Various improvements to the (unstable) scope() API implementation.

Release 0.4.3 (2016-10-25)

• Parallel iterators now offer an adaptive weight scheme, which means that explicit weights should no longer be necessary in most cases! Thanks @cuviper!
  • We are considering removing weights or changing the weight mechanism before 1.0. Examples of scenarios where you still need weights even with this adaptive mechanism would be great. Join the discussion at rayon-rs#111.
• New (unstable) scoped threads API, see rayon::scope for details.
  • You will need to supply the cargo feature unstable.
• The various demos and benchmarks have been consolidated into one program, rayon-demo.
• Optimizations in Rayon's inner workings. Thanks @emilio!
• Update num_cpus to 1.0. Thanks @jamwt!
• Various internal cleanup in the implementation and typo fixes. Thanks @cuviper, @Eh2406, and @spacejam!

Release 0.4.2 (2016-09-15)

• Updated crates.io metadata.

Release 0.4.1 (2016-09-14)

• New chain combinator for parallel iterators.
• Option, Result, as well as many more collection types now have parallel iterators.
• New mergesort demo.
• Misc fixes.

Thanks to @cuviper, @edre, @jdanford, @frewsxcv for their contributions!

Release 0.4 (2016-05-16)

• Make use of latest versions of catch-panic and various fixes to panic propagation.
• Add new prime sieve demo.
• Add cloned() and inspect() combinators.
• Misc fixes for Rust RFC 1214.

Thanks to @areilb1, @Amanieu, @SharplEr, and @cuviper for their contributions!

Release 0.3 (2016-02-23)

• Expanded par_iter APIs now available:
  • into_par_iter is now supported on vectors (taking ownership of the elements)
• Panic handling is much improved:
  • if you use the Nightly feature, experimental panic recovery is available
  • otherwise, panics propagate out and poision the workpool
• New Configuration object to control number of threads and other details
• New demos and benchmarks
  • try cargo run --release -- visualize in demo/nbody :)
    • Note: a nightly compiler is required for this demo due to the use of the += syntax

Thanks to @bjz, @cuviper, @Amanieu, and @willi-kappler for their contributions!

Release 0.2 and earlier

No release notes were being kept at this time.