1 # Release rayon 1.3.1 / rayon-core 1.7.1 (2020-06-15)
3 - Fixed a use-after-free race in calls blocked between two rayon thread pools.
4 - Collecting to an indexed `Vec` now drops any partial writes while unwinding,
5 rather than just leaking them. If dropping also panics, Rust will abort.
6 - Note: the old leaking behavior is considered _safe_, just not ideal.
7 - The new `IndexedParallelIterator::step_by()` adapts an iterator to step
8 through items by the given count, like `Iterator::step_by()`.
9 - The new `ParallelSlice::par_chunks_exact()` and mutable equivalent
10 `ParallelSliceMut::par_chunks_exact_mut()` ensure that the chunks always have
11 the exact length requested, leaving any remainder separate, like the slice
12 methods `chunks_exact()` and `chunks_exact_mut()`.
16 Thanks to all of the contributors for this release!
28 # Release rayon 1.3.0 / rayon-core 1.7.0 (2019-12-21)
30 - Tuples up to length 12 now implement `IntoParallelIterator`, creating a
31 `MultiZip` iterator that produces items as similarly-shaped tuples.
32 - The `--cfg=rayon_unstable` supporting code for `rayon-futures` is removed.
33 - The minimum supported `rustc` is now 1.31.
37 Thanks to all of the contributors for this release!
44 # Release rayon-futures 0.1.1 (2019-12-21)
46 - `Send` bounds have been added for the `Item` and `Error` associated types on
47 all generic `F: Future` interfaces. While technically a breaking change, this
48 is a soundness fix, so we are not increasing the semantic version for this.
49 - This crate is now deprecated, and the `--cfg=rayon_unstable` supporting code
50 will be removed in `rayon-core 1.7.0`. This only supported the now-obsolete
51 `Future` from `futures 0.1`, while support for `std::future::Future` is
52 expected to come directly in `rayon-core` -- although that is not ready yet.
56 Thanks to all of the contributors for this release!
65 # Release rayon 1.2.1 / rayon-core 1.6.1 (2019-11-20)
67 - Update crossbeam dependencies.
68 - Add top-level doc links for the iterator traits.
69 - Document that the iterator traits are not object safe.
73 Thanks to all of the contributors for this release!
83 # Release rayon 1.2.0 / rayon-core 1.6.0 (2019-08-30)
85 - The new `ParallelIterator::copied()` converts an iterator of references into
86 copied values, like `Iterator::copied()`.
87 - `ParallelExtend` is now implemented for the unit `()`.
88 - Internal updates were made to improve test determinism, reduce closure type
89 sizes, reduce task allocations, and update dependencies.
90 - The minimum supported `rustc` is now 1.28.
94 Thanks to all of the contributors for this release!
101 # Release rayon 1.1.0 / rayon-core 1.5.0 (2019-06-12)
103 - FIFO spawns are now supported using the new `spawn_fifo()` and `scope_fifo()`
104 global functions, and their corresponding `ThreadPool` methods.
105 - Normally when tasks are queued on a thread, the most recent is processed
106 first (LIFO) while other threads will steal the oldest (FIFO). With FIFO
107 spawns, those tasks are processed locally in FIFO order too.
108 - Regular spawns and other tasks like `join` are not affected.
109 - The `breadth_first` configuration flag, which globally approximated this
110 effect, is now deprecated.
111 - For more design details, please see [RFC 1].
112 - `ThreadPoolBuilder` can now take a custom `spawn_handler` to control how
113 threads will be created in the pool.
114 - `ThreadPoolBuilder::build_scoped()` uses this to create a scoped thread
115 pool, where the threads are able to use non-static data.
116 - This may also be used to support threading in exotic environments, like
117 WebAssembly, which don't support the normal `std::thread`.
118 - `ParallelIterator` has 3 new methods: `find_map_any()`, `find_map_first()`,
119 and `find_map_last()`, like `Iterator::find_map()` with ordering constraints.
120 - The new `ParallelIterator::panic_fuse()` makes a parallel iterator halt as soon
121 as possible if any of its threads panic. Otherwise, the panic state is not
122 usually noticed until the iterator joins its parallel tasks back together.
123 - `IntoParallelIterator` is now implemented for integral `RangeInclusive`.
124 - Several internal `Folder`s now have optimized `consume_iter` implementations.
125 - `rayon_core::current_thread_index()` is now re-exported in `rayon`.
126 - The minimum `rustc` is now 1.26, following the update policy defined in [RFC 3].
130 Thanks to all of the contributors for this release!
142 [RFC 1]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0001-scope-scheduling.md
143 [RFC 3]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0003-minimum-rustc.md
146 # Release rayon 1.0.3 (2018-11-02)
148 - `ParallelExtend` is now implemented for tuple pairs, enabling nested
149 `unzip()` and `partition_map()` operations. For instance, `(A, (B, C))`
150 items can be unzipped into `(Vec<A>, (Vec<B>, Vec<C>))`.
151 - `ParallelExtend<(A, B)>` works like `unzip()`.
152 - `ParallelExtend<Either<A, B>>` works like `partition_map()`.
153 - `ParallelIterator` now has a method `map_init()` which calls an `init`
154 function for a value to pair with items, like `map_with()` but dynamically
155 constructed. That value type has no constraints, not even `Send` or `Sync`.
156 - The new `for_each_init()` is a variant of this for simple iteration.
157 - The new `try_for_each_init()` is a variant for fallible iteration.
161 Thanks to all of the contributors for this release!
170 # Release rayon 1.0.2 / rayon-core 1.4.1 (2018-07-17)
172 - The `ParallelBridge` trait with method `par_bridge()` makes it possible to
173 use any `Send`able `Iterator` in parallel!
174 - This trait has been added to `rayon::prelude`.
175 - It automatically implements internal synchronization and queueing to
176 spread the `Item`s across the thread pool. Iteration order is not
177 preserved by this adaptor.
178 - "Native" Rayon iterators like `par_iter()` should still be preferred when
179 possible for better efficiency.
180 - `ParallelString` now has additional methods for parity with `std` string
181 iterators: `par_char_indices()`, `par_bytes()`, `par_encode_utf16()`,
182 `par_matches()`, and `par_match_indices()`.
183 - `ParallelIterator` now has fallible methods `try_fold()`, `try_reduce()`,
184 and `try_for_each`, plus `*_with()` variants of each, for automatically
185 short-circuiting iterators on `None` or `Err` values. These are inspired by
186 `Iterator::try_fold()` and `try_for_each()` that were stabilized in Rust 1.27.
187 - `Range<i128>` and `Range<u128>` are now supported with Rust 1.26 and later.
188 - Small improvements have been made to the documentation.
189 - `rayon-core` now only depends on `rand` for testing.
190 - Rayon tests now work on stable Rust.
194 Thanks to all of the contributors for this release!
206 # Release rayon 1.0.1 (2018-03-16)
208 - Added more documentation for `rayon::iter::split()`.
209 - Corrected links and typos in documentation.
213 Thanks to all of the contributors for this release!
221 # Release rayon 1.0.0 / rayon-core 1.4.0 (2018-02-15)
223 - `ParallelIterator` added the `update` method which applies a function to
224 mutable references, inspired by `itertools`.
225 - `IndexedParallelIterator` added the `chunks` method which yields vectors of
226 consecutive items from the base iterator, inspired by `itertools`.
227 - `String` now implements `FromParallelIterator<Cow<str>>` and
228 `ParallelExtend<Cow<str>>`, inspired by `std`.
229 - `()` now implements `FromParallelIterator<()>`, inspired by `std`.
230 - The new `ThreadPoolBuilder` replaces and deprecates `Configuration`.
231 - Errors from initialization now have the concrete `ThreadPoolBuildError`
232 type, rather than `Box<Error>`, and this type implements `Send` and `Sync`.
233 - `ThreadPool::new` is deprecated in favor of `ThreadPoolBuilder::build`.
234 - `initialize` is deprecated in favor of `ThreadPoolBuilder::build_global`.
235 - Examples have been added to most of the parallel iterator methods.
236 - A lot of the documentation has been reorganized and extended.
240 - Rayon now requires rustc 1.13 or greater.
241 - `IndexedParallelIterator::len` and `ParallelIterator::opt_len` now operate on
242 `&self` instead of `&mut self`.
243 - `IndexedParallelIterator::collect_into` is now `collect_into_vec`.
244 - `IndexedParallelIterator::unzip_into` is now `unzip_into_vecs`.
245 - Rayon no longer exports the deprecated `Configuration` and `initialize` from
250 Thanks to all of the contributors for this release!
272 # Release rayon 0.9.0 / rayon-core 1.3.0 / rayon-futures 0.1.0 (2017-11-09)
274 - `Configuration` now has a `build` method.
275 - `ParallelIterator` added `flatten` and `intersperse`, both inspired by
277 - `IndexedParallelIterator` added `interleave`, `interleave_shortest`, and
278 `zip_eq`, all inspired by itertools.
279 - The new functions `iter::empty` and `once` create parallel iterators of
280 exactly zero or one item, like their `std` counterparts.
281 - The new functions `iter::repeat` and `repeatn` create parallel iterators
282 repeating an item indefinitely or `n` times, respectively.
283 - The new function `join_context` works like `join`, with an added `FnContext`
284 parameter that indicates whether the job was stolen.
285 - `Either` (used by `ParallelIterator::partition_map`) is now re-exported from
286 the `either` crate, instead of defining our own type.
287 - `Either` also now implements `ParallelIterator`, `IndexedParallelIterator`,
288 and `ParallelExtend` when both of its `Left` and `Right` types do.
289 - All public types now implement `Debug`.
290 - Many of the parallel iterators now implement `Clone` where possible.
291 - Much of the documentation has been extended. (but still could use more help!)
292 - All rayon crates have improved metadata.
293 - Rayon was evaluated in the Libz Blitz, leading to many of these improvements.
294 - Rayon pull requests are now guarded by bors-ng.
298 The `spawn_future()` method has been refactored into its own `rayon-futures`
299 crate, now through a `ScopeFutureExt` trait for `ThreadPool` and `Scope`. The
300 supporting `rayon-core` APIs are still gated by `--cfg rayon_unstable`.
304 - Two breaking changes have been made to `rayon-core`, but since they're fixing
305 soundness bugs, we are considering these _minor_ changes for semver.
306 - `Scope::spawn` now requires `Send` for the closure.
307 - `ThreadPool::install` now requires `Send` for the return value.
308 - The `iter::internal` module has been renamed to `iter::plumbing`, to hopefully
309 indicate that while these are low-level details, they're not really internal
310 or private to rayon. The contents of that module are needed for third-parties
311 to implement new parallel iterators, and we'll treat them with normal semver
312 stability guarantees.
313 - The function `rayon::iter::split` is no longer re-exported as `rayon::split`.
317 Thanks to all of the contributors for this release!
320 - @ChristopherDavenport
345 # Release rayon 0.8.2 (2017-06-28)
347 - `ParallelSliceMut` now has six parallel sorting methods with the same
348 variations as the standard library.
349 - `par_sort`, `par_sort_by`, and `par_sort_by_key` perform stable sorts in
350 parallel, using the default order, a custom comparator, or a key extraction
351 function, respectively.
352 - `par_sort_unstable`, `par_sort_unstable_by`, and `par_sort_unstable_by_key`
353 perform unstable sorts with the same comparison options.
354 - Thanks to @stjepang!
357 # Release rayon 0.8.1 / rayon-core 1.2.0 (2017-06-14)
359 - The following core APIs are being stabilized:
360 - `rayon::spawn()` -- spawns a task into the Rayon threadpool; as it
361 is contained in the global scope (rather than a user-created
362 scope), the task cannot capture anything from the current stack
364 - `ThreadPool::join()`, `ThreadPool::spawn()`, `ThreadPool::scope()`
365 -- convenience APIs for launching new work within a thread-pool.
366 - The various iterator adapters are now tagged with `#[must_use]`
367 - Parallel iterators now offer a `for_each_with` adapter, similar to
369 - We are adopting a new approach to handling the remaining unstable
370 APIs (which primarily pertain to futures integration). As awlays,
371 unstable APIs are intended for experimentation, but do not come with
372 any promise of compatibility (in other words, we might change them
373 in arbitrary ways in any release). Previously, we designated such
374 APIs using a Cargo feature "unstable". Now, we are using a regular
375 `#[cfg]` flag. This means that to see the unstable APIs, you must do
376 `RUSTFLAGS='--cfg rayon_unstable' cargo build`. This is
377 intentionally inconvenient; in particular, if you are a library,
378 then your clients must also modify their environment, signaling
379 their agreement to instability.
382 # Release rayon 0.8.0 / rayon-core 1.1.0 (2017-06-13)
386 - Added the `map_with` and `fold_with` combinators, which help for
387 passing along state (like channels) that cannot be shared between
388 threads but which can be cloned on each thread split.
389 - Added the `while_some` combinator, which helps for writing short-circuiting iterators.
390 - Added support for "short-circuiting" collection: e.g., collecting
391 from an iterator producing `Option<T>` or `Result<T, E>` into a
392 `Option<Collection<T>>` or `Result<Collection<T>, E>`.
393 - Support `FromParallelIterator` for `Cow`.
394 - Removed the deprecated weight APIs.
395 - Simplified the parallel iterator trait hierarchy by removing the
396 `BoundedParallelIterator` and `ExactParallelIterator` traits,
397 which were not serving much purpose.
398 - Improved documentation.
399 - Added some missing `Send` impls.
400 - Fixed some small bugs.
404 - We now have more documentation.
405 - Renamed the (unstable) methods `spawn_async` and
406 `spawn_future_async` -- which spawn tasks that cannot hold
407 references -- to simply `spawn` and `spawn_future`, respectively.
408 - We are now using the coco library for our deque.
409 - Individual threadpools can now be configured in "breadth-first"
410 mode, which causes them to execute spawned tasks in the reverse
411 order that they used to. In some specific scenarios, this can be a
412 win (though it is not generally the right choice).
413 - Added top-level functions:
414 - `current_thread_index`, for querying the index of the current worker thread within
415 its thread-pool (previously available as `thread_pool.current_thread_index()`);
416 - `current_thread_has_pending_tasks`, for querying whether the
417 current worker that has an empty task deque or not. This can be
418 useful when deciding whether to spawn a task.
419 - The environment variables for controlling Rayon are now
420 `RAYON_NUM_THREADS` and `RAYON_LOG`. The older variables (e.g.,
421 `RAYON_RS_NUM_CPUS` are still supported but deprecated).
425 - Added a new game-of-life benchmark.
429 Thanks to the following contributors:
431 - @ChristopherDavenport
446 # Release rayon 0.7.1 / rayon-core 1.0.2 (2017-05-30)
448 This release is a targeted performance fix for #343, an issue where
449 rayon threads could sometimes enter into a spin loop where they would
450 be unable to make progress until they are pre-empted.
453 # Release rayon 0.7 / rayon-core 1.0 (2017-04-06)
455 This release marks the first step towards Rayon 1.0. **For best
456 performance, it is important that all Rayon users update to at least
457 Rayon 0.7.** This is because, as of Rayon 0.7, we have taken steps to
458 ensure that, no matter how many versions of rayon are actively in use,
459 there will only be a single global scheduler. This is achieved via the
460 `rayon-core` crate, which is being released at version 1.0, and which
461 encapsulates the core schedule APIs like `join()`. (Note: the
462 `rayon-core` crate is, to some degree, an implementation detail, and
463 not intended to be imported directly; it's entire API surface is
464 mirrored through the rayon crate.)
466 We have also done a lot of work reorganizing the API for Rayon 0.7 in
467 preparation for 1.0. The names of iterator types have been changed and
468 reorganized (but few users are expected to be naming those types
469 explicitly anyhow). In addition, a number of parallel iterator methods
470 have been adjusted to match those in the standard iterator traits more
471 closely. See the "Breaking Changes" section below for
474 Finally, Rayon 0.7 includes a number of new features and new parallel
475 iterator methods. **As of this release, Rayon's parallel iterators
476 have officially reached parity with sequential iterators** -- that is,
477 every sequential iterator method that makes any sense in parallel is
478 supported in some capacity.
480 ### New features and methods
482 - The internal `Producer` trait now features `fold_with`, which enables
483 better performance for some parallel iterators.
484 - Strings now support `par_split()` and `par_split_whitespace()`.
485 - The `Configuration` API is expanded and simplified:
486 - `num_threads(0)` no longer triggers an error
487 - you can now supply a closure to name the Rayon threads that get created
488 by using `Configuration::thread_name`.
489 - you can now inject code when Rayon threads start up and finish
490 - you can now set a custom panic handler to handle panics in various odd situations
491 - Threadpools are now able to more gracefully put threads to sleep when not needed.
492 - Parallel iterators now support `find_first()`, `find_last()`, `position_first()`,
493 and `position_last()`.
494 - Parallel iterators now support `rev()`, which primarily affects subsequent calls
496 - The `scope()` API is now considered stable (and part of `rayon-core`).
497 - There is now a useful `rayon::split` function for creating custom
498 Rayon parallel iterators.
499 - Parallel iterators now allow you to customize the min/max number of
500 items to be processed in a given thread. This mechanism replaces the
501 older `weight` mechanism, which is deprecated.
502 - `sum()` and friends now use the standard `Sum` traits
506 In the move towards 1.0, there have been a number of minor breaking changes:
508 - Configuration setters like `Configuration::set_num_threads()` lost the `set_` prefix,
509 and hence become something like `Configuration::num_threads()`.
510 - `Configuration` getters are removed
511 - Iterator types have been shuffled around and exposed more consistently:
512 - combinator types live in `rayon::iter`, e.g. `rayon::iter::Filter`
513 - iterators over various types live in a module named after their type,
514 e.g. `rayon::slice::Windows`
515 - When doing a `sum()` or `product()`, type annotations are needed for the result
516 since it is now possible to have the resulting sum be of a type other than the value
517 you are iterating over (this mirrors sequential iterators).
519 ### Experimental features
521 Experimental features require the use of the `unstable` feature. Their
522 APIs may change or disappear entirely in future releases (even minor
523 releases) and hence they should be avoided for production code.
525 - We now have (unstable) support for futures integration. You can use
526 `Scope::spawn_future` or `rayon::spawn_future_async()`.
527 - There is now a `rayon::spawn_async()` function for using the Rayon
528 threadpool to run tasks that do not have references to the stack.
532 Thanks to the following people for their contributions to this release:
535 - @ChristopherDavenport
551 # Release 0.6 (2016-12-21)
553 This release includes a lot of progress towards the goal of parity
554 with the sequential iterator API, though there are still a few methods
555 that are not yet complete. If you'd like to help with that effort,
556 [check out the milestone](https://github.com/nikomatsakis/rayon/issues?q=is%3Aopen+is%3Aissue+milestone%3A%22Parity+with+the+%60Iterator%60+trait%22)
557 to see the remaining issues.
559 **Announcement:** @cuviper has been added as a collaborator to the
560 Rayon repository for all of his outstanding work on Rayon, which
561 includes both internal refactoring and helping to shape the public
562 API. Thanks @cuviper! Keep it up.
564 - We now support `collect()` and not just `collect_with()`.
565 You can use `collect()` to build a number of collections,
566 including vectors, maps, and sets. Moreover, when building a vector
567 with `collect()`, you are no longer limited to exact parallel iterators.
568 Thanks @nikomatsakis, @cuviper!
569 - We now support `skip()` and `take()` on parallel iterators.
571 - **Breaking change:** We now match the sequential APIs for `min()` and `max()`.
572 We also support `min_by_key()` and `max_by_key()`. Thanks @tapeinosyne!
573 - **Breaking change:** The `mul()` method is now renamed to `product()`,
574 to match sequential iterators. Thanks @jonathandturner!
575 - We now support parallel iterator over ranges on `u64` values. Thanks @cuviper!
576 - We now offer a `par_chars()` method on strings for iterating over characters
577 in parallel. Thanks @cuviper!
578 - We now have new demos: a traveling salesman problem solver as well as matrix
579 multiplication. Thanks @nikomatsakis, @edre!
580 - We are now documenting our minimum rustc requirement (currently
581 v1.12.0). We will attempt to maintain compatibility with rustc
582 stable v1.12.0 as long as it remains convenient, but if new features
583 are stabilized or added that would be helpful to Rayon, or there are
584 bug fixes that we need, we will bump to the most recent rustc. Thanks @cuviper!
585 - The `reduce()` functionality now has better inlining.
587 - The `join()` function now has some documentation. Thanks @gsquire!
588 - The project source has now been fully run through rustfmt.
589 Thanks @ChristopherDavenport!
590 - Exposed helper methods for accessing the current thread index.
594 # Release 0.5 (2016-11-04)
596 - **Breaking change:** The `reduce` method has been vastly
597 simplified, and `reduce_with_identity` has been deprecated.
598 - **Breaking change:** The `fold` method has been changed. It used to
599 always reduce the values, but now instead it is a combinator that
600 returns a parallel iterator which can itself be reduced. See the
601 docs for more information.
602 - The following parallel iterator combinators are now available (thanks @cuviper!):
603 - `find_any()`: similar to `find` on a sequential iterator,
604 but doesn't necessarily return the *first* matching item
605 - `position_any()`: similar to `position` on a sequential iterator,
606 but doesn't necessarily return the index of *first* matching item
607 - `any()`, `all()`: just like their sequential counterparts
608 - The `count()` combinator is now available for parallel iterators.
609 - We now build with older versions of rustc again (thanks @durango!),
610 as we removed a stray semicolon from `thread_local!`.
611 - Various improvements to the (unstable) `scope()` API implementation.
614 # Release 0.4.3 (2016-10-25)
616 - Parallel iterators now offer an adaptive weight scheme,
617 which means that explicit weights should no longer
618 be necessary in most cases! Thanks @cuviper!
619 - We are considering removing weights or changing the weight mechanism
620 before 1.0. Examples of scenarios where you still need weights even
621 with this adaptive mechanism would be great. Join the discussion
622 at <https://github.com/nikomatsakis/rayon/issues/111>.
623 - New (unstable) scoped threads API, see `rayon::scope` for details.
624 - You will need to supply the [cargo feature] `unstable`.
625 - The various demos and benchmarks have been consolidated into one
626 program, `rayon-demo`.
627 - Optimizations in Rayon's inner workings. Thanks @emilio!
628 - Update `num_cpus` to 1.0. Thanks @jamwt!
629 - Various internal cleanup in the implementation and typo fixes.
630 Thanks @cuviper, @Eh2406, and @spacejam!
632 [cargo feature]: http://doc.crates.io/manifest.html#the-features-section
635 # Release 0.4.2 (2016-09-15)
637 - Updated crates.io metadata.
640 # Release 0.4.1 (2016-09-14)
642 - New `chain` combinator for parallel iterators.
643 - `Option`, `Result`, as well as many more collection types now have
645 - New mergesort demo.
648 Thanks to @cuviper, @edre, @jdanford, @frewsxcv for their contributions!
651 # Release 0.4 (2016-05-16)
653 - Make use of latest versions of catch-panic and various fixes to panic propagation.
654 - Add new prime sieve demo.
655 - Add `cloned()` and `inspect()` combinators.
656 - Misc fixes for Rust RFC 1214.
658 Thanks to @areilb1, @Amanieu, @SharplEr, and @cuviper for their contributions!
661 # Release 0.3 (2016-02-23)
663 - Expanded `par_iter` APIs now available:
664 - `into_par_iter` is now supported on vectors (taking ownership of the elements)
665 - Panic handling is much improved:
666 - if you use the Nightly feature, experimental panic recovery is available
667 - otherwise, panics propagate out and poision the workpool
668 - New `Configuration` object to control number of threads and other details
669 - New demos and benchmarks
670 - try `cargo run --release -- visualize` in `demo/nbody` :)
671 - Note: a nightly compiler is required for this demo due to the
672 use of the `+=` syntax
674 Thanks to @bjz, @cuviper, @Amanieu, and @willi-kappler for their contributions!
677 # Release 0.2 and earlier
679 No release notes were being kept at this time.
projects / rustc.git / blob