Rename std::rt::deque::*::init() to *::new()
This commit is contained in:
parent
2c4a1b55e6
commit
b1705714d5
5 changed files with 21 additions and 21 deletions
|
@ -1082,7 +1082,7 @@ mod test {
|
|||
|
||||
do run_in_bare_thread {
|
||||
let sleepers = SleeperList::new();
|
||||
let mut pool = BufferPool::init();
|
||||
let mut pool = BufferPool::new();
|
||||
let (worker1, stealer1) = pool.deque();
|
||||
let (worker2, stealer2) = pool.deque();
|
||||
let queues = ~[stealer1, stealer2];
|
||||
|
|
|
@ -26,7 +26,7 @@
|
|||
//!
|
||||
//! use std::rt::deque::BufferPool;
|
||||
//!
|
||||
//! let mut pool = BufferPool::init();
|
||||
//! let mut pool = BufferPool::new();
|
||||
//! let (mut worker, mut stealer) = pool.deque();
|
||||
//!
|
||||
//! // Only the worker may push/pop
|
||||
|
@ -139,14 +139,14 @@ struct Buffer<T> {
|
|||
impl<T: Send> BufferPool<T> {
|
||||
/// Allocates a new buffer pool which in turn can be used to allocate new
|
||||
/// deques.
|
||||
pub fn init() -> BufferPool<T> {
|
||||
pub fn new() -> BufferPool<T> {
|
||||
BufferPool { pool: Exclusive::new(~[]) }
|
||||
}
|
||||
|
||||
/// Allocates a new work-stealing deque which will send/receiving memory to
|
||||
/// and from this buffer pool.
|
||||
pub fn deque(&mut self) -> (Worker<T>, Stealer<T>) {
|
||||
let (a, b) = UnsafeArc::new2(Deque::init(self.clone()));
|
||||
let (a, b) = UnsafeArc::new2(Deque::new(self.clone()));
|
||||
(Worker { deque: a }, Stealer { deque: b })
|
||||
}
|
||||
|
||||
|
@ -155,7 +155,7 @@ impl<T: Send> BufferPool<T> {
|
|||
self.pool.with(|pool| {
|
||||
match pool.iter().position(|x| x.size() >= (1 << bits)) {
|
||||
Some(i) => pool.remove(i),
|
||||
None => ~Buffer::init(bits)
|
||||
None => ~Buffer::new(bits)
|
||||
}
|
||||
})
|
||||
}
|
||||
|
@ -221,7 +221,7 @@ impl<T: Send> Clone for Stealer<T> {
|
|||
// personally going to heavily comment what's going on here.
|
||||
|
||||
impl<T: Send> Deque<T> {
|
||||
fn init(mut pool: BufferPool<T>) -> Deque<T> {
|
||||
fn new(mut pool: BufferPool<T>) -> Deque<T> {
|
||||
let buf = pool.alloc(MIN_BITS);
|
||||
Deque {
|
||||
bottom: AtomicInt::new(0),
|
||||
|
@ -341,7 +341,7 @@ impl<T: Send> Drop for Deque<T> {
|
|||
}
|
||||
|
||||
impl<T: Send> Buffer<T> {
|
||||
unsafe fn init(log_size: int) -> Buffer<T> {
|
||||
unsafe fn new(log_size: int) -> Buffer<T> {
|
||||
let size = (1 << log_size) * mem::size_of::<T>();
|
||||
let buffer = libc::malloc(size as libc::size_t);
|
||||
assert!(!buffer.is_null());
|
||||
|
@ -375,7 +375,7 @@ impl<T: Send> Buffer<T> {
|
|||
// Again, unsafe because this has incredibly dubious ownership violations.
|
||||
// It is assumed that this buffer is immediately dropped.
|
||||
unsafe fn resize(&self, b: int, t: int, delta: int) -> Buffer<T> {
|
||||
let mut buf = Buffer::init(self.log_size + delta);
|
||||
let mut buf = Buffer::new(self.log_size + delta);
|
||||
for i in range(t, b) {
|
||||
buf.put(i, self.get(i));
|
||||
}
|
||||
|
@ -406,7 +406,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn smoke() {
|
||||
let mut pool = BufferPool::init();
|
||||
let mut pool = BufferPool::new();
|
||||
let (mut w, mut s) = pool.deque();
|
||||
assert_eq!(w.pop(), None);
|
||||
assert_eq!(s.steal(), Empty);
|
||||
|
@ -421,7 +421,7 @@ mod tests {
|
|||
#[test]
|
||||
fn stealpush() {
|
||||
static AMT: int = 100000;
|
||||
let mut pool = BufferPool::<int>::init();
|
||||
let mut pool = BufferPool::<int>::new();
|
||||
let (mut w, s) = pool.deque();
|
||||
let t = do Thread::start {
|
||||
let mut s = s;
|
||||
|
@ -447,7 +447,7 @@ mod tests {
|
|||
#[test]
|
||||
fn stealpush_large() {
|
||||
static AMT: int = 100000;
|
||||
let mut pool = BufferPool::<(int, int)>::init();
|
||||
let mut pool = BufferPool::<(int, int)>::new();
|
||||
let (mut w, s) = pool.deque();
|
||||
let t = do Thread::start {
|
||||
let mut s = s;
|
||||
|
@ -509,7 +509,7 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
fn run_stampede() {
|
||||
let mut pool = BufferPool::<~int>::init();
|
||||
let mut pool = BufferPool::<~int>::new();
|
||||
let (w, s) = pool.deque();
|
||||
stampede(w, s, 8, 10000);
|
||||
}
|
||||
|
@ -517,7 +517,7 @@ mod tests {
|
|||
#[test]
|
||||
fn many_stampede() {
|
||||
static AMT: uint = 4;
|
||||
let mut pool = BufferPool::<~int>::init();
|
||||
let mut pool = BufferPool::<~int>::new();
|
||||
let threads = range(0, AMT).map(|_| {
|
||||
let (w, s) = pool.deque();
|
||||
do Thread::start {
|
||||
|
@ -536,7 +536,7 @@ mod tests {
|
|||
static NTHREADS: int = 8;
|
||||
static mut DONE: AtomicBool = INIT_ATOMIC_BOOL;
|
||||
static mut HITS: AtomicUint = INIT_ATOMIC_UINT;
|
||||
let mut pool = BufferPool::<int>::init();
|
||||
let mut pool = BufferPool::<int>::new();
|
||||
let (mut w, s) = pool.deque();
|
||||
|
||||
let threads = range(0, NTHREADS).map(|_| {
|
||||
|
@ -595,7 +595,7 @@ mod tests {
|
|||
static AMT: int = 10000;
|
||||
static NTHREADS: int = 4;
|
||||
static mut DONE: AtomicBool = INIT_ATOMIC_BOOL;
|
||||
let mut pool = BufferPool::<(int, uint)>::init();
|
||||
let mut pool = BufferPool::<(int, uint)>::new();
|
||||
let (mut w, s) = pool.deque();
|
||||
|
||||
let (threads, hits) = vec::unzip(range(0, NTHREADS).map(|_| {
|
||||
|
|
|
@ -281,7 +281,7 @@ fn run_(main: proc(), use_main_sched: bool) -> int {
|
|||
|
||||
// Create a work queue for each scheduler, ntimes. Create an extra
|
||||
// for the main thread if that flag is set. We won't steal from it.
|
||||
let mut pool = deque::BufferPool::init();
|
||||
let mut pool = deque::BufferPool::new();
|
||||
let arr = vec::from_fn(nscheds, |_| pool.deque());
|
||||
let (workers, stealers) = vec::unzip(arr.move_iter());
|
||||
|
||||
|
|
|
@ -1002,7 +1002,7 @@ mod test {
|
|||
do run_in_bare_thread {
|
||||
|
||||
let sleepers = SleeperList::new();
|
||||
let mut pool = BufferPool::init();
|
||||
let mut pool = BufferPool::new();
|
||||
let (normal_worker, normal_stealer) = pool.deque();
|
||||
let (special_worker, special_stealer) = pool.deque();
|
||||
let queues = ~[normal_stealer, special_stealer];
|
||||
|
@ -1177,7 +1177,7 @@ mod test {
|
|||
do run_in_bare_thread {
|
||||
stress_factor().times(|| {
|
||||
let sleepers = SleeperList::new();
|
||||
let mut pool = BufferPool::init();
|
||||
let mut pool = BufferPool::new();
|
||||
let (worker, stealer) = pool.deque();
|
||||
|
||||
let mut sched = ~Scheduler::new(
|
||||
|
|
|
@ -36,7 +36,7 @@ use vec::{OwnedVector, MutableVector, ImmutableVector};
|
|||
|
||||
pub fn new_test_uv_sched() -> Scheduler {
|
||||
|
||||
let mut pool = BufferPool::init();
|
||||
let mut pool = BufferPool::new();
|
||||
let (worker, stealer) = pool.deque();
|
||||
|
||||
let mut sched = Scheduler::new(new_event_loop(),
|
||||
|
@ -51,7 +51,7 @@ pub fn new_test_uv_sched() -> Scheduler {
|
|||
}
|
||||
|
||||
pub fn new_test_sched() -> Scheduler {
|
||||
let mut pool = BufferPool::init();
|
||||
let mut pool = BufferPool::new();
|
||||
let (worker, stealer) = pool.deque();
|
||||
|
||||
let mut sched = Scheduler::new(basic::event_loop(),
|
||||
|
@ -228,7 +228,7 @@ pub fn run_in_mt_newsched_task(f: proc()) {
|
|||
let mut handles = ~[];
|
||||
let mut scheds = ~[];
|
||||
|
||||
let mut pool = BufferPool::<~Task>::init();
|
||||
let mut pool = BufferPool::<~Task>::new();
|
||||
let workers = range(0, nthreads).map(|_| pool.deque());
|
||||
let (workers, stealers) = vec::unzip(workers);
|
||||
|
||||
|
|
Loading…
Reference in a new issue