|
| 1 | +// Code adopted from https://benchmarksgame-team.pages.debian.net/benchmarksgame/program/nbody-rust-1.html |
| 2 | + |
| 3 | +#![feature(core_intrinsics, lang_items)] |
| 4 | +#![no_std] |
| 5 | + |
| 6 | +#[lang = "panic_fmt"] |
| 7 | +extern "C" fn panic_fmt(_args: ::core::fmt::Arguments, _file: &'static str, _line: u32) -> ! { |
| 8 | + use core::intrinsics; |
| 9 | + unsafe { |
| 10 | + intrinsics::abort(); |
| 11 | + } |
| 12 | +} |
| 13 | + |
| 14 | +#[inline(always)] |
| 15 | +fn sqrt(x: f64) -> f64 { |
| 16 | + use core::intrinsics; |
| 17 | + unsafe { |
| 18 | + intrinsics::sqrtf64(x) |
| 19 | + } |
| 20 | +} |
| 21 | + |
| 22 | +const PI: f64 = 3.141592653589793; |
| 23 | +const SOLAR_MASS: f64 = 4.0 * PI * PI; |
| 24 | +const YEAR: f64 = 365.24; |
| 25 | +const N_BODIES: usize = 5; |
| 26 | + |
| 27 | +static mut BODIES: [Planet; N_BODIES] = [ |
| 28 | + // Sun |
| 29 | + Planet { |
| 30 | + x: 0.0, |
| 31 | + y: 0.0, |
| 32 | + z: 0.0, |
| 33 | + vx: 0.0, |
| 34 | + vy: 0.0, |
| 35 | + vz: 0.0, |
| 36 | + mass: SOLAR_MASS, |
| 37 | + }, |
| 38 | + // Jupiter |
| 39 | + Planet { |
| 40 | + x: 4.84143144246472090e+00, |
| 41 | + y: -1.16032004402742839e+00, |
| 42 | + z: -1.03622044471123109e-01, |
| 43 | + vx: 1.66007664274403694e-03 * YEAR, |
| 44 | + vy: 7.69901118419740425e-03 * YEAR, |
| 45 | + vz: -6.90460016972063023e-05 * YEAR, |
| 46 | + mass: 9.54791938424326609e-04 * SOLAR_MASS, |
| 47 | + }, |
| 48 | + // Saturn |
| 49 | + Planet { |
| 50 | + x: 8.34336671824457987e+00, |
| 51 | + y: 4.12479856412430479e+00, |
| 52 | + z: -4.03523417114321381e-01, |
| 53 | + vx: -2.76742510726862411e-03 * YEAR, |
| 54 | + vy: 4.99852801234917238e-03 * YEAR, |
| 55 | + vz: 2.30417297573763929e-05 * YEAR, |
| 56 | + mass: 2.85885980666130812e-04 * SOLAR_MASS, |
| 57 | + }, |
| 58 | + // Uranus |
| 59 | + Planet { |
| 60 | + x: 1.28943695621391310e+01, |
| 61 | + y: -1.51111514016986312e+01, |
| 62 | + z: -2.23307578892655734e-01, |
| 63 | + vx: 2.96460137564761618e-03 * YEAR, |
| 64 | + vy: 2.37847173959480950e-03 * YEAR, |
| 65 | + vz: -2.96589568540237556e-05 * YEAR, |
| 66 | + mass: 4.36624404335156298e-05 * SOLAR_MASS, |
| 67 | + }, |
| 68 | + // Neptune |
| 69 | + Planet { |
| 70 | + x: 1.53796971148509165e+01, |
| 71 | + y: -2.59193146099879641e+01, |
| 72 | + z: 1.79258772950371181e-01, |
| 73 | + vx: 2.68067772490389322e-03 * YEAR, |
| 74 | + vy: 1.62824170038242295e-03 * YEAR, |
| 75 | + vz: -9.51592254519715870e-05 * YEAR, |
| 76 | + mass: 5.15138902046611451e-05 * SOLAR_MASS, |
| 77 | + }, |
| 78 | +]; |
| 79 | + |
| 80 | +#[derive(Clone, Copy)] |
| 81 | +struct Planet { |
| 82 | + x: f64, |
| 83 | + y: f64, |
| 84 | + z: f64, |
| 85 | + vx: f64, |
| 86 | + vy: f64, |
| 87 | + vz: f64, |
| 88 | + mass: f64, |
| 89 | +} |
| 90 | + |
| 91 | +fn advance(bodies: &mut [Planet; N_BODIES], dt: f64) { |
| 92 | + let mut b_slice: &mut [_] = bodies; |
| 93 | + loop { |
| 94 | + let bi = match shift_mut_ref(&mut b_slice) { |
| 95 | + Some(bi) => bi, |
| 96 | + None => break, |
| 97 | + }; |
| 98 | + |
| 99 | + for bj in b_slice.iter_mut() { |
| 100 | + let dx = bi.x - bj.x; |
| 101 | + let dy = bi.y - bj.y; |
| 102 | + let dz = bi.z - bj.z; |
| 103 | + |
| 104 | + let d2 = dx * dx + dy * dy + dz * dz; |
| 105 | + let mag = dt / (d2 * sqrt(d2)); |
| 106 | + |
| 107 | + let massj_mag = bj.mass * mag; |
| 108 | + bi.vx -= dx * massj_mag; |
| 109 | + bi.vy -= dy * massj_mag; |
| 110 | + bi.vz -= dz * massj_mag; |
| 111 | + |
| 112 | + let massi_mag = bi.mass * mag; |
| 113 | + bj.vx += dx * massi_mag; |
| 114 | + bj.vy += dy * massi_mag; |
| 115 | + bj.vz += dz * massi_mag; |
| 116 | + } |
| 117 | + bi.x += dt * bi.vx; |
| 118 | + bi.y += dt * bi.vy; |
| 119 | + bi.z += dt * bi.vz; |
| 120 | + } |
| 121 | +} |
| 122 | + |
| 123 | +fn energy(bodies: &[Planet; N_BODIES]) -> f64 { |
| 124 | + let mut e = 0.0; |
| 125 | + let mut bodies = bodies.iter(); |
| 126 | + |
| 127 | + loop { |
| 128 | + let bi = match bodies.next() { |
| 129 | + Some(bi) => bi, |
| 130 | + None => break, |
| 131 | + }; |
| 132 | + |
| 133 | + e += (bi.vx * bi.vx + bi.vy * bi.vy + bi.vz * bi.vz) * bi.mass / 2.0; |
| 134 | + for bj in bodies.clone() { |
| 135 | + let dx = bi.x - bj.x; |
| 136 | + let dy = bi.y - bj.y; |
| 137 | + let dz = bi.z - bj.z; |
| 138 | + let dist = sqrt(dx * dx + dy * dy + dz * dz); |
| 139 | + e -= bi.mass * bj.mass / dist; |
| 140 | + } |
| 141 | + } |
| 142 | + e |
| 143 | +} |
| 144 | + |
| 145 | +fn offset_momentum(bodies: &mut [Planet; N_BODIES]) { |
| 146 | + let mut px = 0.0; |
| 147 | + let mut py = 0.0; |
| 148 | + let mut pz = 0.0; |
| 149 | + for bi in bodies.iter() { |
| 150 | + px += bi.vx * bi.mass; |
| 151 | + py += bi.vy * bi.mass; |
| 152 | + pz += bi.vz * bi.mass; |
| 153 | + } |
| 154 | + let sun = &mut bodies[0]; |
| 155 | + sun.vx = -px / SOLAR_MASS; |
| 156 | + sun.vy = -py / SOLAR_MASS; |
| 157 | + sun.vz = -pz / SOLAR_MASS; |
| 158 | +} |
| 159 | + |
| 160 | +#[no_mangle] |
| 161 | +pub unsafe extern "C" fn init() { |
| 162 | + offset_momentum(&mut BODIES); |
| 163 | +} |
| 164 | + |
| 165 | +#[no_mangle] |
| 166 | +pub unsafe extern "C" fn step() -> f64 { |
| 167 | + advance(&mut BODIES, 0.01); |
| 168 | + energy(&BODIES) |
| 169 | +} |
| 170 | + |
| 171 | +#[no_mangle] |
| 172 | +pub unsafe extern "C" fn bench(steps: i32) { |
| 173 | + for _ in 0..steps { |
| 174 | + advance(&mut BODIES, 0.01); |
| 175 | + } |
| 176 | +} |
| 177 | + |
| 178 | +/// Pop a mutable reference off the head of a slice, mutating the slice to no |
| 179 | +/// longer contain the mutable reference. |
| 180 | +fn shift_mut_ref<'a, T>(r: &mut &'a mut [T]) -> Option<&'a mut T> { |
| 181 | + if r.len() == 0 { |
| 182 | + return None; |
| 183 | + } |
| 184 | + let tmp = core::mem::replace(r, &mut []); |
| 185 | + let (h, t) = tmp.split_at_mut(1); |
| 186 | + *r = t; |
| 187 | + Some(&mut h[0]) |
| 188 | +} |
0 commit comments