Add parking_lot_core module

Author: faern

src/libstd/sys/cloudabi/mod.rs

@@ -32,6 +32,8 @@ pub mod stdio;
 pub mod thread;
 #[path = "../unix/thread_local.rs"]
 pub mod thread_local;
+#[path = "../unix/thread_parker/pthread.rs"]
+pub mod thread_parker;
 pub mod time;
 
 mod abi;

src/libstd/sys/redox/mod.rs

@@ -42,6 +42,8 @@ pub mod stdio;
 pub mod syscall;
 pub mod thread;
 pub mod thread_local;
+#[path = "../unix/thread_parker/pthread.rs"]
+pub mod thread_parker;
 pub mod time;
 
 #[cfg(not(test))]

src/libstd/sys/unix/mod.rs

@@ -66,6 +66,7 @@ pub mod rwlock;
 pub mod stack_overflow;
 pub mod thread;
 pub mod thread_local;
+pub mod thread_parker;
 pub mod time;
 pub mod stdio;
 

src/libstd/sys/unix/thread_parker/futex.rs

@@ -0,0 +1,133 @@
+// Copyright 2016 Amanieu d'Antras
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+use libc;
+use ptr;
+use sync::atomic::{AtomicI32, Ordering};
+use time::Instant;
+use super::tv_nsec_t;
+
+const FUTEX_WAIT: i32 = 0;
+const FUTEX_WAKE: i32 = 1;
+const FUTEX_PRIVATE: i32 = 128;
+
+// Helper type for putting a thread to sleep until some other thread wakes it up
+pub struct ThreadParker {
+    futex: AtomicI32,
+}
+
+impl ThreadParker {
+    pub const IS_CHEAP_TO_CONSTRUCT: bool = true;
+
+    pub fn new() -> ThreadParker {
+        ThreadParker {
+            futex: AtomicI32::new(0),
+        }
+    }
+
+    // Prepares the parker. This should be called before adding it to the queue.
+    pub fn prepare_park(&self) {
+        self.futex.store(1, Ordering::Relaxed);
+    }
+
+    // Checks if the park timed out. This should be called while holding the
+    // queue lock after park_until has returned false.
+    pub fn timed_out(&self) -> bool {
+        self.futex.load(Ordering::Relaxed) != 0
+    }
+
+    // Parks the thread until it is unparked. This should be called after it has
+    // been added to the queue, after unlocking the queue.
+    pub fn park(&self) {
+        while self.futex.load(Ordering::Acquire) != 0 {
+            self.futex_wait(None);
+        }
+    }
+
+    // Parks the thread until it is unparked or the timeout is reached. This
+    // should be called after it has been added to the queue, after unlocking
+    // the queue. Returns true if we were unparked and false if we timed out.
+    pub fn park_until(&self, timeout: Instant) -> bool {
+        while self.futex.load(Ordering::Acquire) != 0 {
+            let now = Instant::now();
+            if timeout <= now {
+                return false;
+            }
+            let diff = timeout - now;
+            if diff.as_secs() as libc::time_t as u64 != diff.as_secs() {
+                // Timeout overflowed, just sleep indefinitely
+                self.park();
+                return true;
+            }
+            let ts = libc::timespec {
+                tv_sec: diff.as_secs() as libc::time_t,
+                tv_nsec: diff.subsec_nanos() as tv_nsec_t,
+            };
+            self.futex_wait(Some(ts));
+        }
+        true
+    }
+
+    #[inline]
+    fn futex_wait(&self, ts: Option<libc::timespec>) {
+        let ts_ptr = ts
+            .as_ref()
+            .map(|ts_ref| ts_ref as *const _)
+            .unwrap_or(ptr::null());
+        let r = unsafe {
+            libc::syscall(
+                libc::SYS_futex,
+                &self.futex,
+                FUTEX_WAIT | FUTEX_PRIVATE,
+                1,
+                ts_ptr,
+            )
+        };
+        debug_assert!(r == 0 || r == -1);
+        if r == -1 {
+            unsafe {
+                debug_assert!(
+                    *libc::__errno_location() == libc::EINTR
+                        || *libc::__errno_location() == libc::EAGAIN
+                        || (ts.is_some() && *libc::__errno_location() == libc::ETIMEDOUT)
+                );
+            }
+        }
+    }
+
+    // Locks the parker to prevent the target thread from exiting. This is
+    // necessary to ensure that thread-local ThreadData objects remain valid.
+    // This should be called while holding the queue lock.
+    pub fn unpark_lock(&self) -> UnparkHandle {
+        // We don't need to lock anything, just clear the state
+        self.futex.store(0, Ordering::Release);
+
+        UnparkHandle { futex: &self.futex }
+    }
+}
+
+// Handle for a thread that is about to be unparked. We need to mark the thread
+// as unparked while holding the queue lock, but we delay the actual unparking
+// until after the queue lock is released.
+pub struct UnparkHandle {
+    futex: *const AtomicI32,
+}
+
+impl UnparkHandle {
+    // Wakes up the parked thread. This should be called after the queue lock is
+    // released to avoid blocking the queue for too long.
+    pub fn unpark(self) {
+        // The thread data may have been freed at this point, but it doesn't
+        // matter since the syscall will just return EFAULT in that case.
+        let r =
+            unsafe { libc::syscall(libc::SYS_futex, self.futex, FUTEX_WAKE | FUTEX_PRIVATE, 1) };
+        debug_assert!(r == 0 || r == 1 || r == -1);
+        if r == -1 {
+            debug_assert_eq!(unsafe { *libc::__errno_location() }, libc::EFAULT);
+        }
+    }
+}

src/libstd/sys/unix/thread_parker/mod.rs

@@ -0,0 +1,26 @@
+// Copyright 2016 Amanieu d'Antras
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+// x32 Linux uses a non-standard type for tv_nsec in timespec.
+// See https://sourceware.org/bugzilla/show_bug.cgi?id=16437
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "32"))]
+#[allow(non_camel_case_types)]
+type tv_nsec_t = i64;
+#[cfg(not(all(target_arch = "x86_64", target_pointer_width = "32")))]
+#[allow(non_camel_case_types)]
+type tv_nsec_t = libc::c_long;
+
+#[cfg(target_os = "linux")]
+mod futex;
+#[cfg(target_os = "linux")]
+pub use self::futex::*;
+
+
+#[cfg(not(target_os = "linux"))]
+mod pthread;
+#[cfg(not(target_os = "linux"))]
+pub use self::pthread::*;