1# Release rayon 1.5.1 / rayon-core 1.9.1 (2021-05-18) 2 3- The new `in_place_scope` and `in_place_scope_fifo` are variations of `scope` 4 and `scope_fifo`, running the initial non-`Send` callback directly on the 5 current thread, rather than moving execution to the thread pool. 6- With Rust 1.51 or later, arrays now implement `IntoParallelIterator`. 7- New implementations of `FromParallelIterator` make it possible to `collect` 8 complicated nestings of items. 9 - `FromParallelIterator<(A, B)> for (FromA, FromB)` works like `unzip`. 10 - `FromParallelIterator<Either<L, R>> for (A, B)` works like `partition_map`. 11- Type inference now works better with parallel `Range` and `RangeInclusive`. 12- The implementation of `FromParallelIterator` and `ParallelExtend` for 13 `Vec<T>` now uses `MaybeUninit<T>` internally to avoid creating any 14 references to uninitialized data. 15- `ParallelBridge` fixed a bug with threads missing available work. 16 17## Contributors 18 19Thanks to all of the contributors for this release! 20 21- @atouchet 22- @cuviper 23- @Hywan 24- @iRaiko 25- @Qwaz 26- @rocallahan 27 28# Release rayon 1.5.0 / rayon-core 1.9.0 (2020-10-21) 29 30- Update crossbeam dependencies. 31- The minimum supported `rustc` is now 1.36. 32 33## Contributors 34 35Thanks to all of the contributors for this release! 36 37- @cuviper 38- @mbrubeck 39- @mrksu 40 41# Release rayon 1.4.1 (2020-09-29) 42 43- The new `flat_map_iter` and `flatten_iter` methods can be used to flatten 44 sequential iterators, which may perform better in cases that don't need the 45 nested parallelism of `flat_map` and `flatten`. 46- The new `par_drain` method is a parallel version of the standard `drain` for 47 collections, removing items while keeping the original capacity. Collections 48 that implement this through `ParallelDrainRange` support draining items from 49 arbitrary index ranges, while `ParallelDrainFull` always drains everything. 50- The new `positions` method finds all items that match the given predicate and 51 returns their indices in a new iterator. 52 53# Release rayon-core 1.8.1 (2020-09-17) 54 55- Fixed an overflow panic on high-contention workloads, for a counter that was 56 meant to simply wrap. This panic only occurred with debug assertions enabled, 57 and was much more likely on 32-bit targets. 58 59# Release rayon 1.4.0 / rayon-core 1.8.0 (2020-08-24) 60 61- Implemented a new thread scheduler, [RFC 5], which uses targeted wakeups for 62 new work and for notifications of completed stolen work, reducing wasteful 63 CPU usage in idle threads. 64- Implemented `IntoParallelIterator for Range<char>` and `RangeInclusive<char>` 65 with the same iteration semantics as Rust 1.45. 66- Relaxed the lifetime requirements of the initial `scope` closure. 67 68[RFC 5]: https://github.com/rayon-rs/rfcs/pull/5 69 70## Contributors 71 72Thanks to all of the contributors for this release! 73 74- @CAD97 75- @cuviper 76- @kmaork 77- @nikomatsakis 78- @SuperFluffy 79 80 81# Release rayon 1.3.1 / rayon-core 1.7.1 (2020-06-15) 82 83- Fixed a use-after-free race in calls blocked between two rayon thread pools. 84- Collecting to an indexed `Vec` now drops any partial writes while unwinding, 85 rather than just leaking them. If dropping also panics, Rust will abort. 86 - Note: the old leaking behavior is considered _safe_, just not ideal. 87- The new `IndexedParallelIterator::step_by()` adapts an iterator to step 88 through items by the given count, like `Iterator::step_by()`. 89- The new `ParallelSlice::par_chunks_exact()` and mutable equivalent 90 `ParallelSliceMut::par_chunks_exact_mut()` ensure that the chunks always have 91 the exact length requested, leaving any remainder separate, like the slice 92 methods `chunks_exact()` and `chunks_exact_mut()`. 93 94## Contributors 95 96Thanks to all of the contributors for this release! 97 98- @adrian5 99- @bluss 100- @cuviper 101- @FlyingCanoe 102- @GuillaumeGomez 103- @matthiasbeyer 104- @picoHz 105- @zesterer 106 107 108# Release rayon 1.3.0 / rayon-core 1.7.0 (2019-12-21) 109 110- Tuples up to length 12 now implement `IntoParallelIterator`, creating a 111 `MultiZip` iterator that produces items as similarly-shaped tuples. 112- The `--cfg=rayon_unstable` supporting code for `rayon-futures` is removed. 113- The minimum supported `rustc` is now 1.31. 114 115## Contributors 116 117Thanks to all of the contributors for this release! 118 119- @cuviper 120- @c410-f3r 121- @silwol 122 123 124# Release rayon-futures 0.1.1 (2019-12-21) 125 126- `Send` bounds have been added for the `Item` and `Error` associated types on 127 all generic `F: Future` interfaces. While technically a breaking change, this 128 is a soundness fix, so we are not increasing the semantic version for this. 129- This crate is now deprecated, and the `--cfg=rayon_unstable` supporting code 130 will be removed in `rayon-core 1.7.0`. This only supported the now-obsolete 131 `Future` from `futures 0.1`, while support for `std::future::Future` is 132 expected to come directly in `rayon-core` -- although that is not ready yet. 133 134## Contributors 135 136Thanks to all of the contributors for this release! 137 138- @cuviper 139- @kornelski 140- @jClaireCodesStuff 141- @jwass 142- @seanchen1991 143 144 145# Release rayon 1.2.1 / rayon-core 1.6.1 (2019-11-20) 146 147- Update crossbeam dependencies. 148- Add top-level doc links for the iterator traits. 149- Document that the iterator traits are not object safe. 150 151## Contributors 152 153Thanks to all of the contributors for this release! 154 155- @cuviper 156- @dnaka91 157- @matklad 158- @nikomatsakis 159- @Qqwy 160- @vorner 161 162 163# Release rayon 1.2.0 / rayon-core 1.6.0 (2019-08-30) 164 165- The new `ParallelIterator::copied()` converts an iterator of references into 166 copied values, like `Iterator::copied()`. 167- `ParallelExtend` is now implemented for the unit `()`. 168- Internal updates were made to improve test determinism, reduce closure type 169 sizes, reduce task allocations, and update dependencies. 170- The minimum supported `rustc` is now 1.28. 171 172## Contributors 173 174Thanks to all of the contributors for this release! 175 176- @Aaron1011 177- @cuviper 178- @ralfbiedert 179 180 181# Release rayon 1.1.0 / rayon-core 1.5.0 (2019-06-12) 182 183- FIFO spawns are now supported using the new `spawn_fifo()` and `scope_fifo()` 184 global functions, and their corresponding `ThreadPool` methods. 185 - Normally when tasks are queued on a thread, the most recent is processed 186 first (LIFO) while other threads will steal the oldest (FIFO). With FIFO 187 spawns, those tasks are processed locally in FIFO order too. 188 - Regular spawns and other tasks like `join` are not affected. 189 - The `breadth_first` configuration flag, which globally approximated this 190 effect, is now deprecated. 191 - For more design details, please see [RFC 1]. 192- `ThreadPoolBuilder` can now take a custom `spawn_handler` to control how 193 threads will be created in the pool. 194 - `ThreadPoolBuilder::build_scoped()` uses this to create a scoped thread 195 pool, where the threads are able to use non-static data. 196 - This may also be used to support threading in exotic environments, like 197 WebAssembly, which don't support the normal `std::thread`. 198- `ParallelIterator` has 3 new methods: `find_map_any()`, `find_map_first()`, 199 and `find_map_last()`, like `Iterator::find_map()` with ordering constraints. 200- The new `ParallelIterator::panic_fuse()` makes a parallel iterator halt as soon 201 as possible if any of its threads panic. Otherwise, the panic state is not 202 usually noticed until the iterator joins its parallel tasks back together. 203- `IntoParallelIterator` is now implemented for integral `RangeInclusive`. 204- Several internal `Folder`s now have optimized `consume_iter` implementations. 205- `rayon_core::current_thread_index()` is now re-exported in `rayon`. 206- The minimum `rustc` is now 1.26, following the update policy defined in [RFC 3]. 207 208## Contributors 209 210Thanks to all of the contributors for this release! 211 212- @cuviper 213- @didroe 214- @GuillaumeGomez 215- @huonw 216- @janriemer 217- @kornelski 218- @nikomatsakis 219- @seanchen1991 220- @yegeun542 221 222[RFC 1]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0001-scope-scheduling.md 223[RFC 3]: https://github.com/rayon-rs/rfcs/blob/master/accepted/rfc0003-minimum-rustc.md 224 225 226# Release rayon 1.0.3 (2018-11-02) 227 228- `ParallelExtend` is now implemented for tuple pairs, enabling nested 229 `unzip()` and `partition_map()` operations. For instance, `(A, (B, C))` 230 items can be unzipped into `(Vec<A>, (Vec<B>, Vec<C>))`. 231 - `ParallelExtend<(A, B)>` works like `unzip()`. 232 - `ParallelExtend<Either<A, B>>` works like `partition_map()`. 233- `ParallelIterator` now has a method `map_init()` which calls an `init` 234 function for a value to pair with items, like `map_with()` but dynamically 235 constructed. That value type has no constraints, not even `Send` or `Sync`. 236 - The new `for_each_init()` is a variant of this for simple iteration. 237 - The new `try_for_each_init()` is a variant for fallible iteration. 238 239## Contributors 240 241Thanks to all of the contributors for this release! 242 243- @cuviper 244- @dan-zheng 245- @dholbert 246- @ignatenkobrain 247- @mdonoughe 248 249 250# Release rayon 1.0.2 / rayon-core 1.4.1 (2018-07-17) 251 252- The `ParallelBridge` trait with method `par_bridge()` makes it possible to 253 use any `Send`able `Iterator` in parallel! 254 - This trait has been added to `rayon::prelude`. 255 - It automatically implements internal synchronization and queueing to 256 spread the `Item`s across the thread pool. Iteration order is not 257 preserved by this adaptor. 258 - "Native" Rayon iterators like `par_iter()` should still be preferred when 259 possible for better efficiency. 260- `ParallelString` now has additional methods for parity with `std` string 261 iterators: `par_char_indices()`, `par_bytes()`, `par_encode_utf16()`, 262 `par_matches()`, and `par_match_indices()`. 263- `ParallelIterator` now has fallible methods `try_fold()`, `try_reduce()`, 264 and `try_for_each`, plus `*_with()` variants of each, for automatically 265 short-circuiting iterators on `None` or `Err` values. These are inspired by 266 `Iterator::try_fold()` and `try_for_each()` that were stabilized in Rust 1.27. 267- `Range<i128>` and `Range<u128>` are now supported with Rust 1.26 and later. 268- Small improvements have been made to the documentation. 269- `rayon-core` now only depends on `rand` for testing. 270- Rayon tests now work on stable Rust. 271 272## Contributors 273 274Thanks to all of the contributors for this release! 275 276- @AndyGauge 277- @cuviper 278- @ignatenkobrain 279- @LukasKalbertodt 280- @MajorBreakfast 281- @nikomatsakis 282- @paulkernfeld 283- @QuietMisdreavus 284 285 286# Release rayon 1.0.1 (2018-03-16) 287 288- Added more documentation for `rayon::iter::split()`. 289- Corrected links and typos in documentation. 290 291## Contributors 292 293Thanks to all of the contributors for this release! 294 295- @cuviper 296- @HadrienG2 297- @matthiasbeyer 298- @nikomatsakis 299 300 301# Release rayon 1.0.0 / rayon-core 1.4.0 (2018-02-15) 302 303- `ParallelIterator` added the `update` method which applies a function to 304 mutable references, inspired by `itertools`. 305- `IndexedParallelIterator` added the `chunks` method which yields vectors of 306 consecutive items from the base iterator, inspired by `itertools`. 307- `String` now implements `FromParallelIterator<Cow<str>>` and 308 `ParallelExtend<Cow<str>>`, inspired by `std`. 309- `()` now implements `FromParallelIterator<()>`, inspired by `std`. 310- The new `ThreadPoolBuilder` replaces and deprecates `Configuration`. 311 - Errors from initialization now have the concrete `ThreadPoolBuildError` 312 type, rather than `Box<Error>`, and this type implements `Send` and `Sync`. 313 - `ThreadPool::new` is deprecated in favor of `ThreadPoolBuilder::build`. 314 - `initialize` is deprecated in favor of `ThreadPoolBuilder::build_global`. 315- Examples have been added to most of the parallel iterator methods. 316- A lot of the documentation has been reorganized and extended. 317 318## Breaking changes 319 320- Rayon now requires rustc 1.13 or greater. 321- `IndexedParallelIterator::len` and `ParallelIterator::opt_len` now operate on 322 `&self` instead of `&mut self`. 323- `IndexedParallelIterator::collect_into` is now `collect_into_vec`. 324- `IndexedParallelIterator::unzip_into` is now `unzip_into_vecs`. 325- Rayon no longer exports the deprecated `Configuration` and `initialize` from 326 rayon-core. 327 328## Contributors 329 330Thanks to all of the contributors for this release! 331 332- @Bilkow 333- @cuviper 334- @Enet4 335- @ignatenkobrain 336- @iwillspeak 337- @jeehoonkang 338- @jwass 339- @Kerollmops 340- @KodrAus 341- @kornelski 342- @MaloJaffre 343- @nikomatsakis 344- @obv-mikhail 345- @oddg 346- @phimuemue 347- @stjepang 348- @tmccombs 349- bors[bot] 350 351 352# Release rayon 0.9.0 / rayon-core 1.3.0 / rayon-futures 0.1.0 (2017-11-09) 353 354- `Configuration` now has a `build` method. 355- `ParallelIterator` added `flatten` and `intersperse`, both inspired by 356 itertools. 357- `IndexedParallelIterator` added `interleave`, `interleave_shortest`, and 358 `zip_eq`, all inspired by itertools. 359- The new functions `iter::empty` and `once` create parallel iterators of 360 exactly zero or one item, like their `std` counterparts. 361- The new functions `iter::repeat` and `repeatn` create parallel iterators 362 repeating an item indefinitely or `n` times, respectively. 363- The new function `join_context` works like `join`, with an added `FnContext` 364 parameter that indicates whether the job was stolen. 365- `Either` (used by `ParallelIterator::partition_map`) is now re-exported from 366 the `either` crate, instead of defining our own type. 367 - `Either` also now implements `ParallelIterator`, `IndexedParallelIterator`, 368 and `ParallelExtend` when both of its `Left` and `Right` types do. 369- All public types now implement `Debug`. 370- Many of the parallel iterators now implement `Clone` where possible. 371- Much of the documentation has been extended. (but still could use more help!) 372- All rayon crates have improved metadata. 373- Rayon was evaluated in the Libz Blitz, leading to many of these improvements. 374- Rayon pull requests are now guarded by bors-ng. 375 376## Futures 377 378The `spawn_future()` method has been refactored into its own `rayon-futures` 379crate, now through a `ScopeFutureExt` trait for `ThreadPool` and `Scope`. The 380supporting `rayon-core` APIs are still gated by `--cfg rayon_unstable`. 381 382## Breaking changes 383 384- Two breaking changes have been made to `rayon-core`, but since they're fixing 385 soundness bugs, we are considering these _minor_ changes for semver. 386 - `Scope::spawn` now requires `Send` for the closure. 387 - `ThreadPool::install` now requires `Send` for the return value. 388- The `iter::internal` module has been renamed to `iter::plumbing`, to hopefully 389 indicate that while these are low-level details, they're not really internal 390 or private to rayon. The contents of that module are needed for third-parties 391 to implement new parallel iterators, and we'll treat them with normal semver 392 stability guarantees. 393- The function `rayon::iter::split` is no longer re-exported as `rayon::split`. 394 395## Contributors 396 397Thanks to all of the contributors for this release! 398 399- @AndyGauge 400- @ChristopherDavenport 401- @chrisvittal 402- @cuviper 403- @dns2utf8 404- @dtolnay 405- @frewsxcv 406- @gsquire 407- @Hittherhod 408- @jdr023 409- @laumann 410- @leodasvacas 411- @lvillani 412- @MajorBreakfast 413- @mamuleanu 414- @marmistrz 415- @mbrubeck 416- @mgattozzi 417- @nikomatsakis 418- @smt923 419- @stjepang 420- @tmccombs 421- @vishalsodani 422- bors[bot] 423 424 425# Release rayon 0.8.2 (2017-06-28) 426 427- `ParallelSliceMut` now has six parallel sorting methods with the same 428 variations as the standard library. 429 - `par_sort`, `par_sort_by`, and `par_sort_by_key` perform stable sorts in 430 parallel, using the default order, a custom comparator, or a key extraction 431 function, respectively. 432 - `par_sort_unstable`, `par_sort_unstable_by`, and `par_sort_unstable_by_key` 433 perform unstable sorts with the same comparison options. 434 - Thanks to @stjepang! 435 436 437# Release rayon 0.8.1 / rayon-core 1.2.0 (2017-06-14) 438 439- The following core APIs are being stabilized: 440 - `rayon::spawn()` -- spawns a task into the Rayon threadpool; as it 441 is contained in the global scope (rather than a user-created 442 scope), the task cannot capture anything from the current stack 443 frame. 444 - `ThreadPool::join()`, `ThreadPool::spawn()`, `ThreadPool::scope()` 445 -- convenience APIs for launching new work within a thread-pool. 446- The various iterator adapters are now tagged with `#[must_use]` 447- Parallel iterators now offer a `for_each_with` adapter, similar to 448 `map_with`. 449- We are adopting a new approach to handling the remaining unstable 450 APIs (which primarily pertain to futures integration). As awlays, 451 unstable APIs are intended for experimentation, but do not come with 452 any promise of compatibility (in other words, we might change them 453 in arbitrary ways in any release). Previously, we designated such 454 APIs using a Cargo feature "unstable". Now, we are using a regular 455 `#[cfg]` flag. This means that to see the unstable APIs, you must do 456 `RUSTFLAGS='--cfg rayon_unstable' cargo build`. This is 457 intentionally inconvenient; in particular, if you are a library, 458 then your clients must also modify their environment, signaling 459 their agreement to instability. 460 461 462# Release rayon 0.8.0 / rayon-core 1.1.0 (2017-06-13) 463 464## Rayon 0.8.0 465 466- Added the `map_with` and `fold_with` combinators, which help for 467 passing along state (like channels) that cannot be shared between 468 threads but which can be cloned on each thread split. 469- Added the `while_some` combinator, which helps for writing short-circuiting iterators. 470- Added support for "short-circuiting" collection: e.g., collecting 471 from an iterator producing `Option<T>` or `Result<T, E>` into a 472 `Option<Collection<T>>` or `Result<Collection<T>, E>`. 473- Support `FromParallelIterator` for `Cow`. 474- Removed the deprecated weight APIs. 475- Simplified the parallel iterator trait hierarchy by removing the 476 `BoundedParallelIterator` and `ExactParallelIterator` traits, 477 which were not serving much purpose. 478- Improved documentation. 479- Added some missing `Send` impls. 480- Fixed some small bugs. 481 482## Rayon-core 1.1.0 483 484- We now have more documentation. 485- Renamed the (unstable) methods `spawn_async` and 486 `spawn_future_async` -- which spawn tasks that cannot hold 487 references -- to simply `spawn` and `spawn_future`, respectively. 488- We are now using the coco library for our deque. 489- Individual threadpools can now be configured in "breadth-first" 490 mode, which causes them to execute spawned tasks in the reverse 491 order that they used to. In some specific scenarios, this can be a 492 win (though it is not generally the right choice). 493- Added top-level functions: 494 - `current_thread_index`, for querying the index of the current worker thread within 495 its thread-pool (previously available as `thread_pool.current_thread_index()`); 496 - `current_thread_has_pending_tasks`, for querying whether the 497 current worker that has an empty task deque or not. This can be 498 useful when deciding whether to spawn a task. 499- The environment variables for controlling Rayon are now 500 `RAYON_NUM_THREADS` and `RAYON_LOG`. The older variables (e.g., 501 `RAYON_RS_NUM_CPUS` are still supported but deprecated). 502 503## Rayon-demo 504 505- Added a new game-of-life benchmark. 506 507## Contributors 508 509Thanks to the following contributors: 510 511- @ChristopherDavenport 512- @SuperFluffy 513- @antoinewdg 514- @crazymykl 515- @cuviper 516- @glandium 517- @julian-seward1 518- @leodasvacas 519- @leshow 520- @lilianmoraru 521- @mschmo 522- @nikomatsakis 523- @stjepang 524 525 526# Release rayon 0.7.1 / rayon-core 1.0.2 (2017-05-30) 527 528This release is a targeted performance fix for #343, an issue where 529rayon threads could sometimes enter into a spin loop where they would 530be unable to make progress until they are pre-empted. 531 532 533# Release rayon 0.7 / rayon-core 1.0 (2017-04-06) 534 535This release marks the first step towards Rayon 1.0. **For best 536performance, it is important that all Rayon users update to at least 537Rayon 0.7.** This is because, as of Rayon 0.7, we have taken steps to 538ensure that, no matter how many versions of rayon are actively in use, 539there will only be a single global scheduler. This is achieved via the 540`rayon-core` crate, which is being released at version 1.0, and which 541encapsulates the core schedule APIs like `join()`. (Note: the 542`rayon-core` crate is, to some degree, an implementation detail, and 543not intended to be imported directly; it's entire API surface is 544mirrored through the rayon crate.) 545 546We have also done a lot of work reorganizing the API for Rayon 0.7 in 547preparation for 1.0. The names of iterator types have been changed and 548reorganized (but few users are expected to be naming those types 549explicitly anyhow). In addition, a number of parallel iterator methods 550have been adjusted to match those in the standard iterator traits more 551closely. See the "Breaking Changes" section below for 552details. 553 554Finally, Rayon 0.7 includes a number of new features and new parallel 555iterator methods. **As of this release, Rayon's parallel iterators 556have officially reached parity with sequential iterators** -- that is, 557every sequential iterator method that makes any sense in parallel is 558supported in some capacity. 559 560### New features and methods 561 562- The internal `Producer` trait now features `fold_with`, which enables 563 better performance for some parallel iterators. 564- Strings now support `par_split()` and `par_split_whitespace()`. 565- The `Configuration` API is expanded and simplified: 566 - `num_threads(0)` no longer triggers an error 567 - you can now supply a closure to name the Rayon threads that get created 568 by using `Configuration::thread_name`. 569 - you can now inject code when Rayon threads start up and finish 570 - you can now set a custom panic handler to handle panics in various odd situations 571- Threadpools are now able to more gracefully put threads to sleep when not needed. 572- Parallel iterators now support `find_first()`, `find_last()`, `position_first()`, 573 and `position_last()`. 574- Parallel iterators now support `rev()`, which primarily affects subsequent calls 575 to `enumerate()`. 576- The `scope()` API is now considered stable (and part of `rayon-core`). 577- There is now a useful `rayon::split` function for creating custom 578 Rayon parallel iterators. 579- Parallel iterators now allow you to customize the min/max number of 580 items to be processed in a given thread. This mechanism replaces the 581 older `weight` mechanism, which is deprecated. 582- `sum()` and friends now use the standard `Sum` traits 583 584### Breaking changes 585 586In the move towards 1.0, there have been a number of minor breaking changes: 587 588- Configuration setters like `Configuration::set_num_threads()` lost the `set_` prefix, 589 and hence become something like `Configuration::num_threads()`. 590- `Configuration` getters are removed 591- Iterator types have been shuffled around and exposed more consistently: 592 - combinator types live in `rayon::iter`, e.g. `rayon::iter::Filter` 593 - iterators over various types live in a module named after their type, 594 e.g. `rayon::slice::Windows` 595- When doing a `sum()` or `product()`, type annotations are needed for the result 596 since it is now possible to have the resulting sum be of a type other than the value 597 you are iterating over (this mirrors sequential iterators). 598 599### Experimental features 600 601Experimental features require the use of the `unstable` feature. Their 602APIs may change or disappear entirely in future releases (even minor 603releases) and hence they should be avoided for production code. 604 605- We now have (unstable) support for futures integration. You can use 606 `Scope::spawn_future` or `rayon::spawn_future_async()`. 607- There is now a `rayon::spawn_async()` function for using the Rayon 608 threadpool to run tasks that do not have references to the stack. 609 610### Contributors 611 612Thanks to the following people for their contributions to this release: 613 614- @Aaronepower 615- @ChristopherDavenport 616- @bluss 617- @cuviper 618- @froydnj 619- @gaurikholkar 620- @hniksic 621- @leodasvacas 622- @leshow 623- @martinhath 624- @mbrubeck 625- @nikomatsakis 626- @pegomes 627- @schuster 628- @torkleyy 629 630 631# Release 0.6 (2016-12-21) 632 633This release includes a lot of progress towards the goal of parity 634with the sequential iterator API, though there are still a few methods 635that are not yet complete. If you'd like to help with that effort, 636[check out the milestone](https://github.com/rayon-rs/rayon/issues?q=is%3Aopen+is%3Aissue+milestone%3A%22Parity+with+the+%60Iterator%60+trait%22) 637to see the remaining issues. 638 639**Announcement:** @cuviper has been added as a collaborator to the 640Rayon repository for all of his outstanding work on Rayon, which 641includes both internal refactoring and helping to shape the public 642API. Thanks @cuviper! Keep it up. 643 644- We now support `collect()` and not just `collect_with()`. 645 You can use `collect()` to build a number of collections, 646 including vectors, maps, and sets. Moreover, when building a vector 647 with `collect()`, you are no longer limited to exact parallel iterators. 648 Thanks @nikomatsakis, @cuviper! 649- We now support `skip()` and `take()` on parallel iterators. 650 Thanks @martinhath! 651- **Breaking change:** We now match the sequential APIs for `min()` and `max()`. 652 We also support `min_by_key()` and `max_by_key()`. Thanks @tapeinosyne! 653- **Breaking change:** The `mul()` method is now renamed to `product()`, 654 to match sequential iterators. Thanks @jonathandturner! 655- We now support parallel iterator over ranges on `u64` values. Thanks @cuviper! 656- We now offer a `par_chars()` method on strings for iterating over characters 657 in parallel. Thanks @cuviper! 658- We now have new demos: a traveling salesman problem solver as well as matrix 659 multiplication. Thanks @nikomatsakis, @edre! 660- We are now documenting our minimum rustc requirement (currently 661 v1.12.0). We will attempt to maintain compatibility with rustc 662 stable v1.12.0 as long as it remains convenient, but if new features 663 are stabilized or added that would be helpful to Rayon, or there are 664 bug fixes that we need, we will bump to the most recent rustc. Thanks @cuviper! 665- The `reduce()` functionality now has better inlining. 666 Thanks @bluss! 667- The `join()` function now has some documentation. Thanks @gsquire! 668- The project source has now been fully run through rustfmt. 669 Thanks @ChristopherDavenport! 670- Exposed helper methods for accessing the current thread index. 671 Thanks @bholley! 672 673 674# Release 0.5 (2016-11-04) 675 676- **Breaking change:** The `reduce` method has been vastly 677 simplified, and `reduce_with_identity` has been deprecated. 678- **Breaking change:** The `fold` method has been changed. It used to 679 always reduce the values, but now instead it is a combinator that 680 returns a parallel iterator which can itself be reduced. See the 681 docs for more information. 682- The following parallel iterator combinators are now available (thanks @cuviper!): 683 - `find_any()`: similar to `find` on a sequential iterator, 684 but doesn't necessarily return the *first* matching item 685 - `position_any()`: similar to `position` on a sequential iterator, 686 but doesn't necessarily return the index of *first* matching item 687 - `any()`, `all()`: just like their sequential counterparts 688- The `count()` combinator is now available for parallel iterators. 689- We now build with older versions of rustc again (thanks @durango!), 690 as we removed a stray semicolon from `thread_local!`. 691- Various improvements to the (unstable) `scope()` API implementation. 692 693 694# Release 0.4.3 (2016-10-25) 695 696- Parallel iterators now offer an adaptive weight scheme, 697 which means that explicit weights should no longer 698 be necessary in most cases! Thanks @cuviper! 699 - We are considering removing weights or changing the weight mechanism 700 before 1.0. Examples of scenarios where you still need weights even 701 with this adaptive mechanism would be great. Join the discussion 702 at <https://github.com/rayon-rs/rayon/issues/111>. 703- New (unstable) scoped threads API, see `rayon::scope` for details. 704 - You will need to supply the [cargo feature] `unstable`. 705- The various demos and benchmarks have been consolidated into one 706 program, `rayon-demo`. 707- Optimizations in Rayon's inner workings. Thanks @emilio! 708- Update `num_cpus` to 1.0. Thanks @jamwt! 709- Various internal cleanup in the implementation and typo fixes. 710 Thanks @cuviper, @Eh2406, and @spacejam! 711 712[cargo feature]: https://doc.rust-lang.org/cargo/reference/features.html#the-features-section 713 714 715# Release 0.4.2 (2016-09-15) 716 717- Updated crates.io metadata. 718 719 720# Release 0.4.1 (2016-09-14) 721 722- New `chain` combinator for parallel iterators. 723- `Option`, `Result`, as well as many more collection types now have 724 parallel iterators. 725- New mergesort demo. 726- Misc fixes. 727 728Thanks to @cuviper, @edre, @jdanford, @frewsxcv for their contributions! 729 730 731# Release 0.4 (2016-05-16) 732 733- Make use of latest versions of catch-panic and various fixes to panic propagation. 734- Add new prime sieve demo. 735- Add `cloned()` and `inspect()` combinators. 736- Misc fixes for Rust RFC 1214. 737 738Thanks to @areilb1, @Amanieu, @SharplEr, and @cuviper for their contributions! 739 740 741# Release 0.3 (2016-02-23) 742 743- Expanded `par_iter` APIs now available: 744 - `into_par_iter` is now supported on vectors (taking ownership of the elements) 745- Panic handling is much improved: 746 - if you use the Nightly feature, experimental panic recovery is available 747 - otherwise, panics propagate out and poision the workpool 748- New `Configuration` object to control number of threads and other details 749- New demos and benchmarks 750 - try `cargo run --release -- visualize` in `demo/nbody` :) 751 - Note: a nightly compiler is required for this demo due to the 752 use of the `+=` syntax 753 754Thanks to @bjz, @cuviper, @Amanieu, and @willi-kappler for their contributions! 755 756 757# Release 0.2 and earlier 758 759No release notes were being kept at this time. 760