---

yaml
---
r: 40393
b: refs/heads/dist-snap
c: 9b6f025
h: refs/heads/master
i:
  40391: 8982b21
v: v3

Author: catamorphism

[refs]

@@ -7,7 +7,7 @@ refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: a810c03263670238bccd64cabb12a23a46e3a278
 refs/heads/incoming: e90142e536c150df0d9b4b2f11352152177509b5
-refs/heads/dist-snap: a0610c952f0d23927443b901241627ae910fd3cd
+refs/heads/dist-snap: 9b6f025eb607aab8ea29c2033dcebe1d263ba614
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0

branches/dist-snap/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/dist-snap/src/libstd/thread_pool.rs renamed to branches/dist-snap/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)));
     }