Skip to content

Commit 2650487

Browse files
lkupergraydon
lkuper
authored and
graydon
committed
Got the nbody demo working, and hopefully faster, too!
1 parent 1c1c672 commit 2650487

File tree

1 file changed

+112
-106
lines changed

1 file changed

+112
-106
lines changed

‎src/test/bench/shootout/nbody.rs‎

Lines changed: 112 additions & 106 deletions
Original file line numberDiff line numberDiff line change
@@ -4,8 +4,6 @@
44

55
fn main() {
66

7-
log "foo";
8-
97
let vec[int] inputs = vec(
108
50000
119
//these segfault :(
@@ -17,13 +15,12 @@ fn main() {
1715
let vec[Body.props] bodies = NBodySystem.MakeNBodySystem();
1816

1917
for (int n in inputs) {
20-
// TODO: make #fmt handle floats?
2118
log NBodySystem.energy(bodies);
2219

2320
let int i = 0;
2421
while (i < n) {
25-
bodies = NBodySystem.advance(bodies, 0.01);
26-
i = i+1;
22+
NBodySystem.advance(bodies, 0.01);
23+
i += 1;
2724
}
2825
log NBodySystem.energy(bodies);
2926
}
@@ -40,7 +37,6 @@ native "rust" mod rustrt {
4037
mod NBodySystem {
4138

4239
fn MakeNBodySystem() -> vec[Body.props] {
43-
// can't iterate over a record? how about a vector, then?
4440
let vec[Body.props] bodies = vec(
4541
// these each return a Body.props
4642
Body.sun(),
@@ -53,10 +49,13 @@ mod NBodySystem {
5349
let float py = 0.0;
5450
let float pz = 0.0;
5551

56-
for (Body.props body in bodies) {
57-
px += body.vx * body.mass;
58-
py += body.vy * body.mass;
59-
pz += body.vz * body.mass;
52+
let int i = 0;
53+
while (i < 5) {
54+
px += bodies.(i).vx * bodies.(i).mass;
55+
py += bodies.(i).vy * bodies.(i).mass;
56+
pz += bodies.(i).vz * bodies.(i).mass;
57+
58+
i += 1;
6059
}
6160

6261
// side-effecting
@@ -65,39 +64,46 @@ mod NBodySystem {
6564
ret bodies;
6665
}
6766

68-
fn advance(vec[Body.props] bodies, float dt) -> vec[Body.props] {
69-
for (Body.props ibody in bodies) {
67+
fn advance(vec[Body.props] bodies, float dt) -> () {
7068

71-
let Body.props iBody = ibody;
72-
73-
for (Body.props jbody in bodies) {
74-
let float dx = iBody.x - jbody.x;
75-
let float dy = iBody.y - jbody.y;
76-
let float dz = iBody.z - jbody.z;
69+
let int i = 0;
70+
while (i < 5) {
71+
let int j = i+1;
72+
while (j < 5) {
73+
let float dx = bodies.(i).x - bodies.(j).x;
74+
let float dy = bodies.(i).y - bodies.(j).y;
75+
let float dz = bodies.(i).z - bodies.(j).z;
7776

7877
let float dSquared = dx * dx + dy * dy + dz * dz;
7978

8079
let float distance;
8180
rustrt.squareroot(dSquared, distance);
8281
let float mag = dt / (dSquared * distance);
8382

84-
iBody.vx -= dx * jbody.mass * mag;
85-
iBody.vy -= dy * jbody.mass * mag;
86-
iBody.vz -= dz * jbody.mass * mag;
83+
bodies.(i).vx -= dx * bodies.(j).mass * mag;
84+
bodies.(i).vy -= dy * bodies.(j).mass * mag;
85+
bodies.(i).vz -= dz * bodies.(j).mass * mag;
86+
87+
bodies.(j).vx += dx * bodies.(i).mass * mag;
88+
bodies.(j).vy += dy * bodies.(i).mass * mag;
89+
bodies.(j).vz += dz * bodies.(i).mass * mag;
90+
91+
j += 1;
8792

88-
jbody.vx += dx * iBody.mass * mag;
89-
jbody.vy += dy * iBody.mass * mag;
90-
jbody.vz += dz * iBody.mass * mag;
9193
}
92-
}
9394

94-
for (Body.props body in bodies) {
95-
body.x += dt * body.vx;
96-
body.y += dt * body.vy;
97-
body.z += dt * body.vz;
95+
i += 1;
9896
}
9997

100-
ret bodies;
98+
i = 0;
99+
while (i < 5) {
100+
101+
bodies.(i).x += dt * bodies.(i).vx;
102+
bodies.(i).y += dt * bodies.(i).vy;
103+
bodies.(i).z += dt * bodies.(i).vz;
104+
105+
i += 1;
106+
}
101107
}
102108

103109
fn energy(vec[Body.props] bodies) -> float {
@@ -107,110 +113,110 @@ mod NBodySystem {
107113
let float distance;
108114
let float e = 0.0;
109115

110-
for (Body.props ibody in bodies) {
111-
112-
// do we need this?
113-
let Body.props iBody = ibody;
114-
115-
e += 0.5 * iBody.mass *
116-
( iBody.vx * iBody.vx
117-
+ iBody.vy * iBody.vy
118-
+ iBody.vz * iBody.vz );
119-
120-
for (Body.props jbody in bodies) {
121-
122-
// do we need this?
123-
let Body.props jBody = jbody;
124-
125-
dx = iBody.x - jBody.x;
126-
dy = iBody.y - jBody.y;
127-
dz = iBody.z - jBody.z;
116+
let int i = 0;
117+
while (i < 5) {
118+
e += 0.5 * bodies.(i).mass *
119+
( bodies.(i).vx * bodies.(i).vx
120+
+ bodies.(i).vy * bodies.(i).vy
121+
+ bodies.(i).vz * bodies.(i).vz );
122+
123+
let int j = i+1;
124+
while (j < 5) {
125+
dx = bodies.(i).x - bodies.(j).x;
126+
dy = bodies.(i).y - bodies.(j).y;
127+
dz = bodies.(i).z - bodies.(j).z;
128128

129129
rustrt.squareroot(dx*dx + dy*dy + dz*dz, distance);
130-
e -= (iBody.mass * jBody.mass) / distance;
130+
e -= (bodies.(i).mass * bodies.(j).mass) / distance;
131+
132+
j += 1;
131133
}
134+
135+
i += 1;
132136
}
133137
ret e;
134-
}
135138

139+
}
136140
}
137141

138142
mod Body {
139-
140-
const float PI = 3.14;
141-
const float SOLAR_MASS = 39.47; // was 4 * PI * PI originally
143+
144+
const float PI = 3.141592653589793;
145+
const float SOLAR_MASS = 39.478417604357432; // was 4 * PI * PI originally
142146
const float DAYS_PER_YEAR = 365.24;
143147

144-
type props = rec(float x,
145-
float y,
146-
float z,
147-
float vx,
148-
float vy,
149-
float vz,
148+
type props = rec(mutable float x,
149+
mutable float y,
150+
mutable float z,
151+
mutable float vx,
152+
mutable float vy,
153+
mutable float vz,
150154
float mass);
151155

152156
fn jupiter() -> Body.props {
153-
// current limitation of the float lexer: decimal part has to
154-
// fit into a 32-bit int.
155-
156-
let Body.props p;
157-
p.x = 4.84e+00;
158-
p.y = -1.16e+00;
159-
p.z = -1.03e-01;
160-
p.vx = 1.66e-03 * DAYS_PER_YEAR;
161-
p.vy = 7.69e-03 * DAYS_PER_YEAR;
162-
p.vz = -6.90e-05 * DAYS_PER_YEAR;
163-
p.mass = 9.54e-04 * SOLAR_MASS;
164-
ret p;
157+
ret rec(
158+
mutable x = 4.84143144246472090e+00,
159+
mutable y = -1.16032004402742839e+00,
160+
mutable z = -1.03622044471123109e-01,
161+
mutable vx = 1.66007664274403694e-03 * DAYS_PER_YEAR,
162+
mutable vy = 7.69901118419740425e-03 * DAYS_PER_YEAR,
163+
mutable vz = -6.90460016972063023e-05 * DAYS_PER_YEAR,
164+
mass = 9.54791938424326609e-04 * SOLAR_MASS
165+
);
165166
}
166167

167168
fn saturn() -> Body.props {
168-
let Body.props p;
169-
p.x = 8.34e+00;
170-
p.y = 4.12e+00;
171-
p.z = -4.03e-01;
172-
p.vx = -2.76e-03 * DAYS_PER_YEAR;
173-
p.vy = 4.99e-03 * DAYS_PER_YEAR;
174-
p.vz = 2.30e-05 * DAYS_PER_YEAR;
175-
p.mass = 2.85e-04 * SOLAR_MASS;
176-
ret p;
169+
ret rec(
170+
mutable x = 8.34336671824457987e+00,
171+
mutable y = 4.12479856412430479e+00,
172+
mutable z = -4.03523417114321381e-01,
173+
mutable vx = -2.76742510726862411e-03 * DAYS_PER_YEAR,
174+
mutable vy = 4.99852801234917238e-03 * DAYS_PER_YEAR,
175+
mutable vz = 2.30417297573763929e-05 * DAYS_PER_YEAR,
176+
mass = 2.85885980666130812e-04 * SOLAR_MASS
177+
);
177178
}
178179

179180
fn uranus() -> Body.props {
180-
let Body.props p;
181-
p.x = 1.28e+01;
182-
p.y = -1.51e+01;
183-
p.z = -2.23e-01;
184-
p.vx = 2.96e-03 * DAYS_PER_YEAR;
185-
p.vy = 2.37e-03 * DAYS_PER_YEAR;
186-
p.vz = -2.96e-05 * DAYS_PER_YEAR;
187-
p.mass = 4.36e-05 * SOLAR_MASS;
188-
ret p;
181+
ret rec(
182+
mutable x = 1.28943695621391310e+01,
183+
mutable y = -1.51111514016986312e+01,
184+
mutable z = -2.23307578892655734e-01,
185+
mutable vx = 2.96460137564761618e-03 * DAYS_PER_YEAR,
186+
mutable vy = 2.37847173959480950e-03 * DAYS_PER_YEAR,
187+
mutable vz = -2.96589568540237556e-05 * DAYS_PER_YEAR,
188+
mass = 4.36624404335156298e-05 * SOLAR_MASS
189+
);
189190
}
190191

191192
fn neptune() -> Body.props {
192-
let Body.props p;
193-
p.x = 1.53e+01;
194-
p.y = -2.59e+01;
195-
p.z = 1.79e-01;
196-
p.vx = 2.68e-03 * DAYS_PER_YEAR;
197-
p.vy = 1.62e-03 * DAYS_PER_YEAR;
198-
p.vz = -9.51e-05 * DAYS_PER_YEAR;
199-
p.mass = 5.15e-05 * SOLAR_MASS;
200-
ret p;
193+
ret rec(
194+
mutable x = 1.53796971148509165e+01,
195+
mutable y = -2.59193146099879641e+01,
196+
mutable z = 1.79258772950371181e-01,
197+
mutable vx = 2.68067772490389322e-03 * DAYS_PER_YEAR,
198+
mutable vy = 1.62824170038242295e-03 * DAYS_PER_YEAR,
199+
mutable vz = -9.51592254519715870e-05 * DAYS_PER_YEAR,
200+
mass = 5.15138902046611451e-05 * SOLAR_MASS
201+
);
201202
}
202203

203204
fn sun() -> Body.props {
204-
let Body.props p;
205-
p.mass = SOLAR_MASS;
206-
ret p;
205+
ret rec(
206+
mutable x = 0.0,
207+
mutable y = 0.0,
208+
mutable z = 0.0,
209+
mutable vx = 0.0,
210+
mutable vy = 0.0,
211+
mutable vz = 0.0,
212+
mass = SOLAR_MASS
213+
);
207214
}
208215

209-
impure fn offsetMomentum(mutable Body.props props,
210-
float px,
211-
float py,
212-
float pz) -> Body.props {
213-
216+
impure fn offsetMomentum(&Body.props props,
217+
float px,
218+
float py,
219+
float pz) -> () {
214220
props.vx = -px / SOLAR_MASS;
215221
props.vy = -py / SOLAR_MASS;
216222
props.vz = -pz / SOLAR_MASS;

0 commit comments

Comments
 (0)