use std::io;
use std::os;
use std::str;
-use std::task;
+use std::task::TaskBuilder;
use syntax::ast;
use syntax::diagnostic::Emitter;
use syntax::diagnostic;
#[cfg(not(rtopt))]
static STACK_SIZE: uint = 20000000; // 20MB
- let mut task_builder = task::task().named("rustc");
+ let mut task_builder = TaskBuilder::new().named("rustc");
// FIXME: Hacks on hacks. If the env is trying to override the stack size
// then *don't* set it explicitly.
nocopy: Option<marker::NoCopy>,
}
-/**
- * Generate the base configuration for spawning a task, off of which more
- * configuration methods can be chained.
- */
-pub fn task() -> TaskBuilder {
- TaskBuilder {
- opts: TaskOpts::new(),
- gen_body: None,
- nocopy: None,
+impl TaskBuilder {
+ /// Generate the base configuration for spawning a task, off of which more
+ /// configuration methods can be chained.
+ pub fn new() -> TaskBuilder {
+ TaskBuilder {
+ opts: TaskOpts::new(),
+ gen_body: None,
+ nocopy: None,
+ }
}
-}
-impl TaskBuilder {
/// Get a future representing the exit status of the task.
///
/// Taking the value of the future will block until the child task
/// Sets up a new task with its own call stack and schedules it to run
/// the provided unique closure.
///
-/// This function is equivalent to `task().spawn(f)`.
+/// This function is equivalent to `TaskBuilder::new().spawn(f)`.
pub fn spawn(f: proc():Send) {
- let task = task();
- task.spawn(f)
+ TaskBuilder::new().spawn(f)
}
+/// Execute a function in another task and return either the return value of
+/// the function or an error if the task failed
+///
+/// This is equivalent to TaskBuilder::new().try
pub fn try<T:Send>(f: proc():Send -> T) -> Result<T, ~Any:Send> {
- /*!
- * Execute a function in another task and return either the return value
- * of the function or result::err.
- *
- * This is equivalent to task().try.
- */
-
- let task = task();
- task.try(f)
+ TaskBuilder::new().try(f)
}
#[test]
fn test_owned_named_task() {
- task().named("ada lovelace".to_owned()).spawn(proc() {
+ TaskBuilder::new().named("ada lovelace".to_owned()).spawn(proc() {
with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace");
})
#[test]
fn test_static_named_task() {
- task().named("ada lovelace").spawn(proc() {
+ TaskBuilder::new().named("ada lovelace").spawn(proc() {
with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace");
})
#[test]
fn test_send_named_task() {
- task().named("ada lovelace".into_maybe_owned()).spawn(proc() {
+ TaskBuilder::new().named("ada lovelace".into_maybe_owned()).spawn(proc() {
with_task_name(|name| {
assert!(name.unwrap() == "ada lovelace");
})
#[test]
fn test_run_basic() {
let (tx, rx) = channel();
- task().spawn(proc() {
+ TaskBuilder::new().spawn(proc() {
tx.send(());
});
rx.recv();
#[test]
fn test_with_wrapper() {
let (tx, rx) = channel();
- task().with_wrapper(proc(body) {
+ TaskBuilder::new().with_wrapper(proc(body) {
let result: proc():Send = proc() {
body();
tx.send(());
#[test]
fn test_future_result() {
- let mut builder = task();
+ let mut builder = TaskBuilder::new();
let result = builder.future_result();
builder.spawn(proc() {});
assert!(result.recv().is_ok());
- let mut builder = task();
+ let mut builder = TaskBuilder::new();
let result = builder.future_result();
builder.spawn(proc() {
fail!();
#[test] #[should_fail]
fn test_back_to_the_future_result() {
- let mut builder = task();
+ let mut builder = TaskBuilder::new();
builder.future_result();
builder.future_result();
}
#[test]
fn test_avoid_copying_the_body_task_spawn() {
avoid_copying_the_body(|f| {
- let builder = task();
+ let builder = TaskBuilder::new();
builder.spawn(proc() {
f();
});
fn child_no(x: uint) -> proc():Send {
return proc() {
if x < generations {
- task().spawn(child_no(x+1));
+ TaskBuilder::new().spawn(child_no(x+1));
}
}
}
- task().spawn(child_no(0));
+ TaskBuilder::new().spawn(child_no(0));
}
#[test]
mod tests {
use std::comm::Empty;
use std::task;
+ use std::task::TaskBuilder;
use arc::Arc;
use super::{Mutex, Barrier, RWLock};
let mut children = Vec::new();
for _ in range(0, 5) {
let arc3 = arc.clone();
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
children.push(builder.future_result());
builder.spawn(proc() {
let lock = arc3.read();
use std::os;
use std::str;
use std::strbuf::StrBuf;
-use std::task;
+use std::task::TaskBuilder;
// to be used by rustc to compile tests in libtest
pub mod test {
let mut reader = ChanReader::new(rx);
let stdout = ChanWriter::new(tx.clone());
let stderr = ChanWriter::new(tx);
- let mut task = task::task().named(match desc.name {
+ let mut task = TaskBuilder::new().named(match desc.name {
DynTestName(ref name) => name.clone().into_maybe_owned(),
StaticTestName(name) => name.into_maybe_owned(),
});
use std::comm;
use std::os;
use std::task;
+use std::task::TaskBuilder;
use std::uint;
fn move_out<T>(_x: T) {}
let mut worker_results = Vec::new();
for _ in range(0u, workers) {
let to_child = to_child.clone();
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
worker_results.push(builder.future_result());
builder.spawn(proc() {
for _ in range(0u, size / workers) {
use std::os;
use std::task;
+use std::task::TaskBuilder;
use std::uint;
fn move_out<T>(_x: T) {}
let mut worker_results = Vec::new();
let from_parent = if workers == 1 {
let (to_child, from_parent) = channel();
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
worker_results.push(builder.future_result());
builder.spawn(proc() {
for _ in range(0u, size / workers) {
let (to_child, from_parent) = channel();
for _ in range(0u, workers) {
let to_child = to_child.clone();
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
worker_results.push(builder.future_result());
builder.spawn(proc() {
for _ in range(0u, size / workers) {
use std::os;
use std::result::{Ok, Err};
use std::task;
+use std::task::TaskBuilder;
use std::uint;
fn fib(n: int) -> int {
fn stress(num_tasks: int) {
let mut results = Vec::new();
for i in range(0, num_tasks) {
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
results.push(builder.future_result());
builder.spawn(proc() {
stress_task(i);
// error-pattern:task 'owned name' failed at 'test'
-use std::task;
+use std::task::TaskBuilder;
fn main() {
- task::task().named("owned name".to_owned()).try(proc() {
+ TaskBuilder::new().named("owned name".to_owned()).try(proc() {
fail!("test");
1
}).unwrap()
// error-pattern:task 'send name' failed at 'test'
fn main() {
- ::std::task::task().named("send name".into_maybe_owned()).try(proc() {
+ ::std::task::TaskBuilder::new().named("send name".into_maybe_owned()).try(proc() {
fail!("test");
3
}).unwrap()
// error-pattern:task 'static name' failed at 'test'
fn main() {
- ::std::task::task().named("static name").try(proc() {
+ ::std::task::TaskBuilder::new().named("static name").try(proc() {
fail!("test");
}).unwrap()
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-use std::task;
+use std::task::TaskBuilder;
static generations: uint = 1024+256+128+49;
fn spawn(f: proc():Send) {
- let mut t = task::task();
+ let mut t = TaskBuilder::new();
t.opts.stack_size = Some(32 * 1024);
t.spawn(f);
}
// regression test for issue #10405, make sure we don't call println! too soon.
-use std::task;
+use std::task::TaskBuilder;
pub fn main() {
- let mut t = task::task();
+ let mut t = TaskBuilder::new();
t.spawn(proc() ());
}
// except according to those terms.
use std::task;
+use std::task::TaskBuilder;
pub fn main() { test00(); }
fn test00() {
let i: int = 0;
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
let mut result = builder.future_result();
builder.spawn(proc() {
start(i)
// except according to those terms.
-use std::task;
+use std::task::TaskBuilder;
pub fn main() { println!("===== WITHOUT THREADS ====="); test00(); }
let mut results = Vec::new();
while i < number_of_tasks {
let tx = tx.clone();
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
results.push(builder.future_result());
builder.spawn({
let i = i;
// except according to those terms.
-use std::task;
+use std::task::TaskBuilder;
pub fn main() { test00(); }
let (tx, rx) = channel();
let number_of_messages: int = 10;
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
let result = builder.future_result();
builder.spawn(proc() {
test00_start(&tx, number_of_messages);
use std::io::net::ip::{Ipv4Addr, SocketAddr};
use std::io::net::tcp::{TcpListener, TcpStream};
use std::io::{Acceptor, Listener};
-use std::task;
+use std::task::TaskBuilder;
#[start]
fn start(argc: int, argv: **u8) -> int {
let (tx, rx) = channel();
for _ in range(0, 1000) {
let tx = tx.clone();
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
builder.opts.stack_size = Some(32 * 1024);
builder.spawn(proc() {
match TcpStream::connect(addr) {
// except according to those terms.
use std::task;
+use std::task::TaskBuilder;
pub fn main() {
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
let mut result = builder.future_result();
builder.spawn(child);
println!("1");
// except according to those terms.
use std::task;
+use std::task::TaskBuilder;
pub fn main() {
- let mut builder = task::task();
+ let mut builder = TaskBuilder::new();
let mut result = builder.future_result();
builder.spawn(child);
println!("1");
projects / rust.git / commitdiff