code_ownership 2.0.0.pre.1 → 2.0.0.pre.3

data/ext/cargo-vendor/rayon-1.10.0/.cargo-checksum.json

@@ -1 +0,0 @@
-{"files":{".cargo_vcs_info.json":"ff97d4add5030139e1f42b5aaca9bfc3f74f5cd746853e15f96ebcab07c34296","Cargo.toml":"5c786211c556fd7f0a58c16d034d70bafe221c8c084d7af1d601c85053cec6ee","Cargo.toml.orig":"81fde7efd7f502454cc0329eeebb59c9c61b96c80c8b2a56a73fc139556f2db5","FAQ.md":"e963b051f6295a2944ff5abec368c7da914b913e21049978c2ef0017294abf8f","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0621878e61f0d0fda054bcbe02df75192c28bde1ecc8289cbd86aeba2dd72720","README.md":"5dada1ceff462280be5af52131dbc529cb26bc6eb04d3cf2403ac234a0725fff","RELEASES.md":"2287b9d2894288c931aab43c26bef2fc76f97cef4accbb6cc9960680efaa7311","src/array.rs":"0e1524d222baa8b64f67689b0dea3115f3befb8cc3b5aee9ace169c57b2d29d2","src/collections/binary_heap.rs":"58e2590ff52fa2cfe7b5797fdc37902d0c111cca844aac21a4024add2f28a8db","src/collections/btree_map.rs":"d3094ed5c54620f81a86133f52e74164bae9f0137745eb66e6d31db2e942bcab","src/collections/btree_set.rs":"7de12e388d36cb2f8672bc3b68aed5b44d047c9f5fe262a7260584634299480f","src/collections/hash_map.rs":"cdaf1aa3bedf9bde591fcb323d64bee9366feb35fee6886bedb5fec8d0018564","src/collections/hash_set.rs":"685690108fc20eca2cf346e74e48d6c751f5ceb6028996366d49f1f1ad6051e0","src/collections/linked_list.rs":"bef7f32da49b55db76cfefa0afa4789a6979e08a69427e49bab2874967163fef","src/collections/mod.rs":"3978222720a2df20be7fd0856d8515b6f9fa40f6556662bd3c0726b1392970ca","src/collections/vec_deque.rs":"d14aa4edc858cd3469fff3597fc35ab83c27f3bdf66ede06d1dd25021f383109","src/compile_fail/cannot_collect_filtermap_data.rs":"f76e6727ae8bd0dc8fff5f4a79df3fc598daf5d7371bdf8b2e730fba4ba82719","src/compile_fail/cannot_zip_filtered_data.rs":"3588fcf72e804ea867ea525b6dfa7a3d45fe14e28088e849fa9ddb029acc8a7a","src/compile_fail/cell_par_iter.rs":"ebf8804993c103f9d8228aba0bb2a5f0aadb957de9f1eb59cf546dbace285201","src/compile_fail/mod.rs":"2c346e4b52941fe0ac2667eeb753c0c21a1f998a544bb9d9167f200caba0a7bb","src/compile_fail/must_use.rs":"39ab32af552c2b35e67593b54da146d8edd8e022dbadcf7a81983983a065bbc2","src/compile_fail/no_send_par_iter.rs":"b241446439c659f35060df12ba91590ea4267f373ddc688e4ffc203321db24b3","src/compile_fail/rc_par_iter.rs":"938776b08612e35c85b99962024d54af5a8c87d45a050a76375d16ef6fe4299f","src/delegate.rs":"aad2a11998240fb7dd96bd054b588cac469df3b716b8dffb05239102b6507d05","src/iter/blocks.rs":"851cd78b26d9ae0b789566f2fe018502c80ff6352b4a06f71f14326d78759074","src/iter/chain.rs":"9a79215e5f40619b023a6cc4111dd13644fa290397f01836a9f6cc1a3df5355a","src/iter/chunks.rs":"fa7242ce8e84b0f5c2d1c0116ad635ba149db988c903863bd62d64ff51065130","src/iter/cloned.rs":"35e1c864f99f7bc93c258c4976d15ccfc1d04df969dc878fd03d35f6799377f7","src/iter/collect/consumer.rs":"5f9728fdf2db728a3ea37849c2fc43c417b221e580860be4dfc6cab526e57f8e","src/iter/collect/mod.rs":"ede28d59713c3291709a842cd54b17760008f6854a3982404eca973bdc3d2f23","src/iter/collect/test.rs":"9afcf4c6cf6bbfe22aed42e5bb5a0dcbd4d7c9b060d80d3b01fad665b46e4952","src/iter/copied.rs":"1a3457f3b0fb020593049b8b1f1be2f7a6684c2fcc66c02c911cb14e0a1943d7","src/iter/empty.rs":"3cb2d05721aab1a4d9e9c5813473e1646116c1ea570e26d9ac81e083688a0b7d","src/iter/enumerate.rs":"3204255723a93b3275cf0f208939de8960b13a9b13b8c2ba6b664e65da21cd87","src/iter/extend.rs":"7f1d1f4e90f046ef2fd35736850aab0c1a92395cf83175f93f6bdac74c48f5b3","src/iter/filter.rs":"e48f317ee4d66dea6f19ac2607c6f764d20c023d847b66c6c01826e6a46f96ab","src/iter/filter_map.rs":"2530b726b27fe3a678a34722b1baf8e223a65a0770fa8ed5dca13786ea454580","src/iter/find.rs":"896ddb05b2fa7368462e0ff2a73982ced5f93266c0e0e8c27bb3fc4ec737af21","src/iter/find_first_last/mod.rs":"3759a42531b5593f4a19196a5cc38b4afc322b12ec50beb3c0bb1389de4b14ca","src/iter/find_first_last/test.rs":"fe11970bbe0eb07aee1bd44c3b0cdcdae3d0630269d6530658cadd7f17724e0b","src/iter/flat_map.rs":"4db54dcda5f1f916497d0162268e6cd554478bc7ea0190709cc7c73941a0e20f","src/iter/flat_map_iter.rs":"81886d1d71f4991963ec9b6d767d9ef391c9e84807d27f6135cd92a451dc1b32","src/iter/flatten.rs":"93407a8f44f4a265f47d7fe568508d6ef922597c4ca4558e8945cf1aacdd6b30","src/iter/flatten_iter.rs":"23cf3ddc25b6cad117932c4bac2e8b945c6b56626730fd3b1787f233495d15e6","src/iter/fold.rs":"874259b408d7f8cdc376d34276d37c1837950c035ff780de8281d1edf65ded9f","src/iter/fold_chunks.rs":"2c60b969fb5a148b092bd92619b13ee669ff82d008f36dae5f4f908eb277f1d8","src/iter/fold_chunks_with.rs":"d1bd686202c21a54b60cbe7c7db30a09c35ec35fb544c18966c8e8606ac25490","src/iter/for_each.rs":"7af0e21ed8479eec65831d1409f61a88d45a31764f2385ec759eda1a46d388b2","src/iter/from_par_iter.rs":"46d4e004a71fe83368c59dc85e9eca9bc813b40bf787b971a3e74efef3975c78","src/iter/inspect.rs":"d502b6e435a44f34ba49dfe46aa809a1bad3dbaefa048540a98e3026437b1016","src/iter/interleave.rs":"b3746c549cede5b978392f10305bd44fe12fa0566cd0be9c11587ed70eb92b19","src/iter/interleave_shortest.rs":"a2b1f31ea4cb29f4761d3724feddcf5a96e1f21fd623f95c85a8659294a6745a","src/iter/intersperse.rs":"6b5d3d826ed3499ba78f0ff07468d96a0e104c7ee142a2ced6be8143b43241a5","src/iter/len.rs":"5159ed82c624481808d94714a3c3151c431dd50d4dd27d4566c82de01be08b7d","src/iter/map.rs":"f778f1bd0a71c962375d2ce886b40ac365afed4a032e2b9dd6c385712d3d75eb","src/iter/map_with.rs":"f83950016bb02addecec049fda73663861c80232477a7b89b7e8718291a4b481","src/iter/mod.rs":"fd42fc5b56e05f1f18724472cd25938c05f78b463d2106df0d2fd48b3f200843","src/iter/multizip.rs":"10ec107f6673c9bc6d1d611e11b716c37e8601ab2f4257a460c4bc4962771347","src/iter/noop.rs":"5be6332ddfbb8fdbae1ffdb00983950a8b37a295bcb58e9a265b33806ee504e6","src/iter/once.rs":"fcebffc374dcdd206d13311dcc2e7d7a04da5687658b2f3ec3409f03ed12774b","src/iter/panic_fuse.rs":"2a4d43fa4e717629de7f69eb180f13db90ef95004975cfa20dcfaacc80435015","src/iter/par_bridge.rs":"344c6233e6f799a95b1df517429ee53c817dd227be3c351a7ccc725c57f9f962","src/iter/plumbing/README.md":"da11d90143745b30efe99934bb5d8267d7b205c8096d0936ddb1bbba0b13ea17","src/iter/plumbing/mod.rs":"cb6402a297ab7e43badd9dc6ec76f604525f5365d27e82ba829fb73b009f2ae2","src/iter/positions.rs":"b7abfb59c12b6cceb5e539e85f9eca836054ae88225e16cfc0ba8e68177c7917","src/iter/product.rs":"eaddbf216b068d33cb92f594cf57522f6ea1e2d7699887a086484843bdec3585","src/iter/reduce.rs":"2f5d6e07d7c0de2360505fa5d9198c31fd43ba7e58a6ec40f79edec19319e502","src/iter/repeat.rs":"ed46b17b79d8569f9d67b50585b116ee0293e1d6c17c0dc683c66644f6a58fd5","src/iter/rev.rs":"c4c796d7cb6398e74bef043a080403acccdf70f6a4e74b242e530d1718969b8f","src/iter/skip.rs":"8ac3dd56f306c40b86a4da32cf7f4ceee58a9c0f33dcad8b2b09fb74150bf5b4","src/iter/skip_any.rs":"e827e1658aea906ab1045533d97476a91886dc6c41ab1fe9b6147f90385e45b8","src/iter/skip_any_while.rs":"88e8f5aea16cde70ae41f5eb32749e955861a476766ff678b8bbfca96ed80803","src/iter/splitter.rs":"0024db04b4430c2a1e8c921cec86af641f612f877f3675b15df0da9122de5f00","src/iter/step_by.rs":"a8e0af1c831f843100ce1e1d8ff51a8d01a2935bdfbee74b5e7a65faf93a508c","src/iter/sum.rs":"073a886b8d6b0d7ca5621449a20e9980c90c6d39de56f074371fb075d9df2bed","src/iter/take.rs":"c3f8e46dca9bd89c26c15a2ecbd013ee3dfef4b3975c73c23849b03fb7493fc7","src/iter/take_any.rs":"51f5b39c3fb608fcf7d7b35592a28d95250d9cbb28dbc13a0dc01d22aa0023f9","src/iter/take_any_while.rs":"8327c019b4047d567d8fdae975049c9bc1e4422dddffd3196b62c938d1f5e1fc","src/iter/test.rs":"ae4de120904370fa197f950350b07db01da9f292769342616a516c9786de283f","src/iter/try_fold.rs":"d4f40a00995273b8803031da4a4b139a5f462a174ef1d3c8ba54524b47ab8180","src/iter/try_reduce.rs":"12317a649f777e76e6ae610d205104d7946fbe45804fbf1caa0843118531baed","src/iter/try_reduce_with.rs":"9171563fc22110d7a359f19de7ca66a6823d8f712099d05d01560795781fdeec","src/iter/unzip.rs":"9a16ea1f3b3019a090b7189f6c42c75beb3537bc849bd4c51093120a907cea6b","src/iter/update.rs":"0362185a002cdda0e73b13237017ddc3d5e72390bba6cb2e2f021e947ed861dc","src/iter/walk_tree.rs":"668e687fe7761008ea95d95f5e05bba6e63053ac90aa4677a619439801f2350d","src/iter/while_some.rs":"a514891d7a07031354b48e377c239ff330d0955f184abc57a69d2a193e7fcb45","src/iter/zip.rs":"b15e418daeb2feb85d3d993b307a47018f44746cc9669f15d6bee6c7840b0645","src/iter/zip_eq.rs":"4c18d8f7a78e197a3268c9ef74d16690f8c960407c18bb63dc6905a2fe2bde62","src/lib.rs":"027d4a42a3728ac6819c1fc2983d762ea66e2e29edc7ec7df2435884ad75bd6f","src/math.rs":"040e82a4ba7a6680eb65b65f4d1fc3dc477d902855d8651105b138ae2e71c8e8","src/option.rs":"00979a9bb8f42629f2b956a6cfbd286fc8a41ffbbec85f1b5d0f0da5615dac9c","src/par_either.rs":"afa4b04ba6ea1d37aed2d68eca44d7ba0d1d09ea985c9091540dd8d3c51974f1","src/prelude.rs":"b1af578abff57f9c8a285c39e3793125cf40d9901d0f2a4f0c5f1bb9252a08de","src/private.rs":"152f6d65ce4741616a1dec796b9442f78a018d38bb040f76c4cd85008333a3bb","src/range.rs":"e88bd691f0ce5b82f6d185df30180b143856cfde53974e1d8cf2a9d5abb2a867","src/range_inclusive.rs":"130a58852281195b979c5a2875349e99b7c72185e8da645addaacca33b7394de","src/result.rs":"0656f0000efcea10e571df90247925dfd00a0c2194043fcbc009711fb2f7af02","src/slice/chunk_by.rs":"bca36aa0920039d398b4f8e218ffe61bf657c2a782ed37d08680c94567e012f9","src/slice/chunks.rs":"8a2066ddda9f0cf00f2b284e211311ca26b33e9a8bdc2ae201369f5bae4fb41b","src/slice/mergesort.rs":"effe59ecc40b330c364a3da868182b72b487025d9ba0256079f8a284b85a05ef","src/slice/mod.rs":"d16808e3820166032bd32cc678ce80b01bd8c9420ab27d1717e4b72b4694d843","src/slice/quicksort.rs":"082eb0acb08b675607b0d5a6e99f40bebf924dad6f53c848fc3c2458cc1a48e5","src/slice/rchunks.rs":"23229976840da07e8fff6657ca626810ed380682719e4d1f0693ac08839e1b7c","src/slice/test.rs":"6789b33d62a913770d5b60d26eb587a4243c15b2a1c6f0a6f613806576943694","src/split_producer.rs":"b2633e62bf87ccdc81d0d738de8f184f5892129fc31e81bc891e978b7179e695","src/str.rs":"f8720e1a167a186169797dd4342cde7be45d0ded453c461c42a1331e1c9f6274","src/string.rs":"6691dd31264bd93a0528fc584585415c12f56cfb4baebbfd31ea2f1b21550f77","src/vec.rs":"c80653f3040c07e04fa293fa0359e1f8e7faad13d67899e78780e855b6f9f63a","tests/chars.rs":"6e1aeda8aa604f15965aa3c735da07f2145bd06079abb684b70598c86d99a263","tests/clones.rs":"6088be680e6b25d919ae4a23c1185202870b83789fedaed3cbf2d9e8fb612212","tests/collect.rs":"3ae066cd89eacc9d171ad99ec73335e8040748370e3a3f46845d5af12ce30cc2","tests/cross-pool.rs":"d2ce3b9013f77c955aa02313b27436c5bf760ab0e6a1e7d768effae69b5bdbfe","tests/debug.rs":"5c77126f8145bca24d76022649d84d5d525d90c7fcb3a8d3c0cd1ac05439cf17","tests/drain_vec.rs":"305ca40ba41ed3b459a334386cd742c66586d62aadfb624278aabdf10b872a12","tests/intersperse.rs":"bda4fb2179086e32c77c8293b9bb85d55509c282441837ba1849c2d3aa3186a7","tests/issue671-unzip.rs":"d5eb38d8a6d8f66fdf1c40293abbf58f3ac42b5acfc5dca62b02c7ace5bfc1a4","tests/issue671.rs":"52914cac517074deaedcb81bd76b867f0b99cc7b65c3e01cfe12dc9fe38c0266","tests/iter_panic.rs":"2ca857b37b740528b2e8395b479a409227383b46e0ed012286dcdd1330dacd70","tests/named-threads.rs":"9bd7ea27b4f6cf9e3b3486311747e15a3beb9b9d4e48f115d66ed8288ca19d38","tests/octillion.rs":"756d3789300d6eb4d5f7690937e06f87714b6b0a62ac812f72b622bb6974ccd2","tests/par_bridge_recursion.rs":"6e7030de6d97d1db1c335f676dd2a6348cde2873520df290c4a16bf949c06f00","tests/producer_split_at.rs":"17caad52fb7c9b3e09a2a138e402db39d1d3a96f2305461cbe36c45f7b85f8d5","tests/sort-panic-safe.rs":"ee4093d5367e0a6dae086db71b5d25c4d37773b985575a41f30c72b151e4072d","tests/str.rs":"34aac04413ad0370e6abc66ccc21b00c07655f82d046e47134c6ae0a9c4642e1"},"package":"b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"}

