---

yaml
---
r: 96927
b: refs/heads/dist-snap
c: 1a6d920
h: refs/heads/master
i:
  96925: f98adae
  96923: 9f23349
  96919: 6e023e7
  96911: fef29b6
  96895: b1ab6ad
v: v3

Author: alexcrichton

[refs]

@@ -6,7 +6,7 @@ refs/heads/try: c274a6888410ce3e357e014568b43310ed787d36
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c
-refs/heads/dist-snap: 8be66e212b37045b927138965a76abe3608325ca
+refs/heads/dist-snap: 1a6d920e3df3d48168b22879a194538ec10c951a
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/src/libgreen/lib.rs

@@ -115,6 +115,9 @@ pub fn run(main: proc()) -> int {
 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 {
@@ -123,6 +126,7 @@ impl PoolConfig {
     pub fn new() -> PoolConfig {
         PoolConfig {
             threads: rt::default_sched_threads(),
+            event_loop_factory: None,
         }
     }
 }
@@ -138,6 +142,7 @@ pub struct SchedPool {
     priv stack_pool: StackPool,
     priv deque_pool: deque::BufferPool<~task::GreenTask>,
     priv sleepers: SleeperList,
+    priv factory: fn() -> ~rtio::EventLoop,
 }
 
 impl SchedPool {
@@ -148,7 +153,11 @@ 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
@@ -161,6 +170,7 @@ impl SchedPool {
             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
@@ -176,7 +186,7 @@ impl SchedPool {
             rtdebug!("inserting a regular scheduler");
 
             let mut sched = ~Scheduler::new(pool.id,
-                                            new_event_loop(),
+                                            (pool.factory)(),
                                             worker,
                                             pool.stealers.clone(),
                                             pool.sleepers.clone());
@@ -232,7 +242,7 @@ impl SchedPool {
         // 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());
@@ -270,19 +280,19 @@ impl Drop for SchedPool {
     }
 }
 
-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;
 }

branches/dist-snap/src/librustuv/homing.rs

@@ -161,7 +161,10 @@ mod test {
     #[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());
@@ -179,7 +182,10 @@ mod test {
     #[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();

branches/dist-snap/src/librustuv/uvio.rs

@@ -96,7 +96,7 @@ impl rtio::EventLoop for UvEventLoop {
 
 #[cfg(not(test))]
 #[lang = "event_loop_factory"]
-pub extern "C" fn new_loop() -> ~rtio::EventLoop {
+pub fn new_loop() -> ~rtio::EventLoop {
     ~UvEventLoop::new() as ~rtio::EventLoop
 }
 

branches/dist-snap/src/libstd/rt/crate_map.rs

@@ -30,7 +30,7 @@ pub struct CrateMap<'a> {
     version: i32,
     entries: &'a [ModEntry<'a>],
     children: &'a [&'a CrateMap<'a>],
-    event_loop_factory: Option<extern "C" fn() -> ~EventLoop>,
+    event_loop_factory: Option<fn() -> ~EventLoop>,
 }
 
 #[cfg(not(windows))]