| 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. |