pub struct PoolConfig {
/// The number of schedulers (OS threads) to spawn into this M:N pool.
threads: uint,
+ /// A factory function used to create new event loops. If this is not
+ /// specified then the default event loop factory is used.
+ event_loop_factory: Option<fn() -> ~rtio::EventLoop>,
}
impl PoolConfig {
pub fn new() -> PoolConfig {
PoolConfig {
threads: rt::default_sched_threads(),
+ event_loop_factory: None,
}
}
}
priv stack_pool: StackPool,
priv deque_pool: deque::BufferPool<~task::GreenTask>,
priv sleepers: SleeperList,
+ priv factory: fn() -> ~rtio::EventLoop,
}
impl SchedPool {
pub fn new(config: PoolConfig) -> SchedPool {
static mut POOL_ID: AtomicUint = INIT_ATOMIC_UINT;
- let PoolConfig { threads: nscheds } = config;
+ let PoolConfig {
+ threads: nscheds,
+ event_loop_factory: factory
+ } = config;
+ let factory = factory.unwrap_or(default_event_loop_factory());
assert!(nscheds > 0);
// The pool of schedulers that will be returned from this function
stack_pool: StackPool::new(),
deque_pool: deque::BufferPool::new(),
next_friend: 0,
+ factory: factory,
};
// Create a work queue for each scheduler, ntimes. Create an extra
rtdebug!("inserting a regular scheduler");
let mut sched = ~Scheduler::new(pool.id,
- new_event_loop(),
+ (pool.factory)(),
worker,
pool.stealers.clone(),
pool.sleepers.clone());
// other schedulers as well as having a stealer handle to all other
// schedulers.
let mut sched = ~Scheduler::new(self.id,
- new_event_loop(),
+ (self.factory)(),
worker,
self.stealers.clone(),
self.sleepers.clone());
}
}
-fn new_event_loop() -> ~rtio::EventLoop {
+fn default_event_loop_factory() -> fn() -> ~rtio::EventLoop {
match crate_map::get_crate_map() {
None => {}
Some(map) => {
match map.event_loop_factory {
None => {}
- Some(factory) => return factory()
+ Some(factory) => return factory
}
}
}
// If the crate map didn't specify a factory to create an event loop, then
// instead just use a basic event loop missing all I/O services to at least
// get the scheduler running.
- return basic::event_loop();
+ return basic::event_loop;
}
#[test]
fn test_homing_closes_correctly() {
let (port, chan) = Chan::new();
- let mut pool = SchedPool::new(PoolConfig { threads: 1 });
+ let mut pool = SchedPool::new(PoolConfig {
+ threads: 1,
+ event_loop_factory: None,
+ });
do pool.spawn(TaskOpts::new()) {
let listener = UdpWatcher::bind(local_loop(), next_test_ip4());
#[test]
fn test_homing_read() {
let (port, chan) = Chan::new();
- let mut pool = SchedPool::new(PoolConfig { threads: 1 });
+ let mut pool = SchedPool::new(PoolConfig {
+ threads: 1,
+ event_loop_factory: None,
+ });
do pool.spawn(TaskOpts::new()) {
let addr1 = next_test_ip4();