std: directly use pthread in UNIX parker implementation #96393

joboet · 2022-04-25T13:31:00Z

Mutex and Condvar are being replaced by more efficient implementations, which need thread parking themselves (see #93740). Therefore we should use the pthread synchronization primitives directly. Also, we can avoid allocating the mutex and condition variable because the Parker struct is being placed in an Arc anyways.

This basically is just a copy of the current Mutex and Condvar code, which will however be removed (again, see #93740). An alternative implementation could be to use dedicated private OsMutex and OsCondvar types, but all the other platforms supported by std actually have their own thread parking primitives.

I used Pin to guarantee a stable address for the Parker struct, while the current implementation does not, rather using extra unsafe declaration. Since the thread struct is shared anyways, I assumed this would not add too much clutter while being clearer.

Mutex and Condvar are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore use the pthread synchronization primitives directly. Also, avoid allocating because the Parker struct is being placed in an Arc anyways.

rust-highfive · 2022-04-25T13:31:04Z

r? @thomcc

(rust-highfive has picked a reviewer for you, use r? to override)

thomcc · 2022-04-25T15:27:31Z

An alternative implementation could be to use a dedicated private OsMutex and OsCondvar type...

Hm, I think I'd prefer this, but I won't block it on it. I'll get to the review later today.

thomcc · 2022-04-25T16:26:17Z

Also CC @m-ou-se just to make sure she's aware of this change.

(Also if you'd rather review it, feel free to take. Although I do feel comfortable doing this review, I suspect you've been thinking much more about this code recently)

m-ou-se · 2022-04-25T21:14:37Z

Oh, thanks for working on this! I'll take a look tomorrow. :)

thomcc

This looks fine to me. I think it's a little unfortunate that the "generic" parker is now unix-specific, and wonder if it should be renamed to the pthreads parker or something. But I don't feel that strongly about it.

I also am surprised you don't need to do the condattr clock dance on all targets, I had thought that at least on Darwin that it was needed (but I'll trust if you've done investigation and it is not).

r=me unless @m-ou-se wants to review it too.

library/std/src/sys/unix/thread_parker.rs

m-ou-se · 2022-04-27T09:44:44Z

library/std/src/sys_common/thread_parker/generic.rs

-        Parker { state: AtomicUsize::new(EMPTY), lock: Mutex::new(()), cvar: Condvar::new() }
+    /// Construct the generic parker. The UNIX parker implementation
+    /// requires this to happen in-place.
+    pub unsafe fn new(parker: *mut Parker) {


If this took a &mut MaybeUninit<Parker> instead of a *mut Parker, then this function could be safe.

Without MaybeUninit 'projections' though, that makes using this function tricky when the parker is part of a bigger MaybeUninit. :(

That, and the lack of a dependency on pin_project in std, led me to use a pointer here, as we would require unsafe in Thread::new anyways. I could change this however.

library/std/src/sys/unix/thread_parker.rs

m-ou-se

Looks good. Thanks for working on this! :)

thomcc · 2022-04-28T03:14:18Z

Oh, this is waiting on me.

@bors r

bors · 2022-04-28T03:14:19Z

📌 Commit 2b71201 has been approved by thomcc

std: directly use pthread in UNIX parker implementation `Mutex` and `Condvar` are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore we should use the `pthread` synchronization primitives directly. Also, we can avoid allocating the mutex and condition variable because the `Parker` struct is being placed in an `Arc` anyways. This basically is just a copy of the current `Mutex` and `Condvar` code, which will however be removed (again, see rust-lang#93740). An alternative implementation could be to use dedicated private `OsMutex` and `OsCondvar` types, but all the other platforms supported by std actually have their own thread parking primitives. I used `Pin` to guarantee a stable address for the `Parker` struct, while the current implementation does not, rather using extra unsafe declaration. Since the thread struct is shared anyways, I assumed this would not add too much clutter while being clearer.

m-ou-se · 2022-04-28T10:48:35Z

@bors r=thomcc rollup=iffy

bors · 2022-04-28T10:48:36Z

📌 Commit 5502733 has been approved by thomcc

bors · 2022-04-28T12:45:10Z

⌛ Testing commit 5502733 with merge 7cd4e251f03bd860be1f0f5d81fe3a41e01559b9...

bors · 2022-04-28T13:18:16Z

💔 Test failed - checks-actions

joboet · 2022-04-28T13:38:57Z

Like so?

// cdb-check:    [...] inner            [...] [Type: core::pin::Pin<alloc::sync::Arc<std::thread::Inner> >]

m-ou-se · 2022-04-28T13:42:31Z

I suppose you can leave out the extra whitespace before [...] and just leave a single space. Then it still works if there's less whitespace in cdb's output.

m-ou-se · 2022-04-28T13:43:44Z

([...] just matches anything, see

rust/src/tools/compiletest/src/runtest/debugger.rs

Lines 82 to 84 in 3bfeffd

    
           fn check_single_line(line: &str, check_line: &str) -> bool { 
        
               // Allow check lines to leave parts unspecified (e.g., uninitialized 
        
               // bits in the  wrong case of an enum) with the notation "[...]".

)

m-ou-se · 2022-04-28T13:58:45Z

Let's try again :)

@bors r=thomcc

bors · 2022-04-28T13:58:46Z

📌 Commit 1285fb7 has been approved by thomcc

bors · 2022-04-28T21:58:12Z

⌛ Testing commit 1285fb7 with merge baaa3b6...

bors · 2022-04-29T00:38:42Z

☀️ Test successful - checks-actions
Approved by: thomcc
Pushing baaa3b6 to master...

rust-timer · 2022-04-29T02:55:35Z

Finished benchmarking commit (baaa3b6): comparison url.

Summary:

Primary benchmarks: 🎉 relevant improvement found
Secondary benchmarks: no relevant changes found

	Regressions 😿 (primary)	Regressions 😿 (secondary)	Improvements 🎉 (primary)	Improvements 🎉 (secondary)	All 😿 🎉 (primary)
count¹	0	0	1	0	1
mean²	N/A	N/A	-0.4%	N/A	-0.4%
max	N/A	N/A	-0.4%	N/A	-0.4%

If you disagree with this performance assessment, please file an issue in rust-lang/rustc-perf.

@rustbot label: -perf-regression

number of relevant changes ↩
the arithmetic mean of the percent change ↩

nbdd0121 · 2022-04-29T14:05:48Z

An alternative implementation could be to use dedicated private OsMutex and OsCondvar types, but all the other platforms supported by std actually have their own thread parking primitives.

We still have hermit, solid and sgx which doesn't have their own thread parking primitives.

joboet · 2022-04-29T14:36:36Z

Well, they are not currently implemented:

Hermit has block_current_task and wakeup_task (used in the current mutex):

rust/library/std/src/sys/hermit/mutex.rs

Lines 182 to 208 in 87937d3

    
           #[inline] 
        
           pub unsafe fn lock(&self) { 
        
               loop { 
        
                   let mut guard = self.inner.lock(); 
        
                   if guard.locked == false { 
        
                       guard.locked = true; 
        
                       return; 
        
                   } else { 
        
                       let prio = abi::get_priority(); 
        
                       let id = abi::getpid(); 
        
                       guard.blocked_task.push(prio, id); 
        
                       abi::block_current_task(); 
        
                       drop(guard); 
        
                       abi::yield_now(); 
        
                   } 
        
               } 
        
           } 
        
           #[inline] 
        
           pub unsafe fn unlock(&self) { 
        
               let mut guard = self.inner.lock(); 
        
               guard.locked = false; 
        
               if let Some(tid) = guard.blocked_task.pop() { 
        
                   abi::wakeup_task(tid); 
        
               } 
        
           }

Solid has event flags via µITRON (see http://www.ertl.jp/ITRON/SPEC/FILE/mitron-400e.pdf)
SGX has EV_UNPARK (used in the current mutex)

rust/library/std/src/sys/sgx/waitqueue/mod.rs

Lines 147 to 216 in 87937d3

    
           /// Adds the calling thread to the `WaitVariable`'s wait queue, then wait 
        
           /// until a wakeup event. 
        
           /// 
        
           /// This function does not return until this thread has been awoken. 
        
           pub fn wait<T, F: FnOnce()>(mut guard: SpinMutexGuard<'_, WaitVariable<T>>, before_wait: F) { 
        
               // very unsafe: check requirements of UnsafeList::push 
        
               unsafe { 
        
                   let mut entry = UnsafeListEntry::new(SpinMutex::new(WaitEntry { 
        
                       tcs: thread::current(), 
        
                       wake: false, 
        
                   })); 
        
                   let entry = guard.queue.inner.push(&mut entry); 
        
                   drop(guard); 
        
                   before_wait(); 
        
                   while !entry.lock().wake { 
        
                       // don't panic, this would invalidate `entry` during unwinding 
        
                       let eventset = rtunwrap!(Ok, usercalls::wait(EV_UNPARK, WAIT_INDEFINITE)); 
        
                       rtassert!(eventset & EV_UNPARK == EV_UNPARK); 
        
                   } 
        
               } 
        
           } 
        
           /// Adds the calling thread to the `WaitVariable`'s wait queue, then wait 
        
           /// until a wakeup event or timeout. If event was observed, returns true. 
        
           /// If not, it will remove the calling thread from the wait queue. 
        
           pub fn wait_timeout<T, F: FnOnce()>( 
        
               lock: &SpinMutex<WaitVariable<T>>, 
        
               timeout: Duration, 
        
               before_wait: F, 
        
           ) -> bool { 
        
               // very unsafe: check requirements of UnsafeList::push 
        
               unsafe { 
        
                   let mut entry = UnsafeListEntry::new(SpinMutex::new(WaitEntry { 
        
                       tcs: thread::current(), 
        
                       wake: false, 
        
                   })); 
        
                   let entry_lock = lock.lock().queue.inner.push(&mut entry); 
        
                   before_wait(); 
        
                   usercalls::wait_timeout(EV_UNPARK, timeout, || entry_lock.lock().wake); 
        
                   // acquire the wait queue's lock first to avoid deadlock. 
        
                   let mut guard = lock.lock(); 
        
                   let success = entry_lock.lock().wake; 
        
                   if !success { 
        
                       // nobody is waking us up, so remove our entry from the wait queue. 
        
                       guard.queue.inner.remove(&mut entry); 
        
                   } 
        
                   success 
        
               } 
        
           } 
        
           /// Either find the next waiter on the wait queue, or return the mutex 
        
           /// guard unchanged. 
        
           /// 
        
           /// If a waiter is found, a `WaitGuard` is returned which will notify the 
        
           /// waiter when it is dropped. 
        
           pub fn notify_one<T>( 
        
               mut guard: SpinMutexGuard<'_, WaitVariable<T>>, 
        
           ) -> Result<WaitGuard<'_, T>, SpinMutexGuard<'_, WaitVariable<T>>> { 
        
               unsafe { 
        
                   if let Some(entry) = guard.queue.inner.pop() { 
        
                       let mut entry_guard = entry.lock(); 
        
                       let tcs = entry_guard.tcs; 
        
                       entry_guard.wake = true; 
        
                       drop(entry); 
        
                       Ok(WaitGuard { mutex_guard: Some(guard), notified_tcs: NotifiedTcs::Single(tcs) }) 
        
                   } else { 
        
                       Err(guard) 
        
                   } 
        
               } 
        
           }

std: use an event-flag-based thread parker on SOLID `Mutex` and `Condvar` are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore, the generic `Parker` needs to be replaced on all platforms where the new lock implementation will be used, which, after rust-lang#96393, are SOLID, SGX and Hermit (more PRs coming soon). SOLID, conforming to the [μITRON specification](http://www.ertl.jp/ITRON/SPEC/FILE/mitron-400e.pdf), has event flags, which are a thread parking primitive very similar to `Parker`. However, they do not make any atomic ordering guarantees (even though those can probably be assumed) and necessitate a system call even when the thread token is already available. Hence, this `Parker`, like the Windows parker, uses an extra atomic state variable. I future-proofed the code by wrapping the event flag in a `WaitFlag` structure, as both SGX and Hermit can share the Parker implementation, they just have slightly different primitives (SGX uses signals and Hermit has a thread blocking API (which is unfortunately [broken](hermit-os/kernel#442), I think). ``@kawadakk`` I assume you are the target maintainer? Could you test this for me?

std: use an event-flag-based thread parker on SOLID `Mutex` and `Condvar` are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore, the generic `Parker` needs to be replaced on all platforms where the new lock implementation will be used, which, after rust-lang#96393, are SOLID, SGX and Hermit (more PRs coming soon). SOLID, conforming to the [μITRON specification](http://www.ertl.jp/ITRON/SPEC/FILE/mitron-400e.pdf), has event flags, which are a thread parking primitive very similar to `Parker`. However, they do not make any atomic ordering guarantees (even though those can probably be assumed) and necessitate a system call even when the thread token is already available. Hence, this `Parker`, like the Windows parker, uses an extra atomic state variable. I future-proofed the code by wrapping the event flag in a `WaitFlag` structure, as both SGX and Hermit can share the Parker implementation, they just have slightly different primitives (SGX uses signals and Hermit has a thread blocking API (which is unfortunately [broken](hermit-os/kernel#442), I think). ```@kawadakk``` I assume you are the target maintainer? Could you test this for me?

std: use an event-flag-based thread parker on SOLID `Mutex` and `Condvar` are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore, the generic `Parker` needs to be replaced on all platforms where the new lock implementation will be used, which, after rust-lang#96393, are SOLID, SGX and Hermit (more PRs coming soon). SOLID, conforming to the [μITRON specification](http://www.ertl.jp/ITRON/SPEC/FILE/mitron-400e.pdf), has event flags, which are a thread parking primitive very similar to `Parker`. However, they do not make any atomic ordering guarantees (even though those can probably be assumed) and necessitate a system call even when the thread token is already available. Hence, this `Parker`, like the Windows parker, uses an extra atomic state variable. I future-proofed the code by wrapping the event flag in a `WaitFlag` structure, as both SGX and Hermit can share the Parker implementation, they just have slightly different primitives (SGX uses signals and Hermit has a thread blocking API (which is unfortunately [broken](hermit-os/kernel#442), I think). ````@kawadakk```` I assume you are the target maintainer? Could you test this for me?

std: use an event-flag-based thread parker on SOLID `Mutex` and `Condvar` are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore, the generic `Parker` needs to be replaced on all platforms where the new lock implementation will be used, which, after rust-lang#96393, are SOLID, SGX and Hermit (more PRs coming soon). SOLID, conforming to the [μITRON specification](http://www.ertl.jp/ITRON/SPEC/FILE/mitron-400e.pdf), has event flags, which are a thread parking primitive very similar to `Parker`. However, they do not make any atomic ordering guarantees (even though those can probably be assumed) and necessitate a system call even when the thread token is already available. Hence, this `Parker`, like the Windows parker, uses an extra atomic state variable. I future-proofed the code by wrapping the event flag in a `WaitFlag` structure, as both SGX and Hermit can share the Parker implementation, they just have slightly different primitives (SGX uses signals and Hermit has a thread blocking API). `@kawadakk` I assume you are the target maintainer? Could you test this for me?

std: use an event-flag-based thread parker on SOLID `Mutex` and `Condvar` are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore, the generic `Parker` needs to be replaced on all platforms where the new lock implementation will be used, which, after rust-lang#96393, are SOLID, SGX and Hermit (more PRs coming soon). SOLID, conforming to the [μITRON specification](http://www.ertl.jp/ITRON/SPEC/FILE/mitron-400e.pdf), has event flags, which are a thread parking primitive very similar to `Parker`. However, they do not make any atomic ordering guarantees (even though those can probably be assumed) and necessitate a system call even when the thread token is already available. Hence, this `Parker`, like the Windows parker, uses an extra atomic state variable. I future-proofed the code by wrapping the event flag in a `WaitFlag` structure, as both SGX and Hermit can share the Parker implementation, they just have slightly different primitives (SGX uses signals and Hermit has a thread blocking API). ``@kawadakk`` I assume you are the target maintainer? Could you test this for me?

std: use an event-flag-based thread parker on SOLID `Mutex` and `Condvar` are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore, the generic `Parker` needs to be replaced on all platforms where the new lock implementation will be used, which, after rust-lang#96393, are SOLID, SGX and Hermit (more PRs coming soon). SOLID, conforming to the [μITRON specification](http://www.ertl.jp/ITRON/SPEC/FILE/mitron-400e.pdf), has event flags, which are a thread parking primitive very similar to `Parker`. However, they do not make any atomic ordering guarantees (even though those can probably be assumed) and necessitate a system call even when the thread token is already available. Hence, this `Parker`, like the Windows parker, uses an extra atomic state variable. I future-proofed the code by wrapping the event flag in a `WaitFlag` structure, as both SGX and Hermit can share the Parker implementation, they just have slightly different primitives (SGX uses signals and Hermit has a thread blocking API). ```@kawadakk``` I assume you are the target maintainer? Could you test this for me?

std: use an event-flag-based thread parker on SOLID `Mutex` and `Condvar` are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore, the generic `Parker` needs to be replaced on all platforms where the new lock implementation will be used, which, after rust-lang#96393, are SOLID, SGX and Hermit (more PRs coming soon). SOLID, conforming to the [μITRON specification](http://www.ertl.jp/ITRON/SPEC/FILE/mitron-400e.pdf), has event flags, which are a thread parking primitive very similar to `Parker`. However, they do not make any atomic ordering guarantees (even though those can probably be assumed) and necessitate a system call even when the thread token is already available. Hence, this `Parker`, like the Windows parker, uses an extra atomic state variable. I future-proofed the code by wrapping the event flag in a `WaitFlag` structure, as both SGX and Hermit can share the Parker implementation, they just have slightly different primitives (SGX uses signals and Hermit has a thread blocking API). ````@kawadakk```` I assume you are the target maintainer? Could you test this for me?

std: use an event-flag-based thread parker on SOLID `Mutex` and `Condvar` are being replaced by more efficient implementations, which need thread parking themselves (see rust-lang#93740). Therefore, the generic `Parker` needs to be replaced on all platforms where the new lock implementation will be used, which, after rust-lang#96393, are SOLID, SGX and Hermit (more PRs coming soon). SOLID, conforming to the [μITRON specification](http://www.ertl.jp/ITRON/SPEC/FILE/mitron-400e.pdf), has event flags, which are a thread parking primitive very similar to `Parker`. However, they do not make any atomic ordering guarantees (even though those can probably be assumed) and necessitate a system call even when the thread token is already available. Hence, this `Parker`, like the Windows parker, uses an extra atomic state variable. I future-proofed the code by wrapping the event flag in a `WaitFlag` structure, as both SGX and Hermit can share the Parker implementation, they just have slightly different primitives (SGX uses signals and Hermit has a thread blocking API). `````@kawadakk````` I assume you are the target maintainer? Could you test this for me?

library/std/src/sys/unix/thread_parker.rs

Pkgsrc changes: * adapt patches (libc crate version bump) * no longer pass -I/usr/pkg/include through via gcc-wrap script. Attempt at fixing version skew with curl package vs. internal version of curl. * new checksums Upstream changes: Version 1.62.0 (2022-06-30) ========================== Language -------- - [Stabilize `#[derive(Default)]` on enums with a `#[default]` variant][94457] - [Stop validating some checks in dead code after functions with uninhabited return types][93313] - [Fix constants not getting dropped if part of a diverging expression][94775] - [Support unit struct/enum variant in destructuring assignment][95380] - [Remove mutable_borrow_reservation_conflict lint and allow the code pattern][96268] Compiler -------- - [linker: Stop using whole-archive on dependencies of dylibs][96436] - [Make `unaligned_references` lint deny-by-default][95372] This lint is also a future compatibility lint, and is expected to eventually become a hard error. - [Only add codegen backend to dep info if -Zbinary-dep-depinfo is used][93969] - [Reject `#[thread_local]` attribute on non-static items][95006] - [Add tier 3 `aarch64-pc-windows-gnullvm` and `x86_64-pc-windows-gnullvm` targets\*][94872] - [Implement a lint to warn about unused macro rules][96150] - [Promote `x86_64-unknown-none` target to Tier 2\*][95705] \* Refer to Rust's [platform support page][platform-support-doc] for more information on Rust's tiered platform support. Libraries --------- - [Move `CStr` to libcore, and `CString` to liballoc][94079] - [Windows: Use a pipe relay for chaining pipes][95841] - [Replace Linux Mutex and Condvar with futex based ones.][95035] - [Replace RwLock by a futex based one on Linux][95801] - [std: directly use pthread in UNIX parker implementation][96393] Stabilized APIs --------------- - [`bool::then_some`] - [`f32::total_cmp`] - [`f64::total_cmp`] - [`Stdin::lines`] - [`windows::CommandExt::raw_arg`] - [`impl<T: Default> Default for AssertUnwindSafe<T>`] - [`From<Rc<str>> for Rc<[u8]>`][rc-u8-from-str] - [`From<Arc<str>> for Arc<[u8]>`][arc-u8-from-str] - [`FusedIterator for EncodeWide`] - [RDM intrinsics on aarch64][stdarch/1285] Clippy ------ - [Create clippy lint against unexpectedly late drop for temporaries in match scrutinee expressions][94206] Cargo ----- - Added the `cargo add` command for adding dependencies to `Cargo.toml` from the command-line. [docs](https://doc.rust-lang.org/nightly/cargo/commands/cargo-add.html) - Package ID specs now support `name@version` syntax in addition to the previous `name:version` to align with the behavior in `cargo add` and other tools. `cargo install` and `cargo yank` also now support this syntax so the version does not need to passed as a separate flag. - The `git` and `registry` directories in Cargo's home directory (usually `~/.cargo`) are now marked as cache directories so that they are not included in backups or content indexing (on Windows). - Added automatic `@` argfile support, which will use "response files" if the command-line to `rustc` exceeds the operating system's limit. Compatibility Notes ------------------- - `cargo test` now passes `--target` to `rustdoc` if the specified target is the same as the host target. [#10863](rust-lang/cargo#10863) - [rustdoc: Remove .woff font files][96279] - [Enforce Copy bounds for repeat elements while considering lifetimes][95819] Internal Changes ---------------- - [Unify ReentrantMutex implementations across all platforms][96042] These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools. [93313]: rust-lang/rust#93313 [93969]: rust-lang/rust#93969 [94079]: rust-lang/rust#94079 [94206]: rust-lang/rust#94206 [94457]: rust-lang/rust#94457 [94775]: rust-lang/rust#94775 [94872]: rust-lang/rust#94872 [95006]: rust-lang/rust#95006 [95035]: rust-lang/rust#95035 [95372]: rust-lang/rust#95372 [95380]: rust-lang/rust#95380 [95431]: rust-lang/rust#95431 [95705]: rust-lang/rust#95705 [95801]: rust-lang/rust#95801 [95819]: rust-lang/rust#95819 [95841]: rust-lang/rust#95841 [96042]: rust-lang/rust#96042 [96150]: rust-lang/rust#96150 [96268]: rust-lang/rust#96268 [96279]: rust-lang/rust#96279 [96393]: rust-lang/rust#96393 [96436]: rust-lang/rust#96436 [96557]: rust-lang/rust#96557 [`bool::then_some`]: https://doc.rust-lang.org/stable/std/primitive.bool.html#method.then_some [`f32::total_cmp`]: https://doc.rust-lang.org/stable/std/primitive.f32.html#method.total_cmp [`f64::total_cmp`]: https://doc.rust-lang.org/stable/std/primitive.f64.html#method.total_cmp [`Stdin::lines`]: https://doc.rust-lang.org/stable/std/io/struct.Stdin.html#method.lines [`impl<T: Default> Default for AssertUnwindSafe<T>`]: https://doc.rust-lang.org/stable/std/panic/struct.AssertUnwindSafe.html#impl-Default [rc-u8-from-str]: https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#impl-From> [arc-u8-from-str]: https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#impl-From> [stdarch/1285]: rust-lang/stdarch#1285 [`windows::CommandExt::raw_arg`]: https://doc.rust-lang.org/stable/std/os/windows/process/trait.CommandExt.html#tymethod.raw_arg [`FusedIterator for EncodeWide`]: https://doc.rust-lang.org/stable/std/os/windows/ffi/struct.EncodeWide.html#impl-FusedIterator

Pkgsrc changes: * Bump required GCC to 7 (same as LLVM) to avoid ABI issues Fixes native i386 and powerpc 8.x build w/pkgsrc LLVM 14 * Bump available bootstraps to 1.61.0. * Also unlimit stacksize * Sync patches over from wip/rust * Adjust line number in patches which had non-zero offsets. * no longer pass -I/usr/pkg/include through via gcc-wrap script when building natively. Attempt at fixing version skew with curl package vs. internal version of curl (may not work...) * The NetBSD bootstraps now use .xz compression. * Use mk/atomic64.mk. Still have conditional for libatomic-links. * Default to using the internal LLVM when cross-building. Upstream changes: Version 1.62.1 (2022-07-19) ========================== Rust 1.62.1 addresses a few recent regressions in the compiler and standard library, and also mitigates a CPU vulnerability on Intel SGX. * [The compiler fixed unsound function coercions involving `impl Trait` return types.][98608] * [The compiler fixed an incremental compilation bug with `async fn` lifetimes.][98890] * [Windows added a fallback for overlapped I/O in synchronous reads and writes.][98950] * [The `x86_64-fortanix-unknown-sgx` target added a mitigation for the MMIO stale data vulnerability][98126], advisory [INTEL-SA-00615]. [98608]: rust-lang/rust#98608 [98890]: rust-lang/rust#98890 [98950]: rust-lang/rust#98950 [98126]: rust-lang/rust#98126 [INTEL-SA-00615]: https://www.intel.com/content/www/us/en/security-center/advisory/intel-sa-00615.html Version 1.62.0 (2022-06-30) ========================== Language -------- - [Stabilize `#[derive(Default)]` on enums with a `#[default]` variant][94457] - [Stop validating some checks in dead code after functions with uninhabited return types][93313] - [Fix constants not getting dropped if part of a diverging expression][94775] - [Support unit struct/enum variant in destructuring assignment][95380] - [Remove mutable_borrow_reservation_conflict lint and allow the code pattern][96268] Compiler -------- - [linker: Stop using whole-archive on dependencies of dylibs][96436] - [Make `unaligned_references` lint deny-by-default][95372] This lint is also a future compatibility lint, and is expected to eventually become a hard error. - [Only add codegen backend to dep info if -Zbinary-dep-depinfo is used][93969] - [Reject `#[thread_local]` attribute on non-static items][95006] - [Add tier 3 `aarch64-pc-windows-gnullvm` and `x86_64-pc-windows-gnullvm` targets\*][94872] - [Implement a lint to warn about unused macro rules][96150] - [Promote `x86_64-unknown-none` target to Tier 2\*][95705] \* Refer to Rust's [platform support page][platform-support-doc] for more information on Rust's tiered platform support. Libraries --------- - [Move `CStr` to libcore, and `CString` to liballoc][94079] - [Windows: Use a pipe relay for chaining pipes][95841] - [Replace Linux Mutex and Condvar with futex based ones.][95035] - [Replace RwLock by a futex based one on Linux][95801] - [std: directly use pthread in UNIX parker implementation][96393] Stabilized APIs --------------- - [`bool::then_some`] - [`f32::total_cmp`] - [`f64::total_cmp`] - [`Stdin::lines`] - [`windows::CommandExt::raw_arg`] - [`impl<T: Default> Default for AssertUnwindSafe<T>`] - [`From<Rc<str>> for Rc<[u8]>`][rc-u8-from-str] - [`From<Arc<str>> for Arc<[u8]>`][arc-u8-from-str] - [`FusedIterator for EncodeWide`] - [RDM intrinsics on aarch64][stdarch/1285] Clippy ------ - [Create clippy lint against unexpectedly late drop for temporaries in match scrutinee expressions][94206] Cargo ----- - Added the `cargo add` command for adding dependencies to `Cargo.toml` from the command-line. [docs](https://doc.rust-lang.org/nightly/cargo/commands/cargo-add.html) - Package ID specs now support `name@version` syntax in addition to the previous `name:version` to align with the behavior in `cargo add` and other tools. `cargo install` and `cargo yank` also now support this syntax so the version does not need to passed as a separate flag. - The `git` and `registry` directories in Cargo's home directory (usually `~/.cargo`) are now marked as cache directories so that they are not included in backups or content indexing (on Windows). - Added automatic `@` argfile support, which will use "response files" if the command-line to `rustc` exceeds the operating system's limit. Compatibility Notes ------------------- - `cargo test` now passes `--target` to `rustdoc` if the specified target is the same as the host target. [#10863](rust-lang/cargo#10863) - [rustdoc: Remove .woff font files][96279] - [Enforce Copy bounds for repeat elements while considering lifetimes][95819] Internal Changes ---------------- - [Unify ReentrantMutex implementations across all platforms][96042] These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools. [93313]: rust-lang/rust#93313 [93969]: rust-lang/rust#93969 [94079]: rust-lang/rust#94079 [94206]: rust-lang/rust#94206 [94457]: rust-lang/rust#94457 [94775]: rust-lang/rust#94775 [94872]: rust-lang/rust#94872 [95006]: rust-lang/rust#95006 [95035]: rust-lang/rust#95035 [95372]: rust-lang/rust#95372 [95380]: rust-lang/rust#95380 [95431]: rust-lang/rust#95431 [95705]: rust-lang/rust#95705 [95801]: rust-lang/rust#95801 [95819]: rust-lang/rust#95819 [95841]: rust-lang/rust#95841 [96042]: rust-lang/rust#96042 [96150]: rust-lang/rust#96150 [96268]: rust-lang/rust#96268 [96279]: rust-lang/rust#96279 [96393]: rust-lang/rust#96393 [96436]: rust-lang/rust#96436 [96557]: rust-lang/rust#96557 [`bool::then_some`]: https://doc.rust-lang.org/stable/std/primitive.bool.html#method.then_some [`f32::total_cmp`]: https://doc.rust-lang.org/stable/std/primitive.f32.html#method.total_cmp [`f64::total_cmp`]: https://doc.rust-lang.org/stable/std/primitive.f64.html#method.total_cmp [`Stdin::lines`]: https://doc.rust-lang.org/stable/std/io/struct.Stdin.html#method.lines [`impl<T: Default> Default for AssertUnwindSafe<T>`]: https://doc.rust-lang.org/stable/std/panic/struct.AssertUnwindSafe.html#impl-Default [rc-u8-from-str]: https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#impl-From> [arc-u8-from-str]: https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#impl-From> [stdarch/1285]: rust-lang/stdarch#1285 [`windows::CommandExt::raw_arg`]: https://doc.rust-lang.org/stable/std/os/windows/process/trait.CommandExt.html#tymethod.raw_arg [`FusedIterator for EncodeWide`]: https://doc.rust-lang.org/stable/std/os/windows/ffi/struct.EncodeWide.html#impl-FusedIterator Version 1.61.0 (2022-05-19) ========================== Language -------- - [`const fn` signatures can now include generic trait bounds][93827] - [`const fn` signatures can now use `impl Trait` in argument and return position][93827] - [Function pointers can now be created, cast, and passed around in a `const fn`][93827] - [Recursive calls can now set the value of a function's opaque `impl Trait` return type][94081] Compiler -------- - [Linking modifier syntax in `#[link]` attributes and on the command line, as well as the `whole-archive` modifier specifically, are now supported][93901] - [The `char` type is now described as UTF-32 in debuginfo][89887] - The [`#[target_feature]`][target_feature] attribute [can now be used with aarch64 features][90621] - X86 [`#[target_feature = "adx"]` is now stable][93745] Libraries --------- - [`ManuallyDrop<T>` is now documented to have the same layout as `T`][88375] - [`#[ignore = "#"]` messages are printed when running tests][92714] - [Consistently show absent stdio handles on Windows as NULL handles][93263] - [Make `std::io::stdio::lock()` return `'static` handles.][93965] Previously, the creation of locked handles to stdin/stdout/stderr would borrow the handles being locked, which prevented writing `let out = std::io::stdout().lock();` because `out` would outlive the return value of `stdout()`. Such code now works, eliminating a common pitfall that affected many Rust users. - [`Vec::from_raw_parts` is now less restrictive about its inputs][95016] - [`std::thread::available_parallelism` now takes cgroup quotas into account.][92697] Since `available_parallelism` is often used to create a thread pool for parallel computation, which may be CPU-bound for performance, `available_parallelism` will return a value consistent with the ability to use that many threads continuously, if possible. For instance, in a container with 8 virtual CPUs but quotas only allowing for 50% usage, `available_parallelism` will return 4. Stabilized APIs --------------- - [`Pin::static_mut`] - [`Pin::static_ref`] - [`Vec::retain_mut`] - [`VecDeque::retain_mut`] - [`Write` for `Cursor<[u8; N]>`][cursor-write-array] - [`std::os::unix::net::SocketAddr::from_pathname`] - [`std::process::ExitCode`] and [`std::process::Termination`]. The stabilization of these two API s now makes it possible for programs to return errors from `main` with custom exit codes. - [`std::thread::JoinHandle::is_finished`] These APIs are now usable in const contexts: - [`<*const T>::offset` and `<*mut T>::offset`][ptr-offset] - [`<*const T>::wrapping_offset` and `<*mut T>::wrapping_offset`] [ptr-wrapping_offset] - [`<*const T>::add` and `<*mut T>::add`][ptr-add] - [`<*const T>::sub` and `<*mut T>::sub`][ptr-sub] - [`<*const T>::wrapping_add` and `<*mut T>::wrapping_add`][ptr-wrapping_add] - [`<*const T>::wrapping_sub` and `<*mut T>::wrapping_sub`][ptr-wrapping_sub] - [`<[T]>::as_mut_ptr`][slice-as_mut_ptr] - [`<[T]>::as_ptr_range`][slice-as_ptr_range] - [`<[T]>::as_mut_ptr_range`][slice-as_mut_ptr_range] Cargo ----- No feature changes, but see compatibility notes. Compatibility Notes ------------------- - Previously native static libraries were linked as `whole-archive` in some cases, but now rustc tries not to use `whole-archive` unless explicitly requested. This [change][93901] may result in linking errors in some cases. To fix such errors, native libraries linked from the command line, build scripts, or [`#[link]` attributes][link-attr] need to - (more common) either be reordered to respect dependencies between them (if `a` depends on `b` then `a` should go first and `b` second) - (less common) or be updated to use the [` whole-archive`] modifier. - [Catching a second unwind from FFI code while cleaning up from a Rust panic now causes the process to abort][92911] - [Proc macros no longer see `ident` matchers wrapped in groups][92472] - [The number of `#` in `r#` raw string literals is now required to be less than 256][95251] - [When checking that a dyn type satisfies a trait bound, supertrait bounds are now enforced][92285] - [`cargo vendor` now only accepts one value for each `--sync` flag] [cargo/10448] - [`cfg` predicates in `all()` and `any()` are always evaluated to detect errors, instead of short-circuiting.][94295] The compatibility considerations here arise in nightly-only code that used the short-circuiting behavior of `all` to write something like `cfg(all(feature = "nightly", syntax-requiring-nightly))`, which will now fail to compile. Instead, use either `cfg_attr(feature = "nightly", ...)` or nested uses of `cfg`. - [bootstrap: static-libstdcpp is now enabled by default, and can now be disabled when llvm-tools is enabled][94832] Internal Changes ---------------- These changes provide no direct user facing benefits, but represent significant improvements to the internals and overall performance of rustc and related tools. - [debuginfo: Refactor debuginfo generation for types][94261] - [Remove the everybody loops pass][93913] [88375]: rust-lang/rust#88375 [89887]: rust-lang/rust#89887 [90621]: rust-lang/rust#90621 [92285]: rust-lang/rust#92285 [92472]: rust-lang/rust#92472 [92697]: rust-lang/rust#92697 [92714]: rust-lang/rust#92714 [92911]: rust-lang/rust#92911 [93263]: rust-lang/rust#93263 [93745]: rust-lang/rust#93745 [93827]: rust-lang/rust#93827 [93901]: rust-lang/rust#93901 [93913]: rust-lang/rust#93913 [93965]: rust-lang/rust#93965 [94081]: rust-lang/rust#94081 [94261]: rust-lang/rust#94261 [94295]: rust-lang/rust#94295 [94832]: rust-lang/rust#94832 [95016]: rust-lang/rust#95016 [95251]: rust-lang/rust#95251 [` whole-archive`]: https://doc.rust-lang.org/stable/rustc/command-line-arguments.html#linking-modifiers-whole-archive [`Pin::static_mut`]: https://doc.rust-lang.org/stable/std/pin/struct.Pin.html#method.static_mut [`Pin::static_ref`]: https://doc.rust-lang.org/stable/std/pin/struct.Pin.html#method.static_ref [`Vec::retain_mut`]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.retain_mut [`VecDeque::retain_mut`]: https://doc.rust-lang.org/stable/std/collections/struct.VecDeque.html#method.retain_mut [`std::os::unix::net::SocketAddr::from_pathname`]: https://doc.rust-lang.org/stable/std/os/unix/net/struct.SocketAddr.html#method.from_pathname [`std::process::ExitCode`]: https://doc.rust-lang.org/stable/std/process/struct.ExitCode.html [`std::process::Termination`]: https://doc.rust-lang.org/stable/std/process/trait.Termination.html [`std::thread::JoinHandle::is_finished`]: https://doc.rust-lang.org/stable/std/thread/struct.JoinHandle.html#method.is_finished [cargo/10448]: rust-lang/cargo#10448 [cursor-write-array]: https://doc.rust-lang.org/stable/std/io/struct.Cursor.html#impl-Write-4 [link-attr]: https://doc.rust-lang.org/stable/reference/items/external-blocks.html#the-link-attribute [ptr-add]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.add [ptr-offset]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.offset [ptr-sub]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.sub [ptr-wrapping_add]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.wrapping_add [ptr-wrapping_offset]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.wrapping_offset [ptr-wrapping_sub]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.wrapping_sub [slice-as_mut_ptr]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.as_mut_ptr [slice-as_mut_ptr_range]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.as_mut_ptr_range [slice-as_ptr_range]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.as_ptr_range [target_feature]: https://doc.rust-lang.org/reference/attributes/codegen.html#the-target_feature-attribute

rust-highfive assigned thomcc Apr 25, 2022

rustbot added the T-libs Relevant to the library team, which will review and decide on the PR/issue. label Apr 25, 2022

This comment was marked as off-topic.

Sign in to view

rust-highfive added the S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. label Apr 25, 2022

thomcc approved these changes Apr 25, 2022

View reviewed changes

library/std/src/sys/unix/thread_parker.rs Show resolved Hide resolved

m-ou-se reviewed Apr 27, 2022

View reviewed changes

library/std/src/sys/unix/thread_parker.rs Outdated Show resolved Hide resolved

m-ou-se approved these changes Apr 27, 2022

View reviewed changes

bors added S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Apr 28, 2022

Dylan-DPC mentioned this pull request Apr 28, 2022

Rollup of 6 pull requests #96502

Closed

std: simplify UNIX parker timeouts

5502733

joboet force-pushed the pthread_parker branch from 2b71201 to 5502733 Compare April 28, 2022 10:33

m-ou-se mentioned this pull request Apr 28, 2022

Tracking issue for improving std::sync::{Mutex, RwLock, Condvar} #93740

Closed

63 tasks

bors added S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. and removed S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. labels Apr 28, 2022

std: update debuginfo check to match type definition

1285fb7

joboet force-pushed the pthread_parker branch from 6fc1321 to 1285fb7 Compare April 28, 2022 13:49

bors added S-waiting-on-bors Status: Waiting on bors to run and complete tests. Bors will change the label on completion. and removed S-waiting-on-review Status: Awaiting review from the assignee but also interested parties. labels Apr 28, 2022

bors added the merged-by-bors This PR was explicitly merged by bors. label Apr 29, 2022

bors merged commit baaa3b6 into rust-lang:master Apr 29, 2022

rustbot added this to the 1.62.0 milestone Apr 29, 2022

joboet deleted the pthread_parker branch April 29, 2022 11:40

joboet mentioned this pull request May 18, 2022

std: use an event-flag-based thread parker on SOLID #97140

Merged

BGR360 reviewed Jul 1, 2022

View reviewed changes

library/std/src/sys/unix/thread_parker.rs Show resolved Hide resolved

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

std: directly use pthread in UNIX parker implementation #96393

std: directly use pthread in UNIX parker implementation #96393

joboet commented Apr 25, 2022 •

edited

Loading

This comment was marked as off-topic.

rust-highfive commented Apr 25, 2022

thomcc commented Apr 25, 2022 •

edited

Loading

thomcc commented Apr 25, 2022

m-ou-se commented Apr 25, 2022

thomcc left a comment •

edited

Loading

m-ou-se Apr 27, 2022

joboet Apr 27, 2022

m-ou-se left a comment

thomcc commented Apr 28, 2022

bors commented Apr 28, 2022

m-ou-se commented Apr 28, 2022

bors commented Apr 28, 2022

bors commented Apr 28, 2022

bors commented Apr 28, 2022

joboet commented Apr 28, 2022

m-ou-se commented Apr 28, 2022

m-ou-se commented Apr 28, 2022

m-ou-se commented Apr 28, 2022

bors commented Apr 28, 2022

bors commented Apr 28, 2022

bors commented Apr 29, 2022

rust-timer commented Apr 29, 2022

nbdd0121 commented Apr 29, 2022 •

edited

Loading

joboet commented Apr 29, 2022

std: directly use pthread in UNIX parker implementation #96393

std: directly use pthread in UNIX parker implementation #96393

Conversation

joboet commented Apr 25, 2022 • edited Loading

This comment was marked as off-topic.

rust-highfive commented Apr 25, 2022

thomcc commented Apr 25, 2022 • edited Loading

thomcc commented Apr 25, 2022

m-ou-se commented Apr 25, 2022

thomcc left a comment • edited Loading

Choose a reason for hiding this comment

m-ou-se Apr 27, 2022

Choose a reason for hiding this comment

joboet Apr 27, 2022

Choose a reason for hiding this comment

m-ou-se left a comment

Choose a reason for hiding this comment

thomcc commented Apr 28, 2022

bors commented Apr 28, 2022

m-ou-se commented Apr 28, 2022

bors commented Apr 28, 2022

bors commented Apr 28, 2022

bors commented Apr 28, 2022

joboet commented Apr 28, 2022

m-ou-se commented Apr 28, 2022

m-ou-se commented Apr 28, 2022

m-ou-se commented Apr 28, 2022

bors commented Apr 28, 2022

bors commented Apr 28, 2022

bors commented Apr 29, 2022

rust-timer commented Apr 29, 2022

Footnotes

nbdd0121 commented Apr 29, 2022 • edited Loading

joboet commented Apr 29, 2022

joboet commented Apr 25, 2022 •

edited

Loading

thomcc commented Apr 25, 2022 •

edited

Loading

thomcc left a comment •

edited

Loading

nbdd0121 commented Apr 29, 2022 •

edited

Loading