---

yaml
---
r: 37579
b: refs/heads/try
c: 9b6f025
h: refs/heads/master
i:
  37577: 5b19aad
  37575: 92bd77f
v: v3

Author: catamorphism

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 09bb07bed9166105ea961a42b5fff7739ae0d2e9
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: eb8fd119c65c67f3b1b8268cc7341c22d39b7b61
-refs/heads/try: a0610c952f0d23927443b901241627ae910fd3cd
+refs/heads/try: 9b6f025eb607aab8ea29c2033dcebe1d263ba614
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278

branches/try/src/libstd/std.rc

@@ -54,7 +54,7 @@ pub mod sync;
 pub mod arc;
 pub mod comm;
 pub mod future;
-pub mod thread_pool;
+pub mod task_pool;
 
 // Collections
 

branches/try/src/libstd/thread_pool.rs renamed to branches/try/src/libstd/task_pool.rs

@@ -1,4 +1,4 @@
-/// A thread pool abstraction. Useful for achieving predictable CPU
+/// A task pool abstraction. Useful for achieving predictable CPU
 /// parallelism.
 
 use pipes::{Chan, Port};
@@ -9,7 +9,7 @@ enum Msg<T> {
     Quit
 }
 
-pub struct ThreadPool<T> {
+pub struct TaskPool<T> {
     channels: ~[Chan<Msg<T>>],
     mut next_index: uint,
 
@@ -20,15 +20,15 @@ pub struct ThreadPool<T> {
     }
 }
 
-pub impl<T> ThreadPool<T> {
-    /// Spawns a new thread pool with `n_tasks` tasks. If the `sched_mode`
+pub impl<T> TaskPool<T> {
+    /// Spawns a new task pool with `n_tasks` tasks. If the `sched_mode`
     /// is None, the tasks run on this scheduler; otherwise, they run on a
     /// new scheduler with the given mode. The provided `init_fn_factory`
     /// returns a function which, given the index of the task, should return
     /// local data to be kept around in that task.
     static fn new(n_tasks: uint,
                   opt_sched_mode: Option<SchedMode>,
-                  init_fn_factory: ~fn() -> ~fn(uint) -> T) -> ThreadPool<T> {
+                  init_fn_factory: ~fn() -> ~fn(uint) -> T) -> TaskPool<T> {
         assert n_tasks >= 1;
 
         let channels = do vec::from_fn(n_tasks) |i| {
@@ -59,10 +59,10 @@ pub impl<T> ThreadPool<T> {
             move chan
         };
 
-        return ThreadPool { channels: move channels, next_index: 0 };
+        return TaskPool { channels: move channels, next_index: 0 };
     }
 
-    /// Executes the function `f` on a thread in the pool. The function
+    /// Executes the function `f` on a task in the pool. The function
     /// receives a reference to the local data returned by the `init_fn`.
     fn execute(&self, f: ~fn(&T)) {
         self.channels[self.next_index].send(Execute(move f));
@@ -72,12 +72,12 @@ pub impl<T> ThreadPool<T> {
 }
 
 #[test]
-fn test_thread_pool() {
+fn test_task_pool() {
     let f: ~fn() -> ~fn(uint) -> uint = || {
         let g: ~fn(uint) -> uint = |i| i;
         move g
     };
-    let pool = ThreadPool::new(4, Some(SingleThreaded), move f);
+    let pool = TaskPool::new(4, Some(SingleThreaded), move f);
     for 8.times {
         pool.execute(|i| io::println(fmt!("Hello from thread %u!", *i)));
     }