test: Update all tests with the sync changes

Author: alexcrichton

src/doc/guide-tasks.md

@@ -359,7 +359,7 @@ fn main() {
 
         spawn(proc() {
             let local_arc : Arc<~[f64]> = rx.recv();
-            let task_numbers = local_arc.get();
+            let task_numbers = &*local_arc;
             println!("{}-norm = {}", num, pnorm(task_numbers, num));
         });
     }
@@ -411,7 +411,7 @@ Each task recovers the underlying data by
 # let (tx, rx) = channel();
 # tx.send(numbers_arc.clone());
 # let local_arc : Arc<~[f64]> = rx.recv();
-let task_numbers = local_arc.get();
+let task_numbers = &*local_arc;
 # }
 ~~~
 

src/librustdoc/html/format.rs

@@ -208,8 +208,8 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
         let loc = loc.unwrap();
 
         local_data::get(cache_key, |cache| {
-            let cache = cache.unwrap().get();
-            let abs_root = root(cache, loc.as_slice());
+            let cache = cache.unwrap();
+            let abs_root = root(&**cache, loc.as_slice());
             let rel_root = match path.segments.get(0).name.as_slice() {
                 "self" => Some(~"./"),
                 _ => None,
@@ -241,7 +241,7 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
                 }
             }
 
-            match info(cache) {
+            match info(&**cache) {
                 // This is a documented path, link to it!
                 Some((ref fqp, shortty)) if abs_root.is_some() => {
                     let mut url = abs_root.unwrap();
@@ -301,7 +301,7 @@ impl fmt::Show for clean::Type {
         match *self {
             clean::TyParamBinder(id) | clean::Generic(id) => {
                 local_data::get(cache_key, |cache| {
-                    let m = cache.unwrap().get();
+                    let m = cache.unwrap();
                     f.buf.write(m.typarams.get(&id).as_bytes())
                 })
             }

src/librustdoc/html/render.rs

@@ -1265,7 +1265,7 @@ fn item_trait(w: &mut Writer, it: &clean::Item,
     }
 
     local_data::get(cache_key, |cache| {
-        let cache = cache.unwrap().get();
+        let cache = cache.unwrap();
         match cache.implementors.find(&it.id) {
             Some(implementors) => {
                 try!(write!(w, "
@@ -1496,7 +1496,7 @@ fn render_struct(w: &mut Writer, it: &clean::Item,
 
 fn render_methods(w: &mut Writer, it: &clean::Item) -> fmt::Result {
     local_data::get(cache_key, |cache| {
-        let c = cache.unwrap().get();
+        let c = cache.unwrap();
         match c.impls.find(&it.id) {
             Some(v) => {
                 let mut non_trait = v.iter().filter(|p| {
@@ -1576,7 +1576,7 @@ fn render_impl(w: &mut Writer, i: &clean::Impl,
             Some(id) => id,
         };
         try!(local_data::get(cache_key, |cache| {
-            let cache = cache.unwrap().get();
+            let cache = cache.unwrap();
             match cache.traits.find(&trait_id) {
                 Some(t) => {
                     let name = meth.name.clone();
@@ -1606,7 +1606,7 @@ fn render_impl(w: &mut Writer, i: &clean::Impl,
         None => {}
         Some(id) => {
             try!(local_data::get(cache_key, |cache| {
-                let cache = cache.unwrap().get();
+                let cache = cache.unwrap();
                 match cache.traits.find(&id) {
                     Some(t) => {
                         for method in t.methods.iter() {

src/libworkcache/lib.rs

@@ -26,7 +26,7 @@ extern crate sync;
 use serialize::json;
 use serialize::json::ToJson;
 use serialize::{Encoder, Encodable, Decoder, Decodable};
-use sync::{Arc,RWArc};
+use sync::{Arc, RWLock};
 use collections::TreeMap;
 use std::str;
 use std::io;
@@ -225,7 +225,7 @@ pub type FreshnessMap = TreeMap<~str,extern fn(&str,&str)->bool>;
 
 #[deriving(Clone)]
 pub struct Context {
-    db: RWArc<Database>,
+    db: Arc<RWLock<Database>>,
     priv cfg: Arc<json::Object>,
     /// Map from kinds (source, exe, url, etc.) to a freshness function.
     /// The freshness function takes a name (e.g. file path) and value
@@ -269,12 +269,12 @@ fn json_decode<T:Decodable<json::Decoder>>(s: &str) -> T {
 
 impl Context {
 
-    pub fn new(db: RWArc<Database>,
+    pub fn new(db: Arc<RWLock<Database>>,
                cfg: Arc<json::Object>) -> Context {
         Context::new_with_freshness(db, cfg, Arc::new(TreeMap::new()))
     }
 
-    pub fn new_with_freshness(db: RWArc<Database>,
+    pub fn new_with_freshness(db: Arc<RWLock<Database>>,
                               cfg: Arc<json::Object>,
                               freshness: Arc<FreshnessMap>) -> Context {
         Context {
@@ -364,7 +364,7 @@ impl<'a> Prep<'a> {
     fn is_fresh(&self, cat: &str, kind: &str,
                 name: &str, val: &str) -> bool {
         let k = kind.to_owned();
-        let f = self.ctxt.freshness.get().find(&k);
+        let f = self.ctxt.freshness.deref().find(&k);
         debug!("freshness for: {}/{}/{}/{}", cat, kind, name, val)
         let fresh = match f {
             None => fail!("missing freshness-function for '{}'", kind),
@@ -406,9 +406,10 @@ impl<'a> Prep<'a> {
 
         debug!("exec_work: looking up {} and {:?}", self.fn_name,
                self.declared_inputs);
-        let cached = self.ctxt.db.read(|db| {
-            db.prepare(self.fn_name, &self.declared_inputs)
-        });
+        let cached = {
+            let db = self.ctxt.db.deref().read();
+            db.deref().prepare(self.fn_name, &self.declared_inputs)
+        };
 
         match cached {
             Some((ref disc_in, ref disc_out, ref res))
@@ -460,13 +461,12 @@ impl<'a, T:Send +
             WorkFromTask(prep, port) => {
                 let (exe, v) = port.recv();
                 let s = json_encode(&v);
-                prep.ctxt.db.write(|db| {
-                    db.cache(prep.fn_name,
-                             &prep.declared_inputs,
-                             &exe.discovered_inputs,
-                             &exe.discovered_outputs,
-                             s)
-                });
+                let mut db = prep.ctxt.db.deref().write();
+                db.deref_mut().cache(prep.fn_name,
+                                     &prep.declared_inputs,
+                                     &exe.discovered_inputs,
+                                     &exe.discovered_outputs,
+                                     s);
                 v
             }
         }
@@ -496,7 +496,7 @@ fn test() {
 
     let db_path = make_path(~"db.json");
 
-    let cx = Context::new(RWArc::new(Database::new(db_path)),
+    let cx = Context::new(Arc::new(RWLock::new(Database::new(db_path))),
                           Arc::new(TreeMap::new()));
 
     let s = cx.with_prep("test1", |prep| {

src/test/bench/msgsend-ring-mutex-arcs.rs

@@ -18,36 +18,28 @@
 extern crate sync;
 extern crate time;
 
-use sync::Arc;
-use sync::MutexArc;
-use sync::Future;
+use sync::{Arc, Future, Mutex};
 use std::os;
 use std::uint;
 
 // A poor man's pipe.
-type pipe = MutexArc<Vec<uint> >;
+type pipe = Arc<Mutex<Vec<uint>>>;
 
 fn send(p: &pipe, msg: uint) {
-    unsafe {
-        p.access_cond(|state, cond| {
-            state.push(msg);
-            cond.signal();
-        })
-    }
+    let mut arr = p.lock();
+    arr.push(msg);
+    arr.cond.signal();
 }
 fn recv(p: &pipe) -> uint {
-    unsafe {
-        p.access_cond(|state, cond| {
-            while state.is_empty() {
-                cond.wait();
-            }
-            state.pop().unwrap()
-        })
+    let mut arr = p.lock();
+    while arr.is_empty() {
+        arr.cond.wait();
     }
+    arr.pop().unwrap()
 }
 
 fn init() -> (pipe,pipe) {
-    let m = MutexArc::new(Vec::new());
+    let m = Arc::new(Mutex::new(Vec::new()));
     ((&m).clone(), m)
 }
 

src/test/bench/msgsend-ring-rw-arcs.rs

@@ -18,31 +18,29 @@
 extern crate sync;
 extern crate time;
 
-use sync::RWArc;
+use sync::{RWLock, Arc};
 use sync::Future;
 use std::os;
 use std::uint;
 
 // A poor man's pipe.
-type pipe = RWArc<Vec<uint> >;
+type pipe = Arc<RWLock<Vec<uint>>>;
 
 fn send(p: &pipe, msg: uint) {
-    p.write_cond(|state, cond| {
-        state.push(msg);
-        cond.signal();
-    })
+    let mut arr = p.write();
+    arr.push(msg);
+    arr.cond.signal();
 }
 fn recv(p: &pipe) -> uint {
-    p.write_cond(|state, cond| {
-        while state.is_empty() {
-            cond.wait();
-        }
-        state.pop().unwrap()
-    })
+    let mut arr = p.write();
+    while arr.is_empty() {
+        arr.cond.wait();
+    }
+    arr.pop().unwrap()
 }
 
 fn init() -> (pipe,pipe) {
-    let x = RWArc::new(Vec::new());
+    let x = Arc::new(RWLock::new(Vec::new()));
     ((&x).clone(), x)
 }
 

src/test/bench/shootout-spectralnorm.rs

@@ -14,7 +14,8 @@ use std::from_str::FromStr;
 use std::iter::count;
 use std::cmp::min;
 use std::os;
-use sync::RWArc;
+use std::slice::from_elem;
+use sync::{Arc, RWLock};
 
 fn A(i: uint, j: uint) -> f64 {
     ((i + j) * (i + j + 1) / 2 + i + 1) as f64
@@ -28,17 +29,16 @@ fn dot(v: &[f64], u: &[f64]) -> f64 {
     sum
 }
 
-fn mult(v: RWArc<Vec<f64>>,
-        out: RWArc<Vec<f64>>,
+fn mult(v: Arc<RWLock<Vec<f64>>>, out: Arc<RWLock<Vec<f64>>>,
         f: fn(&Vec<f64>, uint) -> f64) {
-    // We launch in different tasks the work to be done.  To finish
+    // We lanch in different tasks the work to be done.  To finish
     // this fuction, we need to wait for the completion of every
     // tasks.  To do that, we give to each tasks a wait_chan that we
     // drop at the end of the work.  At the end of this function, we
     // wait until the channel hang up.
     let (tx, rx) = channel();
 
-    let len = out.read(|out| out.len());
+    let len = out.read().len();
     let chunk = len / 100 + 1;
     for chk in count(0, chunk) {
         if chk >= len {break;}
@@ -47,8 +47,8 @@ fn mult(v: RWArc<Vec<f64>>,
         let out = out.clone();
         spawn(proc() {
             for i in range(chk, min(len, chk + chunk)) {
-                let val = v.read(|v| f(v, i));
-                out.write(|out| *out.get_mut(i) = val);
+                let val = f(&*v.read(), i);
+                *out.write().get_mut(i) = val;
             }
             drop(tx)
         });
@@ -67,7 +67,7 @@ fn mult_Av_impl(v: &Vec<f64> , i: uint) -> f64 {
     sum
 }
 
-fn mult_Av(v: RWArc<Vec<f64> >, out: RWArc<Vec<f64> >) {
+fn mult_Av(v: Arc<RWLock<Vec<f64>>>, out: Arc<RWLock<Vec<f64>>>) {
     mult(v, out, mult_Av_impl);
 }
 
@@ -79,11 +79,12 @@ fn mult_Atv_impl(v: &Vec<f64> , i: uint) -> f64 {
     sum
 }
 
-fn mult_Atv(v: RWArc<Vec<f64> >, out: RWArc<Vec<f64> >) {
+fn mult_Atv(v: Arc<RWLock<Vec<f64>>>, out: Arc<RWLock<Vec<f64>>>) {
     mult(v, out, mult_Atv_impl);
 }
 
-fn mult_AtAv(v: RWArc<Vec<f64> >, out: RWArc<Vec<f64> >, tmp: RWArc<Vec<f64> >) {
+fn mult_AtAv(v: Arc<RWLock<Vec<f64>>>, out: Arc<RWLock<Vec<f64>>>,
+             tmp: Arc<RWLock<Vec<f64>>>) {
     mult_Av(v, tmp.clone());
     mult_Atv(tmp, out);
 }
@@ -97,16 +98,16 @@ fn main() {
     } else {
         FromStr::from_str(args[1]).unwrap()
     };
-    let u = RWArc::new(Vec::from_elem(n, 1.));
-    let v = RWArc::new(Vec::from_elem(n, 1.));
-    let tmp = RWArc::new(Vec::from_elem(n, 1.));
+    let u = Arc::new(RWLock::new(Vec::from_elem(n, 1.)));
+    let v = Arc::new(RWLock::new(Vec::from_elem(n, 1.)));
+    let tmp = Arc::new(RWLock::new(Vec::from_elem(n, 1.)));
     for _ in range(0, 10) {
         mult_AtAv(u.clone(), v.clone(), tmp.clone());
         mult_AtAv(v.clone(), u.clone(), tmp.clone());
     }
 
-    u.read(|u| v.read(|v| {
-        println!("{:.9f}",
-                 (dot(u.as_slice(), v.as_slice()) / dot(v.as_slice(), v.as_slice())).sqrt());
-    }))
+    let u = u.read();
+    let v = v.read();
+    println!("{:.9f}", (dot(u.as_slice(), v.as_slice()) /
+                        dot(v.as_slice(), v.as_slice())).sqrt());
 }