data/ext/cargo-vendor/rayon-1.10.0/.cargo_vcs_info.json

@@ -1,6 +0,0 @@
-{
-  "git": {
-    "sha1": "7543ed40c9a017dee32b3dc72b3ae819820e8366"
-  },
-  "path_in_vcs": ""
-}

data/ext/cargo-vendor/rayon-1.10.0/Cargo.toml

@@ -1,61 +0,0 @@
-# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
-#
-# When uploading crates to the registry Cargo will automatically
-# "normalize" Cargo.toml files for maximal compatibility
-# with all versions of Cargo and also rewrite `path` dependencies
-# to registry (e.g., crates.io) dependencies.
-#
-# If you are reading this file be aware that the original Cargo.toml
-# will likely look very different (and much more reasonable).
-# See Cargo.toml.orig for the original contents.
-
-[package]
-edition = "2021"
-rust-version = "1.63"
-name = "rayon"
-version = "1.10.0"
-authors = [
-    "Niko Matsakis <niko@alum.mit.edu>",
-    "Josh Stone <cuviper@gmail.com>",
-]
-exclude = [
-    "/ci/*",
-    "/scripts/*",
-    "/.github/*",
-]
-description = "Simple work-stealing parallelism for Rust"
-documentation = "https://docs.rs/rayon/"
-readme = "README.md"
-keywords = [
-    "parallel",
-    "thread",
-    "concurrency",
-    "join",
-    "performance",
-]
-categories = ["concurrency"]
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/rayon-rs/rayon"
-
-[dependencies.either]
-version = "1.0"
-default-features = false
-
-[dependencies.rayon-core]
-version = "1.12.1"
-
-[dependencies.wasm_sync]
-version = "0.1.0"
-optional = true
-
-[dev-dependencies.rand]
-version = "0.8"
-
-[dev-dependencies.rand_xorshift]
-version = "0.3"
-
-[features]
-web_spin_lock = [
-    "dep:wasm_sync",
-    "rayon-core/web_spin_lock",
-]

