test: fix benchmark unsafe blocks, r=burningtree.

Author: graydon

src/test/bench/shootout-fasta.rs

@@ -64,18 +64,20 @@ fn make_random_fasta(wr: io::Writer, id: ~str, desc: ~str, genelist: ~[aminoacid
     if str::len(op) > 0u { wr.write_line(op); }
 }
 
-fn make_repeat_fasta(wr: io::Writer, id: ~str, desc: ~str, s: ~str, n: int) unsafe {
-    wr.write_line(~">" + id + ~" " + desc);
-    let mut op: ~str = ~"";
-    let sl: uint = str::len(s);
-    for uint::range(0u, n as uint) |i| {
-        str::raw::push_byte(&mut op, s[i % sl]);
-        if str::len(op) >= LINE_LENGTH() {
-            wr.write_line(op);
-            op = ~"";
+fn make_repeat_fasta(wr: io::Writer, id: ~str, desc: ~str, s: ~str, n: int) {
+    unsafe {
+        wr.write_line(~">" + id + ~" " + desc);
+        let mut op: ~str = ~"";
+        let sl: uint = str::len(s);
+        for uint::range(0u, n as uint) |i| {
+            str::raw::push_byte(&mut op, s[i % sl]);
+            if str::len(op) >= LINE_LENGTH() {
+                wr.write_line(op);
+                op = ~"";
+            }
         }
+        if str::len(op) > 0u { wr.write_line(op); }
     }
-    if str::len(op) > 0u { wr.write_line(op); }
 }
 
 fn acid(ch: char, prob: u32) -> aminoacids { return {ch: ch, prob: prob}; }

src/test/bench/shootout-nbody.rs

@@ -98,23 +98,25 @@ mod NBodySystem {
 
     pub fn advance_one(bi: &mut Body::props,
                        bj: &mut Body::props,
-                       dt: float) unsafe {
-        let dx = bi.x - bj.x;
-        let dy = bi.y - bj.y;
-        let dz = bi.z - bj.z;
+                       dt: float) {
+        unsafe {
+            let dx = bi.x - bj.x;
+            let dy = bi.y - bj.y;
+            let dz = bi.z - bj.z;
 
-        let dSquared = dx * dx + dy * dy + dz * dz;
+            let dSquared = dx * dx + dy * dy + dz * dz;
 
-        let distance = ::libc::sqrt(dSquared);
-        let mag = dt / (dSquared * distance);
+            let distance = ::libc::sqrt(dSquared);
+            let mag = dt / (dSquared * distance);
 
-        bi.vx -= dx * bj.mass * mag;
-        bi.vy -= dy * bj.mass * mag;
-        bi.vz -= dz * bj.mass * mag;
+            bi.vx -= dx * bj.mass * mag;
+            bi.vy -= dy * bj.mass * mag;
+            bi.vz -= dz * bj.mass * mag;
 
-        bj.vx += dx * bi.mass * mag;
-        bj.vy += dy * bi.mass * mag;
-        bj.vz += dz * bi.mass * mag;
+            bj.vx += dx * bi.mass * mag;
+            bj.vy += dy * bi.mass * mag;
+            bj.vz += dz * bi.mass * mag;
+        }
     }
 
     pub fn move_(b: &mut Body::props, dt: float) {
@@ -123,36 +125,41 @@ mod NBodySystem {
         b.z += dt * b.vz;
     }
 
-    pub fn energy(bodies: &[Body::props]) -> float unsafe {
-        let mut dx;
-        let mut dy;
-        let mut dz;
-        let mut distance;
-        let mut e = 0.0;
-
-        let mut i = 0;
-        while i < 5 {
-            e +=
-                0.5 * bodies[i].mass *
-                (bodies[i].vx * bodies[i].vx + bodies[i].vy * bodies[i].vy
-                 + bodies[i].vz * bodies[i].vz);
-
-            let mut j = i + 1;
-            while j < 5 {
-                dx = bodies[i].x - bodies[j].x;
-                dy = bodies[i].y - bodies[j].y;
-                dz = bodies[i].z - bodies[j].z;
-
-                distance = ::libc::sqrt(dx * dx + dy * dy + dz * dz);
-                e -= bodies[i].mass * bodies[j].mass / distance;
-
-                j += 1;
+    pub fn energy(bodies: &[Body::props]) -> float {
+        unsafe {
+            let mut dx;
+            let mut dy;
+            let mut dz;
+            let mut distance;
+            let mut e = 0.0;
+
+            let mut i = 0;
+            while i < 5 {
+                e +=
+                    0.5 * bodies[i].mass *
+                    (bodies[i].vx * bodies[i].vx
+                     + bodies[i].vy * bodies[i].vy
+                     + bodies[i].vz * bodies[i].vz);
+
+                let mut j = i + 1;
+                while j < 5 {
+                    dx = bodies[i].x - bodies[j].x;
+                    dy = bodies[i].y - bodies[j].y;
+                    dz = bodies[i].z - bodies[j].z;
+
+                    distance = ::libc::sqrt(dx * dx
+                                            + dy * dy
+                                            + dz * dz);
+                    e -= bodies[i].mass
+                        * bodies[j].mass / distance;
+
+                    j += 1;
+                }
+
+                i += 1;
             }
-
-            i += 1;
+            return e;
         }
-        return e;
-
     }
 }