diff --git a/mk/crates.mk b/mk/crates.mk index e02e4fb8706e8..dd94d268becb5 100644 --- a/mk/crates.mk +++ b/mk/crates.mk @@ -49,25 +49,26 @@ # automatically generated for all stage/host/target combinations. ################################################################################ -TARGET_CRATES := std extra green rustuv native flate arena glob term semver uuid +TARGET_CRATES := std extra green rustuv native flate arena glob term semver uuid sync HOST_CRATES := syntax rustc rustdoc CRATES := $(TARGET_CRATES) $(HOST_CRATES) TOOLS := compiletest rustdoc rustc DEPS_std := native:rustrt -DEPS_extra := std term +DEPS_extra := std term sync DEPS_green := std DEPS_rustuv := std native:uv native:uv_support DEPS_native := std DEPS_syntax := std extra term -DEPS_rustc := syntax native:rustllvm flate arena -DEPS_rustdoc := rustc native:sundown +DEPS_rustc := syntax native:rustllvm flate arena sync +DEPS_rustdoc := rustc native:sundown sync DEPS_flate := std native:miniz DEPS_arena := std extra DEPS_glob := std DEPS_term := std DEPS_semver := std DEPS_uuid := std extra +DEPS_sync := std TOOL_DEPS_compiletest := extra green rustuv TOOL_DEPS_rustdoc := rustdoc green rustuv diff --git a/src/doc/guide-tasks.md b/src/doc/guide-tasks.md index c3bdbe3a3ee89..387f481025df7 100644 --- a/src/doc/guide-tasks.md +++ b/src/doc/guide-tasks.md @@ -39,7 +39,7 @@ data through the global _exchange heap_. While Rust's type system provides the building blocks needed for safe and efficient tasks, all of the task functionality itself is implemented -in the standard and extra libraries, which are still under development +in the standard and sync libraries, which are still under development and do not always present a consistent or complete interface. For your reference, these are the standard modules involved in Rust @@ -47,18 +47,43 @@ concurrency at this writing: * [`std::task`] - All code relating to tasks and task scheduling, * [`std::comm`] - The message passing interface, -* [`extra::comm`] - Additional messaging types based on `std::comm`, -* [`extra::sync`] - More exotic synchronization tools, including locks, -* [`extra::arc`] - The Arc (atomically reference counted) type, - for safely sharing immutable data, -* [`extra::future`] - A type representing values that may be computed concurrently and retrieved at a later time. +* [`sync::DuplexStream`] - An extension of `pipes::stream` that allows both sending and receiving, +* [`sync::SyncChan`] - An extension of `pipes::stream` that provides synchronous message sending, +* [`sync::SyncPort`] - An extension of `pipes::stream` that acknowledges each message received, +* [`sync::rendezvous`] - Creates a stream whose channel, upon sending a message, blocks until the + message is received. +* [`sync::Arc`] - The Arc (atomically reference counted) type, for safely sharing immutable data, +* [`sync::RWArc`] - A dual-mode Arc protected by a reader-writer lock, +* [`sync::MutexArc`] - An Arc with mutable data protected by a blocking mutex, +* [`sync::Semaphore`] - A counting, blocking, bounded-waiting semaphore, +* [`sync::Mutex`] - A blocking, bounded-waiting, mutual exclusion lock with an associated + FIFO condition variable, +* [`sync::RWLock`] - A blocking, no-starvation, reader-writer lock with an associated condvar, +* [`sync::Barrier`] - A barrier enables multiple tasks to synchronize the beginning + of some computation, +* [`sync::TaskPool`] - A task pool abstraction, +* [`sync::Future`] - A type encapsulating the result of a computation which may not be complete, +* [`sync::one`] - A "once initialization" primitive +* [`sync::mutex`] - A proper mutex implementation regardless of the "flavor of task" which is + acquiring the lock. [`std::task`]: std/task/index.html [`std::comm`]: std/comm/index.html -[`extra::comm`]: extra/comm/index.html -[`extra::sync`]: extra/sync/index.html -[`extra::arc`]: extra/arc/index.html -[`extra::future`]: extra/future/index.html +[`sync::DuplexStream`]: sync/struct.DuplexStream.html +[`sync::SyncChan`]: sync/struct.SyncChan.html +[`sync::SyncPort`]: sync/struct.SyncPort.html +[`sync::rendezvous`]: sync/fn.rendezvous.html +[`sync::Arc`]: sync/struct.Arc.html +[`sync::RWArc`]: sync/struct.RWArc.html +[`sync::MutexArc`]: sync/struct.MutexArc.html +[`sync::Semaphore`]: sync/struct.Semaphore.html +[`sync::Mutex`]: sync/struct.Mutex.html +[`sync::RWLock`]: sync/struct.RWLock.html +[`sync::Barrier`]: sync/struct.Barrier.html +[`sync::TaskPool`]: sync/struct.TaskPool.html +[`sync::Future`]: sync/struct.Future.html +[`sync::one`]: sync/one/index.html +[`sync::mutex`]: sync/mutex/index.html # Basics @@ -254,21 +279,25 @@ let result = ports.iter().fold(0, |accum, port| accum + port.recv() ); ~~~ ## Backgrounding computations: Futures -With `extra::future`, rust has a mechanism for requesting a computation and getting the result +With `sync::Future`, rust has a mechanism for requesting a computation and getting the result later. The basic example below illustrates this. ~~~ +# extern mod sync; + +# fn main() { # fn make_a_sandwich() {}; fn fib(n: u64) -> u64 { // lengthy computation returning an uint 12586269025 } -let mut delayed_fib = extra::future::Future::spawn(proc() fib(50)); +let mut delayed_fib = sync::Future::spawn(proc() fib(50)); make_a_sandwich(); println!("fib(50) = {:?}", delayed_fib.get()) +# } ~~~ The call to `future::spawn` returns immediately a `future` object regardless of how long it @@ -281,6 +310,7 @@ Here is another example showing how futures allow you to background computations be distributed on the available cores. ~~~ +# extern mod sync; # use std::vec; fn partial_sum(start: uint) -> f64 { let mut local_sum = 0f64; @@ -291,7 +321,7 @@ fn partial_sum(start: uint) -> f64 { } fn main() { - let mut futures = vec::from_fn(1000, |ind| extra::future::Future::spawn( proc() { partial_sum(ind) })); + let mut futures = vec::from_fn(1000, |ind| sync::Future::spawn( proc() { partial_sum(ind) })); let mut final_res = 0f64; for ft in futures.mut_iter() { @@ -309,16 +339,17 @@ add up to a significant amount of wasted memory and would require copying the sa necessary. To tackle this issue, one can use an Atomically Reference Counted wrapper (`Arc`) as implemented in -the `extra` library of Rust. With an Arc, the data will no longer be copied for each task. The Arc +the `sync` library of Rust. With an Arc, the data will no longer be copied for each task. The Arc acts as a reference to the shared data and only this reference is shared and cloned. Here is a small example showing how to use Arcs. We wish to run concurrently several computations on a single large vector of floats. Each task needs the full vector to perform its duty. ~~~ +# extern mod sync; # use std::vec; # use std::rand; -use extra::arc::Arc; +use sync::Arc; fn pnorm(nums: &~[f64], p: uint) -> f64 { nums.iter().fold(0.0, |a,b| a+(*b).powf(&(p as f64)) ).powf(&(1.0 / (p as f64))) @@ -348,23 +379,29 @@ at the power given as argument and takes the inverse power of this value). The A created by the line ~~~ -# use extra::arc::Arc; +# extern mod sync; +# use sync::Arc; # use std::vec; # use std::rand; +# fn main() { # let numbers = vec::from_fn(1000000, |_| rand::random::()); let numbers_arc=Arc::new(numbers); +# } ~~~ and a clone of it is sent to each task ~~~ -# use extra::arc::Arc; +# extern mod sync; +# use sync::Arc; # use std::vec; # use std::rand; +# fn main() { # let numbers=vec::from_fn(1000000, |_| rand::random::()); # let numbers_arc = Arc::new(numbers); # let (port, chan) = Chan::new(); chan.send(numbers_arc.clone()); +# } ~~~ copying only the wrapper and not its contents. @@ -372,15 +409,18 @@ copying only the wrapper and not its contents. Each task recovers the underlying data by ~~~ -# use extra::arc::Arc; +# extern mod sync; +# use sync::Arc; # use std::vec; # use std::rand; +# fn main() { # let numbers=vec::from_fn(1000000, |_| rand::random::()); # let numbers_arc=Arc::new(numbers); # let (port, chan) = Chan::new(); # chan.send(numbers_arc.clone()); # let local_arc : Arc<~[f64]> = port.recv(); let task_numbers = local_arc.get(); +# } ~~~ and can use it as if it were local. @@ -450,7 +490,7 @@ proceed). A very common thing to do is to spawn a child task where the parent and child both need to exchange messages with each other. The -function `extra::comm::DuplexStream()` supports this pattern. We'll +function `sync::comm::DuplexStream()` supports this pattern. We'll look briefly at how to use it. To see how `DuplexStream()` works, we will create a child task @@ -458,17 +498,19 @@ that repeatedly receives a `uint` message, converts it to a string, and sends the string in response. The child terminates when it receives `0`. Here is the function that implements the child task: -~~~{.ignore .linked-failure} -# use extra::comm::DuplexStream; -# use std::uint; -fn stringifier(channel: &DuplexStream<~str, uint>) { - let mut value: uint; - loop { - value = channel.recv(); - channel.send(uint::to_str(value)); - if value == 0 { break; } +~~~ +# extern mod sync; +# fn main() { +# use sync::DuplexStream; + fn stringifier(channel: &DuplexStream<~str, uint>) { + let mut value: uint; + loop { + value = channel.recv(); + channel.send(value.to_str()); + if value == 0 { break; } + } } -} +# } ~~~~ The implementation of `DuplexStream` supports both sending and @@ -481,15 +523,15 @@ response itself is simply the stringified version of the received value, Here is the code for the parent task: -~~~{.ignore .linked-failure} +~~~ +# extern mod sync; # use std::task::spawn; -# use std::uint; -# use extra::comm::DuplexStream; +# use sync::DuplexStream; # fn stringifier(channel: &DuplexStream<~str, uint>) { # let mut value: uint; # loop { # value = channel.recv(); -# channel.send(uint::to_str(value)); +# channel.send(value.to_str()); # if value == 0u { break; } # } # } diff --git a/src/doc/index.md b/src/doc/index.md index 9915d67bfcad3..5aa92c9fec4db 100644 --- a/src/doc/index.md +++ b/src/doc/index.md @@ -43,6 +43,7 @@ li {list-style-type: none; } * [The `semver` version collation library](semver/index.html) * [The `term` terminal-handling library](term/index.html) * [The UUID library](uuid/index.html) +* [The `sync` library for concurrency-enabled mechanisms and primitives](sync/index.html) # Tooling diff --git a/src/etc/licenseck.py b/src/etc/licenseck.py index afbf34d07535d..e214a40e3d134 100644 --- a/src/etc/licenseck.py +++ b/src/etc/licenseck.py @@ -41,7 +41,7 @@ "libstd/sync/mpsc_queue.rs", # BSD "libstd/sync/spsc_queue.rs", # BSD "libstd/sync/mpmc_bounded_queue.rs", # BSD - "libextra/sync/mpsc_intrusive.rs", # BSD + "libsync/sync/mpsc_intrusive.rs", # BSD ] def check_license(name, contents): diff --git a/src/libextra/lib.rs b/src/libextra/lib.rs index d198fd44450c4..401ece64a5dc2 100644 --- a/src/libextra/lib.rs +++ b/src/libextra/lib.rs @@ -34,17 +34,16 @@ Rust extras are part of the standard Rust distribution. #[deny(non_camel_case_types)]; #[deny(missing_doc)]; -// Utility modules +extern mod sync; -pub mod c_vec; +#[cfg(stage0)] +macro_rules! if_ok ( + ($e:expr) => (match $e { Ok(e) => e, Err(e) => return Err(e) }) +) -// Concurrency +// Utility modules -pub mod sync; -pub mod arc; -pub mod comm; -pub mod future; -pub mod task_pool; +pub mod c_vec; // Collections diff --git a/src/libextra/workcache.rs b/src/libextra/workcache.rs index 4d8e7e50dcfd5..d16edb7aa1e79 100644 --- a/src/libextra/workcache.rs +++ b/src/libextra/workcache.rs @@ -13,7 +13,7 @@ use json; use json::ToJson; use serialize::{Encoder, Encodable, Decoder, Decodable}; -use arc::{Arc,RWArc}; +use sync::{Arc,RWArc}; use treemap::TreeMap; use std::str; use std::io; diff --git a/src/librustc/back/link.rs b/src/librustc/back/link.rs index e224a06818af1..aea9b65087dc6 100644 --- a/src/librustc/back/link.rs +++ b/src/librustc/back/link.rs @@ -331,7 +331,7 @@ pub mod write { } unsafe fn configure_llvm(sess: Session) { - use extra::sync::one::{Once, ONCE_INIT}; + use sync::one::{Once, ONCE_INIT}; static mut INIT: Once = ONCE_INIT; // Copy what clang does by turning on loop vectorization at O2 and diff --git a/src/librustc/lib.rs b/src/librustc/lib.rs index 8e722fae13a36..d4a6c29752d16 100644 --- a/src/librustc/lib.rs +++ b/src/librustc/lib.rs @@ -35,6 +35,7 @@ extern mod extra; extern mod flate; extern mod arena; extern mod syntax; +extern mod sync; use back::link; use driver::session; diff --git a/src/librustc/middle/trans/base.rs b/src/librustc/middle/trans/base.rs index 1ebe4a03cfdd2..5b4a961761277 100644 --- a/src/librustc/middle/trans/base.rs +++ b/src/librustc/middle/trans/base.rs @@ -2660,7 +2660,7 @@ pub fn trans_crate(sess: session::Session, output: &Path) -> CrateTranslation { // Before we touch LLVM, make sure that multithreading is enabled. unsafe { - use extra::sync::one::{Once, ONCE_INIT}; + use sync::one::{Once, ONCE_INIT}; static mut INIT: Once = ONCE_INIT; static mut POISONED: bool = false; INIT.doit(|| { diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs index 65696528a6fa1..f01e420030f6d 100644 --- a/src/librustdoc/html/render.rs +++ b/src/librustdoc/html/render.rs @@ -41,7 +41,7 @@ use std::io::{fs, File, BufferedWriter}; use std::str; use std::vec; -use extra::arc::Arc; +use sync::Arc; use extra::json::ToJson; use syntax::ast; use syntax::attr; diff --git a/src/librustdoc/lib.rs b/src/librustdoc/lib.rs index fe989279e7147..bf096a7e49b46 100644 --- a/src/librustdoc/lib.rs +++ b/src/librustdoc/lib.rs @@ -18,6 +18,7 @@ extern mod syntax; extern mod rustc; extern mod extra; +extern mod sync; use std::local_data; use std::io; diff --git a/src/libextra/arc.rs b/src/libsync/arc.rs similarity index 99% rename from src/libextra/arc.rs rename to src/libsync/arc.rs index 7f8d64053d51c..0e53ecd416a7a 100644 --- a/src/libextra/arc.rs +++ b/src/libsync/arc.rs @@ -18,7 +18,7 @@ * With simple pipes, without Arc, a copy would have to be made for each task. * * ```rust - * use extra::arc::Arc; + * use sync::Arc; * use std::{rand, vec}; * * let numbers = vec::from_fn(100, |i| (i as f32) * rand::random()); @@ -38,7 +38,7 @@ * ``` */ -#[allow(missing_doc)]; +#[allow(missing_doc, dead_code)]; use sync; @@ -424,7 +424,7 @@ impl RWArc { * # Example * * ```rust - * use extra::arc::RWArc; + * use sync::RWArc; * * let arc = RWArc::new(1); * arc.write_downgrade(|mut write_token| { @@ -605,7 +605,7 @@ impl Clone for CowArc { #[cfg(test)] mod tests { - use arc::*; + use super::{Arc, RWArc, MutexArc, CowArc}; use std::task; diff --git a/src/libextra/comm.rs b/src/libsync/comm.rs similarity index 100% rename from src/libextra/comm.rs rename to src/libsync/comm.rs diff --git a/src/libextra/future.rs b/src/libsync/future.rs similarity index 99% rename from src/libextra/future.rs rename to src/libsync/future.rs index b9121290f33f4..479174d17afb0 100644 --- a/src/libextra/future.rs +++ b/src/libsync/future.rs @@ -15,7 +15,7 @@ * # Example * * ```rust - * use extra::future::Future; + * use sync::Future; * # fn fib(n: uint) -> uint {42}; * # fn make_a_sandwich() {}; * let mut delayed_fib = Future::spawn(proc() { fib(5000) }); diff --git a/src/libsync/lib.rs b/src/libsync/lib.rs new file mode 100644 index 0000000000000..de1b0f91d6dc5 --- /dev/null +++ b/src/libsync/lib.rs @@ -0,0 +1,31 @@ +// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT +// file at the top-level directory of this distribution and at +// http://rust-lang.org/COPYRIGHT. +// +// Licensed under the Apache License, Version 2.0 or the MIT license +// , at your +// option. This file may not be copied, modified, or distributed +// except according to those terms. + +/*! + * Concurrency-enabled mechanisms and primitives. + */ + +#[crate_id = "sync#0.10-pre"]; +#[crate_type = "rlib"]; +#[crate_type = "dylib"]; +#[license = "MIT/ASL2"]; + +pub use arc::{Arc, MutexArc, RWArc, RWWriteMode, RWReadMode, Condvar}; +pub use sync::{Mutex, RWLock, Condvar, Semaphore, RWLockWriteMode, + RWLockReadMode, Barrier, one, mutex}; +pub use comm::{DuplexStream, SyncChan, SyncPort, rendezvous}; +pub use task_pool::TaskPool; +pub use future::Future; + +mod arc; +mod sync; +mod comm; +mod task_pool; +mod future; diff --git a/src/libextra/sync/mod.rs b/src/libsync/sync/mod.rs similarity index 99% rename from src/libextra/sync/mod.rs rename to src/libsync/sync/mod.rs index 03bf1101f1f29..cfff31e08d4b3 100644 --- a/src/libextra/sync/mod.rs +++ b/src/libsync/sync/mod.rs @@ -588,7 +588,7 @@ impl RWLock { * # Example * * ```rust - * use extra::sync::RWLock; + * use sync::RWLock; * * let lock = RWLock::new(); * lock.write_downgrade(|mut write_token| { @@ -695,7 +695,7 @@ impl<'a> RWLockReadMode<'a> { /// of some computation. /// /// ```rust -/// use extra::sync::Barrier; +/// use sync::Barrier; /// /// let barrier = Barrier::new(10); /// for _ in range(0, 10) { @@ -759,7 +759,7 @@ impl Barrier { #[cfg(test)] mod tests { - use sync::*; + use sync::{Semaphore, Mutex, RWLock, Barrier, Condvar}; use std::cast; use std::result; diff --git a/src/libextra/sync/mpsc_intrusive.rs b/src/libsync/sync/mpsc_intrusive.rs similarity index 100% rename from src/libextra/sync/mpsc_intrusive.rs rename to src/libsync/sync/mpsc_intrusive.rs diff --git a/src/libextra/sync/mutex.rs b/src/libsync/sync/mutex.rs similarity index 99% rename from src/libextra/sync/mutex.rs rename to src/libsync/sync/mutex.rs index 7ea98c0741a29..f1a81d65c1da5 100644 --- a/src/libextra/sync/mutex.rs +++ b/src/libsync/sync/mutex.rs @@ -83,7 +83,7 @@ pub static NATIVE_BLOCKED: uint = 1 << 2; /// # Example /// /// ```rust -/// use extra::sync::mutex::Mutex; +/// use sync::mutex::Mutex; /// /// let mut m = Mutex::new(); /// let guard = m.lock(); @@ -113,7 +113,7 @@ enum Flavor { /// # Example /// /// ```rust -/// use extra::sync::mutex::{StaticMutex, MUTEX_INIT}; +/// use sync::mutex::{StaticMutex, MUTEX_INIT}; /// /// static mut LOCK: StaticMutex = MUTEX_INIT; /// diff --git a/src/libextra/sync/one.rs b/src/libsync/sync/one.rs similarity index 99% rename from src/libextra/sync/one.rs rename to src/libsync/sync/one.rs index 826955d93e8d3..93d818b704dc9 100644 --- a/src/libextra/sync/one.rs +++ b/src/libsync/sync/one.rs @@ -30,7 +30,7 @@ use sync::mutex::{StaticMutex, MUTEX_INIT}; /// # Example /// /// ```rust -/// use extra::sync::one::{Once, ONCE_INIT}; +/// use sync::one::{Once, ONCE_INIT}; /// /// static mut START: Once = ONCE_INIT; /// unsafe { diff --git a/src/libextra/task_pool.rs b/src/libsync/task_pool.rs similarity index 100% rename from src/libextra/task_pool.rs rename to src/libsync/task_pool.rs diff --git a/src/test/bench/msgsend-ring-mutex-arcs.rs b/src/test/bench/msgsend-ring-mutex-arcs.rs index b1b2300466a5e..4b505ec811762 100644 --- a/src/test/bench/msgsend-ring-mutex-arcs.rs +++ b/src/test/bench/msgsend-ring-mutex-arcs.rs @@ -16,15 +16,17 @@ // This also serves as a pipes test, because Arcs are implemented with pipes. extern mod extra; +extern mod sync; -use extra::arc; -use extra::future::Future; +use sync::Arc; +use sync::MutexArc; +use sync::Future; use extra::time; use std::os; use std::uint; // A poor man's pipe. -type pipe = arc::MutexArc<~[uint]>; +type pipe = MutexArc<~[uint]>; fn send(p: &pipe, msg: uint) { unsafe { @@ -46,7 +48,7 @@ fn recv(p: &pipe) -> uint { } fn init() -> (pipe,pipe) { - let m = arc::MutexArc::new(~[]); + let m = MutexArc::new(~[]); ((&m).clone(), m) } diff --git a/src/test/bench/msgsend-ring-rw-arcs.rs b/src/test/bench/msgsend-ring-rw-arcs.rs index d7bd0f2f6bd3d..23b4f00b280da 100644 --- a/src/test/bench/msgsend-ring-rw-arcs.rs +++ b/src/test/bench/msgsend-ring-rw-arcs.rs @@ -16,15 +16,16 @@ // This also serves as a pipes test, because Arcs are implemented with pipes. extern mod extra; +extern mod sync; -use extra::arc; -use extra::future::Future; +use sync::RWArc; +use sync::Future; use extra::time; use std::os; use std::uint; // A poor man's pipe. -type pipe = arc::RWArc<~[uint]>; +type pipe = RWArc<~[uint]>; fn send(p: &pipe, msg: uint) { p.write_cond(|state, cond| { @@ -42,7 +43,7 @@ fn recv(p: &pipe) -> uint { } fn init() -> (pipe,pipe) { - let x = arc::RWArc::new(~[]); + let x = RWArc::new(~[]); ((&x).clone(), x) } diff --git a/src/test/bench/shootout-binarytrees.rs b/src/test/bench/shootout-binarytrees.rs index da658e6d041f7..c0e22f207b8f9 100644 --- a/src/test/bench/shootout-binarytrees.rs +++ b/src/test/bench/shootout-binarytrees.rs @@ -8,11 +8,11 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; +extern mod sync; extern mod arena; use std::iter::range_step; -use extra::future::Future; +use sync::Future; use arena::TypedArena; enum Tree<'a> { diff --git a/src/test/bench/shootout-spectralnorm.rs b/src/test/bench/shootout-spectralnorm.rs index d68ca4e0abbae..9de62aaf960e8 100644 --- a/src/test/bench/shootout-spectralnorm.rs +++ b/src/test/bench/shootout-spectralnorm.rs @@ -10,15 +10,15 @@ // xfail-test arcs no longer unwrap -extern mod extra; +extern mod sync; use std::from_str::FromStr; use std::iter::count; use std::num::min; use std::os; use std::vec::from_elem; -use extra::arc::Arc; -use extra::arc::RWArc; +use sync::Arc; +use sync::RWArc; fn A(i: uint, j: uint) -> f64 { ((i + j) * (i + j + 1) / 2 + i + 1) as f64 diff --git a/src/test/compile-fail/arc-cant-nest-rw-arc-3177.rs b/src/test/compile-fail/arc-cant-nest-rw-arc-3177.rs index 49412b3aafdea..5c55f10ab4f2a 100644 --- a/src/test/compile-fail/arc-cant-nest-rw-arc-3177.rs +++ b/src/test/compile-fail/arc-cant-nest-rw-arc-3177.rs @@ -8,8 +8,8 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; -use extra::arc::RWArc; +extern mod sync; +use sync::RWArc; fn main() { let arc1 = RWArc::new(true); diff --git a/src/test/compile-fail/arc-rw-cond-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-cond-shouldnt-escape.rs index c31a7bb244c72..c9cd132788225 100644 --- a/src/test/compile-fail/arc-rw-cond-shouldnt-escape.rs +++ b/src/test/compile-fail/arc-rw-cond-shouldnt-escape.rs @@ -9,10 +9,10 @@ // except according to those terms. // error-pattern: lifetime of return value does not outlive the function call -extern mod extra; -use extra::arc; +extern mod sync; +use sync::RWArc; fn main() { - let x = ~arc::RWArc::new(1); + let x = ~RWArc::new(1); let mut y = None; x.write_cond(|_one, cond| y = Some(cond)); y.unwrap().wait(); diff --git a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs index 716dfe2c8b5c5..dfdbd882acff6 100644 --- a/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs +++ b/src/test/compile-fail/arc-rw-read-mode-shouldnt-escape.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; -use extra::arc; +extern mod sync; +use sync::RWArc; fn main() { - let x = ~arc::RWArc::new(1); + let x = ~RWArc::new(1); let mut y = None; x.write_downgrade(|write_mode| { y = Some(x.downgrade(write_mode)); diff --git a/src/test/compile-fail/arc-rw-state-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-state-shouldnt-escape.rs index 7c129ae0dcaad..4bb7653d23e5c 100644 --- a/src/test/compile-fail/arc-rw-state-shouldnt-escape.rs +++ b/src/test/compile-fail/arc-rw-state-shouldnt-escape.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; -use extra::arc; +extern mod sync; +use sync::RWArc; fn main() { - let x = ~arc::RWArc::new(1); + let x = ~RWArc::new(1); let mut y = None; //~ ERROR lifetime of variable does not enclose its declaration x.write(|one| y = Some(one)); *y.unwrap() = 2; diff --git a/src/test/compile-fail/arc-rw-write-mode-cond-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-write-mode-cond-shouldnt-escape.rs index 674cd5708889c..1410308107e94 100644 --- a/src/test/compile-fail/arc-rw-write-mode-cond-shouldnt-escape.rs +++ b/src/test/compile-fail/arc-rw-write-mode-cond-shouldnt-escape.rs @@ -9,10 +9,10 @@ // except according to those terms. // error-pattern: lifetime of variable does not enclose its declaration -extern mod extra; -use extra::arc; +extern mod sync; +use sync::RWArc; fn main() { - let x = ~arc::RWArc::new(1); + let x = ~RWArc::new(1); let mut y = None; x.write_downgrade(|write_mode| { (&write_mode).write_cond(|_one, cond| { diff --git a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs index 213bf48a08750..68226d96a18ef 100644 --- a/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs +++ b/src/test/compile-fail/arc-rw-write-mode-shouldnt-escape.rs @@ -9,10 +9,10 @@ // except according to those terms. // error-pattern: lifetime of variable does not enclose its declaration -extern mod extra; -use extra::arc; +extern mod sync; +use sync::RWArc; fn main() { - let x = ~arc::RWArc::new(1); + let x = ~RWArc::new(1); let mut y = None; x.write_downgrade(|write_mode| y = Some(write_mode)); y.unwrap(); diff --git a/src/test/compile-fail/functional-struct-update-noncopyable.rs b/src/test/compile-fail/functional-struct-update-noncopyable.rs index 00945ea84693c..f2c9ba5822893 100644 --- a/src/test/compile-fail/functional-struct-update-noncopyable.rs +++ b/src/test/compile-fail/functional-struct-update-noncopyable.rs @@ -11,8 +11,8 @@ // issue 7327 // xfail-fast #7103 -extern mod extra; -use extra::arc::Arc; +extern mod sync; +use sync::Arc; struct A { y: Arc, x: Arc } diff --git a/src/test/compile-fail/future_not_copyable.rs b/src/test/compile-fail/future_not_copyable.rs index aef5d0f9b04a6..69a90275ec78b 100644 --- a/src/test/compile-fail/future_not_copyable.rs +++ b/src/test/compile-fail/future_not_copyable.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; +extern mod sync; -use extra::future::Future; +use sync::Future; fn main() { let f = Future::from_value(()); diff --git a/src/test/compile-fail/mutex-arc-nested.rs b/src/test/compile-fail/mutex-arc-nested.rs index 24a141c4799d5..cdfdd29410e76 100644 --- a/src/test/compile-fail/mutex-arc-nested.rs +++ b/src/test/compile-fail/mutex-arc-nested.rs @@ -8,10 +8,10 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; +extern mod sync; use std::task; -use extra::arc::{MutexArc}; +use sync::MutexArc; fn test_mutex_arc_nested() { let arc = ~MutexArc::new(1); diff --git a/src/test/compile-fail/no-capture-arc.rs b/src/test/compile-fail/no-capture-arc.rs index 5ae38e69ec0e3..cc529abd6f94f 100644 --- a/src/test/compile-fail/no-capture-arc.rs +++ b/src/test/compile-fail/no-capture-arc.rs @@ -10,14 +10,14 @@ // error-pattern: use of moved value -extern mod extra; -use extra::arc; +extern mod sync; +use sync::Arc; use std::task; fn main() { let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - let arc_v = arc::Arc::new(v); + let arc_v = Arc::new(v); task::spawn(proc() { let v = arc_v.get(); diff --git a/src/test/compile-fail/no-reuse-move-arc.rs b/src/test/compile-fail/no-reuse-move-arc.rs index c6c0ba41ab91a..204a0e1cdd4a0 100644 --- a/src/test/compile-fail/no-reuse-move-arc.rs +++ b/src/test/compile-fail/no-reuse-move-arc.rs @@ -8,14 +8,14 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -extern mod extra; -use extra::arc; +extern mod sync; +use sync::Arc; use std::task; fn main() { let v = ~[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; - let arc_v = arc::Arc::new(v); + let arc_v = Arc::new(v); task::spawn(proc() { let v = arc_v.get(); diff --git a/src/test/compile-fail/once-cant-call-twice-on-heap.rs b/src/test/compile-fail/once-cant-call-twice-on-heap.rs index 8d5e2229b2e5d..a7e4f8de43704 100644 --- a/src/test/compile-fail/once-cant-call-twice-on-heap.rs +++ b/src/test/compile-fail/once-cant-call-twice-on-heap.rs @@ -12,8 +12,8 @@ // This program would segfault if it were legal. #[feature(once_fns)]; -extern mod extra; -use extra::arc; +extern mod sync; +use sync::Arc; fn foo(blk: proc()) { blk(); @@ -21,7 +21,7 @@ fn foo(blk: proc()) { } fn main() { - let x = arc::Arc::new(true); + let x = Arc::new(true); foo(proc() { assert!(*x.get()); drop(x); diff --git a/src/test/compile-fail/once-cant-call-twice-on-stack.rs b/src/test/compile-fail/once-cant-call-twice-on-stack.rs index 71293555d499d..8b168dd67870e 100644 --- a/src/test/compile-fail/once-cant-call-twice-on-stack.rs +++ b/src/test/compile-fail/once-cant-call-twice-on-stack.rs @@ -12,8 +12,8 @@ // This program would segfault if it were legal. #[feature(once_fns)]; -extern mod extra; -use extra::arc; +extern mod sync; +use sync::Arc; fn foo(blk: once ||) { blk(); @@ -21,7 +21,7 @@ fn foo(blk: once ||) { } fn main() { - let x = arc::Arc::new(true); + let x = Arc::new(true); foo(|| { assert!(*x.get()); drop(x); diff --git a/src/test/compile-fail/once-cant-move-out-of-non-once-on-stack.rs b/src/test/compile-fail/once-cant-move-out-of-non-once-on-stack.rs index 7206b9bdb88eb..4fa6b6af7949e 100644 --- a/src/test/compile-fail/once-cant-move-out-of-non-once-on-stack.rs +++ b/src/test/compile-fail/once-cant-move-out-of-non-once-on-stack.rs @@ -11,8 +11,8 @@ // Testing guarantees provided by once functions. // This program would segfault if it were legal. -extern mod extra; -use extra::arc; +extern mod sync; +use sync::Arc; fn foo(blk: ||) { blk(); @@ -20,7 +20,7 @@ fn foo(blk: ||) { } fn main() { - let x = arc::Arc::new(true); + let x = Arc::new(true); foo(|| { assert!(*x.get()); drop(x); //~ ERROR cannot move out of captured outer variable diff --git a/src/test/compile-fail/sync-cond-shouldnt-escape.rs b/src/test/compile-fail/sync-cond-shouldnt-escape.rs index 4df08b28eb896..06b8ad6259b6b 100644 --- a/src/test/compile-fail/sync-cond-shouldnt-escape.rs +++ b/src/test/compile-fail/sync-cond-shouldnt-escape.rs @@ -9,8 +9,8 @@ // except according to those terms. // error-pattern: lifetime of variable does not enclose its declaration -extern mod extra; -use extra::sync; +extern mod sync; +use sync::Mutex; fn main() { let m = ~sync::Mutex::new(); diff --git a/src/test/compile-fail/sync-rwlock-cond-shouldnt-escape.rs b/src/test/compile-fail/sync-rwlock-cond-shouldnt-escape.rs index d59eaf62abf84..52466c122dd7f 100644 --- a/src/test/compile-fail/sync-rwlock-cond-shouldnt-escape.rs +++ b/src/test/compile-fail/sync-rwlock-cond-shouldnt-escape.rs @@ -9,10 +9,10 @@ // except according to those terms. // error-pattern: lifetime of method receiver does not outlive the method call -extern mod extra; -use extra::sync; +extern mod sync; +use sync::RWLock; fn main() { - let x = ~sync::RWLock::new(); + let x = ~RWLock::new(); let mut y = None; x.write_cond(|cond| { y = Some(cond); diff --git a/src/test/compile-fail/sync-rwlock-read-mode-shouldnt-escape.rs b/src/test/compile-fail/sync-rwlock-read-mode-shouldnt-escape.rs index 0078841acb139..0201f9dd51cbf 100644 --- a/src/test/compile-fail/sync-rwlock-read-mode-shouldnt-escape.rs +++ b/src/test/compile-fail/sync-rwlock-read-mode-shouldnt-escape.rs @@ -9,10 +9,10 @@ // except according to those terms. // error-pattern: cannot infer an appropriate lifetime -extern mod extra; -use extra::sync; +extern mod sync; +use sync::RWLock; fn main() { - let x = ~sync::RWLock::new(); + let x = ~RWLock::new(); let mut y = None; x.write_downgrade(|write_mode| { y = Some(x.downgrade(write_mode)); diff --git a/src/test/compile-fail/sync-rwlock-write-mode-cond-shouldnt-escape.rs b/src/test/compile-fail/sync-rwlock-write-mode-cond-shouldnt-escape.rs index cbe5181d46f24..71a9dd100c395 100644 --- a/src/test/compile-fail/sync-rwlock-write-mode-cond-shouldnt-escape.rs +++ b/src/test/compile-fail/sync-rwlock-write-mode-cond-shouldnt-escape.rs @@ -9,10 +9,10 @@ // except according to those terms. // error-pattern: lifetime of variable does not enclose its declaration -extern mod extra; -use extra::sync; +extern mod sync; +use sync::RWLock; fn main() { - let x = ~sync::RWLock::new(); + let x = ~RWLock::new(); let mut y = None; x.write_downgrade(|write_mode| { (&write_mode).write_cond(|cond| { diff --git a/src/test/compile-fail/sync-rwlock-write-mode-shouldnt-escape.rs b/src/test/compile-fail/sync-rwlock-write-mode-shouldnt-escape.rs index 6e9216830750b..53966bf48a493 100644 --- a/src/test/compile-fail/sync-rwlock-write-mode-shouldnt-escape.rs +++ b/src/test/compile-fail/sync-rwlock-write-mode-shouldnt-escape.rs @@ -9,10 +9,10 @@ // except according to those terms. // error-pattern: lifetime of variable does not enclose its declaration -extern mod extra; -use extra::sync; +extern mod sync; +use sync::RWLock; fn main() { - let x = ~sync::RWLock::new(); + let x = ~RWLock::new(); let mut y = None; x.write_downgrade(|write_mode| { y = Some(write_mode); diff --git a/src/test/run-fail/issue-2444.rs b/src/test/run-fail/issue-2444.rs index c1357988f7db5..16f54e929236a 100644 --- a/src/test/run-fail/issue-2444.rs +++ b/src/test/run-fail/issue-2444.rs @@ -10,10 +10,10 @@ // error-pattern:explicit failure -extern mod extra; -use extra::arc; +extern mod sync; +use sync::Arc; -enum e { e(arc::Arc) } +enum e { e(Arc) } fn foo() -> e {fail!();} diff --git a/src/test/run-pass/bind-by-move.rs b/src/test/run-pass/bind-by-move.rs index a7a4aa9885e6e..3a86357bdaad1 100644 --- a/src/test/run-pass/bind-by-move.rs +++ b/src/test/run-pass/bind-by-move.rs @@ -9,12 +9,12 @@ // except according to those terms. // xfail-fast -extern mod extra; -use extra::arc; -fn dispose(_x: arc::Arc) { } +extern mod sync; +use sync::Arc; +fn dispose(_x: Arc) { } pub fn main() { - let p = arc::Arc::new(true); + let p = Arc::new(true); let x = Some(p); match x { Some(z) => { dispose(z); }, diff --git a/src/test/run-pass/once-move-out-on-heap.rs b/src/test/run-pass/once-move-out-on-heap.rs index bc56712ee3bc1..0ccf7b8f8a3e1 100644 --- a/src/test/run-pass/once-move-out-on-heap.rs +++ b/src/test/run-pass/once-move-out-on-heap.rs @@ -13,15 +13,15 @@ // xfail-fast #[feature(once_fns)]; -extern mod extra; -use extra::arc; +extern mod sync; +use sync::Arc; fn foo(blk: proc()) { blk(); } pub fn main() { - let x = arc::Arc::new(true); + let x = Arc::new(true); foo(proc() { assert!(*x.get()); drop(x); diff --git a/src/test/run-pass/once-move-out-on-stack.rs b/src/test/run-pass/once-move-out-on-stack.rs index 07dd5175a0fae..e732d0c76a663 100644 --- a/src/test/run-pass/once-move-out-on-stack.rs +++ b/src/test/run-pass/once-move-out-on-stack.rs @@ -13,15 +13,15 @@ // xfail-fast #[feature(once_fns)]; -extern mod extra; -use extra::arc; +extern mod sync; +use sync::Arc; fn foo(blk: once ||) { blk(); } pub fn main() { - let x = arc::Arc::new(true); + let x = Arc::new(true); foo(|| { assert!(*x.get()); drop(x); diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs index 2bf18e1ae1d5f..454da6d2aaa07 100644 --- a/src/test/run-pass/trait-bounds-in-arc.rs +++ b/src/test/run-pass/trait-bounds-in-arc.rs @@ -15,9 +15,9 @@ // xfail-fast -extern mod extra; +extern mod sync; -use extra::arc; +use sync::Arc; use std::task; trait Pet { @@ -65,7 +65,7 @@ pub fn main() { let dogge1 = Dogge { bark_decibels: 100, tricks_known: 42, name: ~"alan_turing" }; let dogge2 = Dogge { bark_decibels: 55, tricks_known: 11, name: ~"albert_einstein" }; let fishe = Goldfyshe { swim_speed: 998, name: ~"alec_guinness" }; - let arc = arc::Arc::new(~[~catte as ~Pet:Freeze+Send, + let arc = Arc::new(~[~catte as ~Pet:Freeze+Send, ~dogge1 as ~Pet:Freeze+Send, ~fishe as ~Pet:Freeze+Send, ~dogge2 as ~Pet:Freeze+Send]); @@ -83,21 +83,21 @@ pub fn main() { p3.recv(); } -fn check_legs(arc: arc::Arc<~[~Pet:Freeze+Send]>) { +fn check_legs(arc: Arc<~[~Pet:Freeze+Send]>) { let mut legs = 0; for pet in arc.get().iter() { legs += pet.num_legs(); } assert!(legs == 12); } -fn check_names(arc: arc::Arc<~[~Pet:Freeze+Send]>) { +fn check_names(arc: Arc<~[~Pet:Freeze+Send]>) { for pet in arc.get().iter() { pet.name(|name| { assert!(name[0] == 'a' as u8 && name[1] == 'l' as u8); }) } } -fn check_pedigree(arc: arc::Arc<~[~Pet:Freeze+Send]>) { +fn check_pedigree(arc: Arc<~[~Pet:Freeze+Send]>) { for pet in arc.get().iter() { assert!(pet.of_good_pedigree()); }