data/ext/cargo-vendor/rayon-1.10.0/Cargo.toml.orig

@@ -1,39 +0,0 @@
-[package]
-name = "rayon"
-version = "1.10.0"
-authors = ["Niko Matsakis <niko@alum.mit.edu>",
-           "Josh Stone <cuviper@gmail.com>"]
-description = "Simple work-stealing parallelism for Rust"
-rust-version = "1.63"
-edition = "2021"
-license = "MIT OR Apache-2.0"
-repository = "https://github.com/rayon-rs/rayon"
-documentation = "https://docs.rs/rayon/"
-readme = "README.md"
-keywords = ["parallel", "thread", "concurrency", "join", "performance"]
-categories = ["concurrency"]
-exclude = ["/ci/*", "/scripts/*", "/.github/*"]
-
-[workspace]
-members = ["rayon-demo", "rayon-core"]
-exclude = ["ci"]
-
-[dependencies]
-rayon-core = { version = "1.12.1", path = "rayon-core" }
-wasm_sync = { version = "0.1.0", optional = true }
-
-# This is a public dependency!
-[dependencies.either]
-version = "1.0"
-default-features = false
-
-[features]
-# This feature switches to a spin-lock implementation on the browser's
-# main thread to avoid the forbidden `atomics.wait`.
-#
-# Only useful on the `wasm32-unknown-unknown` target.
-web_spin_lock = ["dep:wasm_sync", "rayon-core/web_spin_lock"]
-
-[dev-dependencies]
-rand = "0.8"
-rand_xorshift = "0.3"

