fn test_sem_runtime_friendly_blocking() {
// Force the runtime to schedule two threads on the same sched_loop.
// When one blocks, it should schedule the other one.
- do task::spawn_sched(task::ManualThreads(1)) {
+ do task::spawn_sched(task::SingleThreaded) {
let s = ~Semaphore::new(1);
let s2 = ~s.clone();
let (p,c) = comm::stream();
SingleThreaded,
/// Tasks are distributed among available CPUs
ThreadPerTask,
- /// Tasks are distributed among a fixed number of OS threads
- ManualThreads(uint),
}
/**
}
}
-#[test]
-#[should_fail]
-#[ignore(cfg(windows))]
-fn test_spawn_sched_no_threads() {
- do spawn_sched(ManualThreads(0u)) { }
-}
-
#[test]
fn test_spawn_sched() {
let (po, ch) = stream::<()>();
task::spawn(child_no(0));
}
-#[test]
-fn test_spawn_thread_on_demand() {
- let (port, chan) = comm::stream();
-
- do spawn_sched(ManualThreads(2)) || {
- unsafe {
- let max_threads = rt::rust_sched_threads();
- assert_eq!(max_threads as int, 2);
- let running_threads = rt::rust_sched_current_nonlazy_threads();
- assert_eq!(running_threads as int, 1);
-
- let (port2, chan2) = comm::stream();
-
- do spawn_sched(CurrentScheduler) || {
- chan2.send(());
- }
-
- let running_threads2 = rt::rust_sched_current_nonlazy_threads();
- assert_eq!(running_threads2 as int, 2);
-
- port2.recv();
- chan.send(());
- }
- }
-
- port.recv();
-}
-
#[test]
fn test_simple_newsched_spawn() {
use rt::test::run_in_newsched_task;
pub fn rust_get_sched_id() -> sched_id;
pub fn rust_new_sched(num_threads: libc::uintptr_t) -> sched_id;
- pub fn rust_sched_threads() -> libc::size_t;
- pub fn rust_sched_current_nonlazy_threads() -> libc::size_t;
pub fn get_task_id() -> task_id;
#[rust_stack]
use task::local_data_priv::{local_get, local_set, OldHandle};
use task::rt::rust_task;
use task::rt;
-use task::{Failure, ManualThreads, PlatformThread, SchedOpts, SingleThreaded};
+use task::{Failure, PlatformThread, SchedOpts, SingleThreaded};
use task::{Success, TaskOpts, TaskResult, ThreadPerTask};
use task::{ExistingScheduler, SchedulerHandle};
use task::unkillable;
ThreadPerTask => {
fail!("ThreadPerTask scheduling mode unimplemented")
}
- ManualThreads(threads) => {
- if threads == 0u {
- fail!("can not create a scheduler with no threads");
- }
- threads
- }
};
unsafe {
target->start(f->f, f->env, NULL);
}
-extern "C" CDECL size_t
-rust_sched_current_nonlazy_threads() {
- rust_task *task = rust_get_current_task();
- return task->sched->number_of_threads();
-}
-
-extern "C" CDECL size_t
-rust_sched_threads() {
- rust_task *task = rust_get_current_task();
- return task->sched->max_number_of_threads();
-}
-
// This is called by an intrinsic on the Rust stack and must run
// entirely in the red zone. Do not call on the C stack.
extern "C" CDECL MUST_CHECK bool
rust_should_log_console
rust_set_environ
rust_unset_sigprocmask
-rust_sched_current_nonlazy_threads
-rust_sched_threads
rust_set_exit_status
rust_start
rust_env_pairs