Debian Codegraph @

.cargo/vendor/rayon/RELEASES.md

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