data/ext/cargo-vendor/rayon-1.10.0/FAQ.md

@@ -1,227 +0,0 @@
-# Rayon FAQ
-
-This file is for general questions that don't fit into the README or
-crate docs.
-
-## How many threads will Rayon spawn?
-
-By default, Rayon uses the same number of threads as the number of
-CPUs available. Note that on systems with hyperthreading enabled this
-equals the number of logical cores and not the physical ones.
-
-If you want to alter the number of threads spawned, you can set the
-environmental variable `RAYON_NUM_THREADS` to the desired number of
-threads or use the
-[`ThreadPoolBuilder::build_global` function](https://docs.rs/rayon/*/rayon/struct.ThreadPoolBuilder.html#method.build_global)
-method.
-
-## How does Rayon balance work between threads?
-
-Behind the scenes, Rayon uses a technique called **work stealing** to
-try and dynamically ascertain how much parallelism is available and
-exploit it. The idea is very simple: we always have a pool of worker
-threads available, waiting for some work to do. When you call `join`
-the first time, we shift over into that pool of threads. But if you
-call `join(a, b)` from a worker thread W, then W will place `b` into
-its work queue, advertising that this is work that other worker
-threads might help out with. W will then start executing `a`.
-
-While W is busy with `a`, other threads might come along and take `b`
-from its queue. That is called *stealing* `b`. Once `a` is done, W
-checks whether `b` was stolen by another thread and, if not, executes
-`b` itself. If W runs out of jobs in its own queue, it will look
-through the other threads' queues and try to steal work from them.
-
-This technique is not new. It was first introduced by the
-[Cilk project][cilk], done at MIT in the late nineties. The name Rayon
-is an homage to that work.
-
-[cilk]: http://supertech.csail.mit.edu/cilk/
-
-## What should I do if I use `Rc`, `Cell`, `RefCell` or other non-Send-and-Sync types?
-
-There are a number of non-threadsafe types in the Rust standard library,
-and if your code is using them, you will not be able to combine it
-with Rayon. Similarly, even if you don't have such types, but you try
-to have multiple closures mutating the same state, you will get
-compilation errors; for example, this function won't work, because
-both closures access `slice`:
-
-```rust
-/// Increment all values in slice.
-fn increment_all(slice: &mut [i32]) {
-    rayon::join(|| process(slice), || process(slice));
-}
-```
-
-The correct way to resolve such errors will depend on the case.  Some
-cases are easy: for example, uses of [`Rc`] can typically be replaced
-with [`Arc`], which is basically equivalent, but thread-safe.
-
-Code that uses `Cell` or `RefCell`, however, can be somewhat more complicated.
-If you can refactor your code to avoid those types, that is often the best way
-forward, but otherwise, you can try to replace those types with their threadsafe
-equivalents:
-
-- `Cell` -- replacement: `AtomicUsize`, `AtomicBool`, etc
-- `RefCell` -- replacement: `RwLock`, or perhaps `Mutex`
-
-However, you have to be wary! The parallel versions of these types
-have different atomicity guarantees. For example, with a `Cell`, you
-can increment a counter like so:
-
-```rust
-let value = counter.get();
-counter.set(value + 1);
-```
-
-But when you use the equivalent `AtomicUsize` methods, you are
-actually introducing a potential race condition (not a data race,
-technically, but it can be an awfully fine distinction):
-
-```rust
-let value = tscounter.load(Ordering::SeqCst);
-tscounter.store(value + 1, Ordering::SeqCst);
-```
-
-You can already see that the `AtomicUsize` API is a bit more complex,
-as it requires you to specify an
-[ordering](https://doc.rust-lang.org/std/sync/atomic/enum.Ordering.html). (I
-won't go into the details on ordering here, but suffice to say that if
-you don't know what an ordering is, and probably even if you do, you
-should use `Ordering::SeqCst`.) The danger in this parallel version of
-the counter is that other threads might be running at the same time
-and they could cause our counter to get out of sync. For example, if
-we have two threads, then they might both execute the "load" before
-either has a chance to execute the "store":
-
-```
-Thread 1                                          Thread 2
-let value = tscounter.load(Ordering::SeqCst);
-// value = X                                      let value = tscounter.load(Ordering::SeqCst);
-                                                  // value = X
-tscounter.store(value+1);                         tscounter.store(value+1);
-// tscounter = X+1                                // tscounter = X+1
-```
-
-Now even though we've had two increments, we'll only increase the
-counter by one!  Even though we've got no data race, this is still
-probably not the result we wanted. The problem here is that the `Cell`
-API doesn't make clear the scope of a "transaction" -- that is, the
-set of reads/writes that should occur atomically. In this case, we
-probably wanted the get/set to occur together.
-
-In fact, when using the `Atomic` types, you very rarely want a plain
-`load` or plain `store`. You probably want the more complex
-operations. A counter, for example, would use `fetch_add` to
-atomically load and increment the value in one step. Compare-and-swap
-is another popular building block.
-
-A similar problem can arise when converting `RefCell` to `RwLock`, but
-it is somewhat less likely, because the `RefCell` API does in fact
-have a notion of a transaction: the scope of the handle returned by
-`borrow` or `borrow_mut`. So if you convert each call to `borrow` to
-`read` (and `borrow_mut` to `write`), things will mostly work fine in
-a parallel setting, but there can still be changes in behavior.
-Consider using a `handle: RefCell<Vec<i32>>` like:
-
-```rust
-let len = handle.borrow().len();
-for i in 0 .. len {
-    let data = handle.borrow()[i];
-    println!("{}", data);
-}
-```
-
-In sequential code, we know that this loop is safe. But if we convert
-this to parallel code with an `RwLock`, we do not: this is because
-another thread could come along and do
-`handle.write().unwrap().pop()`, and thus change the length of the
-vector. In fact, even in *sequential* code, using very small borrow
-sections like this is an anti-pattern: you ought to be enclosing the
-entire transaction together, like so:
-
-```rust
-let vec = handle.borrow();
-let len = vec.len();
-for i in 0 .. len {
-    let data = vec[i];
-    println!("{}", data);
-}
-```
-
-Or, even better, using an iterator instead of indexing:
-
-```rust
-let vec = handle.borrow();
-for data in vec {
-    println!("{}", data);
-}
-```
-
-There are several reasons to prefer one borrow over many. The most
-obvious is that it is more efficient, since each borrow has to perform
-some safety checks. But it's also more reliable: suppose we modified
-the loop above to not just print things out, but also call into a
-helper function:
-
-```rust
-let vec = handle.borrow();
-for data in vec {
-    helper(...);
-}
-```
-
-And now suppose, independently, this helper fn evolved and had to pop
-something off of the vector:
-
-```rust
-fn helper(...) {
-    handle.borrow_mut().pop();
-}
-```
-
-Under the old model, where we did lots of small borrows, this would
-yield precisely the same error that we saw in parallel land using an
-`RwLock`: the length would be out of sync and our indexing would fail
-(note that in neither case would there be an actual *data race* and
-hence there would never be undefined behavior). But now that we use a
-single borrow, we'll see a borrow error instead, which is much easier
-to diagnose, since it occurs at the point of the `borrow_mut`, rather
-than downstream. Similarly, if we move to an `RwLock`, we'll find that
-the code either deadlocks (if the write is on the same thread as the
-read) or, if the write is on another thread, works just fine. Both of
-these are preferable to random failures in my experience.
-
-## But wait, isn't Rust supposed to free me from this kind of thinking?
-
-You might think that Rust is supposed to mean that you don't have to
-think about atomicity at all. In fact, if you avoid interior
-mutability (`Cell` and `RefCell` in a sequential setting, or
-`AtomicUsize`, `RwLock`, `Mutex`, et al. in parallel code), then this
-is true: the type system will basically guarantee that you don't have
-to think about atomicity at all. But often there are times when you
-WANT threads to interleave in the ways I showed above.
-
-Consider for example when you are conducting a search in parallel, say
-to find the shortest route. To avoid fruitless search, you might want
-to keep a cell with the shortest route you've found thus far.  This
-way, when you are searching down some path that's already longer than
-this shortest route, you can just stop and avoid wasted effort. In
-sequential land, you might model this "best result" as a shared value
-like `Rc<Cell<usize>>` (here the `usize` represents the length of best
-path found so far); in parallel land, you'd use a `Arc<AtomicUsize>`.
-Now we can make our search function look like:
-
-```rust
-fn search(path: &Path, cost_so_far: usize, best_cost: &Arc<AtomicUsize>) {
-    if cost_so_far >= best_cost.load(Ordering::SeqCst) {
-        return;
-    }
-    ...
-    best_cost.store(...);
-}
-```
-
-Now in this case, we really WANT to see results from other threads
-interjected into our execution!

data/ext/cargo-vendor/rayon-1.10.0/README.md

@@ -1,151 +0,0 @@
-# Rayon
-
-[![Rayon crate](https://img.shields.io/crates/v/rayon.svg)](https://crates.io/crates/rayon)
-[![Rayon documentation](https://docs.rs/rayon/badge.svg)](https://docs.rs/rayon)
-![minimum rustc 1.63](https://img.shields.io/badge/rustc-1.63+-red.svg)
-[![build status](https://github.com/rayon-rs/rayon/workflows/main/badge.svg)](https://github.com/rayon-rs/rayon/actions)
-[![Join the chat at https://gitter.im/rayon-rs/Lobby](https://badges.gitter.im/rayon-rs/Lobby.svg)](https://gitter.im/rayon-rs/Lobby?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
-
-Rayon is a data-parallelism library for Rust. It is extremely
-lightweight and makes it easy to convert a sequential computation into
-a parallel one. It also guarantees data-race freedom. (You may also
-enjoy [this blog post][blog] about Rayon, which gives more background
-and details about how it works, or [this video][video], from the Rust
-Belt Rust conference.) Rayon is
-[available on crates.io](https://crates.io/crates/rayon), and
-[API documentation is available on docs.rs](https://docs.rs/rayon).
-
-[blog]: https://smallcultfollowing.com/babysteps/blog/2015/12/18/rayon-data-parallelism-in-rust/
-[video]: https://www.youtube.com/watch?v=gof_OEv71Aw
-
-## Parallel iterators and more
-
-Rayon makes it drop-dead simple to convert sequential iterators into
-parallel ones: usually, you just change your `foo.iter()` call into
-`foo.par_iter()`, and Rayon does the rest:
-
-```rust
-use rayon::prelude::*;
-fn sum_of_squares(input: &[i32]) -> i32 {
-    input.par_iter() // <-- just change that!
-         .map(|&i| i * i)
-         .sum()
-}
-```
-
-[Parallel iterators] take care of deciding how to divide your data
-into tasks; it will dynamically adapt for maximum performance. If you
-need more flexibility than that, Rayon also offers the [join] and
-[scope] functions, which let you create parallel tasks on your own.
-For even more control, you can create [custom threadpools] rather than
-using Rayon's default, global threadpool.
-
-[Parallel iterators]: https://docs.rs/rayon/*/rayon/iter/index.html
-[join]: https://docs.rs/rayon/*/rayon/fn.join.html
-[scope]: https://docs.rs/rayon/*/rayon/fn.scope.html
-[custom threadpools]: https://docs.rs/rayon/*/rayon/struct.ThreadPool.html
-
-## No data races
-
-You may have heard that parallel execution can produce all kinds of
-crazy bugs. Well, rest easy. Rayon's APIs all guarantee **data-race
-freedom**, which generally rules out most parallel bugs (though not
-all). In other words, **if your code compiles**, it typically does the
-same thing it did before.
-
-For the most, parallel iterators in particular are guaranteed to
-produce the same results as their sequential counterparts. One caveat:
-If your iterator has side effects (for example, sending methods to
-other threads through a [Rust channel] or writing to disk), those side
-effects may occur in a different order. Note also that, in some cases,
-parallel iterators offer alternative versions of the sequential
-iterator methods that can have higher performance.
-
-[Rust channel]: https://doc.rust-lang.org/std/sync/mpsc/fn.channel.html
-
-## Using Rayon
-
-[Rayon is available on crates.io](https://crates.io/crates/rayon). The
-recommended way to use it is to add a line into your Cargo.toml such
-as:
-
-```toml
-[dependencies]
-rayon = "1.8"
-```
-
-To use the parallel iterator APIs, a number of traits have to be in
-scope. The easiest way to bring those things into scope is to use the
-[Rayon prelude](https://docs.rs/rayon/*/rayon/prelude/index.html). In
-each module where you would like to use the parallel iterator APIs,
-just add:
-
-```rust
-use rayon::prelude::*;
-```
-
-Rayon currently requires `rustc 1.63.0` or greater.
-
-### Usage with WebAssembly
-
-By default, when building to WebAssembly, Rayon will treat it as any
-other platform without multithreading support and will fall back to
-sequential iteration. This allows existing code to compile and run
-successfully with no changes necessary, but it will run slower as it
-will only use a single CPU core.
-
-You can build Rayon-based projects with proper multithreading support
-for the Web, but you'll need an adapter and some project configuration
-to account for differences between WebAssembly threads and threads
-on the other platforms.
-
-Check out the
-[wasm-bindgen-rayon](https://github.com/RReverser/wasm-bindgen-rayon)
-docs for more details.
-
-## Contribution
-
-Rayon is an open source project! If you'd like to contribute to Rayon,
-check out
-[the list of "help wanted" issues](https://github.com/rayon-rs/rayon/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22).
-These are all (or should be) issues that are suitable for getting
-started, and they generally include a detailed set of instructions for
-what to do. Please ask questions if anything is unclear! Also, check
-out the
-[Guide to Development](https://github.com/rayon-rs/rayon/wiki/Guide-to-Development)
-page on the wiki. Note that all code submitted in PRs to Rayon is
-assumed to
-[be licensed under Rayon's dual MIT/Apache 2.0 licensing](https://github.com/rayon-rs/rayon/blob/main/README.md#license).
-
-## Quick demo
-
-To see Rayon in action, check out the `rayon-demo` directory, which
-includes a number of demos of code using Rayon. For example, run this
-command to get a visualization of an N-body simulation. To see the
-effect of using Rayon, press `s` to run sequentially and `p` to run in
-parallel.
-
-```text
-> cd rayon-demo
-> cargo run --release -- nbody visualize
-```
-
-For more information on demos, try:
-
-```text
-> cd rayon-demo
-> cargo run --release -- --help
-```
-
-## Other questions?
-
-See [the Rayon FAQ][faq].
-
-[faq]: https://github.com/rayon-rs/rayon/blob/main/FAQ.md
-
-## License
-
-Rayon is distributed under the terms of both the MIT license and the
-Apache License (Version 2.0). See [LICENSE-APACHE](LICENSE-APACHE) and
-[LICENSE-MIT](LICENSE-MIT) for details. Opening a pull request is
-assumed to signal agreement with these licensing terms.