diff --git a/src/proxy.c b/src/proxy.c
index 7d2e546bf945ca18c2195ea2801d1b2058cb2f58..f58847988946c347367a0f172048f8cc96f26914 100644
--- a/src/proxy.c
+++ b/src/proxy.c
@@ -50,11 +50,9 @@ void proxy_cells_exch1(struct proxy *p) {
#ifdef WITH_MPI
- int k, ind;
-
/* Get the number of pcells we will need to send. */
p->size_pcells_out = 0;
- for (k = 0; k < p->nr_cells_out; k++)
+ for (int k = 0; k < p->nr_cells_out; k++)
p->size_pcells_out += p->cells_out[k]->pcell_size;
/* Send the number of pcells. */
@@ -70,7 +68,7 @@ void proxy_cells_exch1(struct proxy *p) {
if ((p->pcells_out = malloc(sizeof(struct pcell) * p->size_pcells_out)) ==
NULL)
error("Failed to allocate pcell_out buffer.");
- for (ind = 0, k = 0; k < p->nr_cells_out; k++) {
+ for (int ind = 0, k = 0; k < p->nr_cells_out; k++) {
memcpy(&p->pcells_out[ind], p->cells_out[k]->pcell,
sizeof(struct pcell) * p->cells_out[k]->pcell_size);
ind += p->cells_out[k]->pcell_size;
@@ -131,16 +129,14 @@ void proxy_cells_exch2(struct proxy *p) {
void proxy_addcell_in(struct proxy *p, struct cell *c) {
- int k;
- struct cell **temp;
-
/* Check if the cell is already registered with the proxy. */
- for (k = 0; k < p->nr_cells_in; k++)
+ for (int k = 0; k < p->nr_cells_in; k++)
if (p->cells_in[k] == c) return;
/* Do we need to grow the number of in cells? */
if (p->nr_cells_in == p->size_cells_in) {
p->size_cells_in *= proxy_buffgrow;
+ struct cell **temp;
if ((temp = malloc(sizeof(struct cell *) * p->size_cells_in)) == NULL)
error("Failed to allocate incoming cell list.");
memcpy(temp, p->cells_in, sizeof(struct cell *) * p->nr_cells_in);
@@ -162,16 +158,14 @@ void proxy_addcell_in(struct proxy *p, struct cell *c) {
void proxy_addcell_out(struct proxy *p, struct cell *c) {
- int k;
- struct cell **temp;
-
/* Check if the cell is already registered with the proxy. */
- for (k = 0; k < p->nr_cells_out; k++)
+ for (int k = 0; k < p->nr_cells_out; k++)
if (p->cells_out[k] == c) return;
/* Do we need to grow the number of out cells? */
if (p->nr_cells_out == p->size_cells_out) {
p->size_cells_out *= proxy_buffgrow;
+ struct cell **temp;
if ((temp = malloc(sizeof(struct cell *) * p->size_cells_out)) == NULL)
error("Failed to allocate outgoing cell list.");
memcpy(temp, p->cells_out, sizeof(struct cell *) * p->nr_cells_out);
@@ -278,8 +272,8 @@ void proxy_parts_exch2(struct proxy *p) {
* @param N The number of parts.
*/
-void proxy_parts_load(struct proxy *p, struct part *parts, struct xpart *xparts,
- int N) {
+void proxy_parts_load(struct proxy *p, const struct part *parts,
+ const struct xpart *xparts, int N) {
/* Is there enough space in the buffer? */
if (p->nr_parts_out + N > p->size_parts_out) {
diff --git a/src/proxy.h b/src/proxy.h
index 3cd33e0f0819ee1ecac53213630445b39c809dea..1a0272dd6c948df0130f733bb573477eeff1d0db 100644
--- a/src/proxy.h
+++ b/src/proxy.h
@@ -68,8 +68,8 @@ struct proxy {
/* Function prototypes. */
void proxy_init(struct proxy *p, int mynodeID, int nodeID);
-void proxy_parts_load(struct proxy *p, struct part *parts, struct xpart *xparts,
- int N);
+void proxy_parts_load(struct proxy *p, const struct part *parts,
+ const struct xpart *xparts, int N);
void proxy_parts_exch1(struct proxy *p);
void proxy_parts_exch2(struct proxy *p);
void proxy_addcell_in(struct proxy *p, struct cell *c);
diff --git a/src/scheduler.c b/src/scheduler.c
index 722e344b5a86b5fbdc42c7038fd3cb00e44b2ee8..029e0321aefdda3f30ecd33a42a666ed22dee706 100644
--- a/src/scheduler.c
+++ b/src/scheduler.c
@@ -95,32 +95,29 @@ void scheduler_addunlock(struct scheduler *s, struct task *ta,
void scheduler_splittasks(struct scheduler *s) {
- int j, k, ind, sid, tid = 0, redo;
- struct cell *ci, *cj;
- double hi, hj, shift[3];
- struct task *t, *t_old;
- // float dt_step = s->dt_step;
- int pts[7][8] = {{-1, 12, 10, 9, 4, 3, 1, 0},
- {-1, -1, 11, 10, 5, 4, 2, 1},
- {-1, -1, -1, 12, 7, 6, 4, 3},
- {-1, -1, -1, -1, 8, 7, 5, 4},
- {-1, -1, -1, -1, -1, 12, 10, 9},
- {-1, -1, -1, -1, -1, -1, 11, 10},
- {-1, -1, -1, -1, -1, -1, -1, 12}};
- float sid_scale[13] = {0.1897, 0.4025, 0.1897, 0.4025, 0.5788, 0.4025, 0.1897,
- 0.4025, 0.1897, 0.4025, 0.5788, 0.4025, 0.5788};
+ const int pts[7][8] = {{-1, 12, 10, 9, 4, 3, 1, 0},
+ {-1, -1, 11, 10, 5, 4, 2, 1},
+ {-1, -1, -1, 12, 7, 6, 4, 3},
+ {-1, -1, -1, -1, 8, 7, 5, 4},
+ {-1, -1, -1, -1, -1, 12, 10, 9},
+ {-1, -1, -1, -1, -1, -1, 11, 10},
+ {-1, -1, -1, -1, -1, -1, -1, 12}};
+ const float sid_scale[13] = {0.1897, 0.4025, 0.1897, 0.4025, 0.5788,
+ 0.4025, 0.1897, 0.4025, 0.1897, 0.4025,
+ 0.5788, 0.4025, 0.5788};
/* Loop through the tasks... */
- redo = 0;
- t_old = t = NULL;
+ int tid = 0, redo = 0;
+ struct task *t_old = NULL;
while (1) {
/* Get a pointer on the task. */
+ struct task *t = t_old;
if (redo) {
redo = 0;
- t = t_old;
} else {
- if ((ind = atomic_inc(&tid)) < s->nr_tasks)
+ const int ind = atomic_inc(&tid);
+ if (ind < s->nr_tasks)
t_old = t = &s->tasks[s->tasks_ind[ind]];
else
break;
@@ -161,7 +158,7 @@ void scheduler_splittasks(struct scheduler *s) {
if (t->type == task_type_self) {
/* Get a handle on the cell involved. */
- ci = t->ci;
+ struct cell *ci = t->ci;
/* Foreign task? */
if (ci->nodeID != s->nodeID) {
@@ -187,18 +184,18 @@ void scheduler_splittasks(struct scheduler *s) {
redo = 1;
/* Add the self task. */
- for (k = 0; ci->progeny[k] == NULL; k++)
- ;
- t->ci = ci->progeny[k];
- for (k += 1; k < 8; k++)
+ int first_child = 0;
+ while (ci->progeny[first_child] == NULL) first_child++;
+ t->ci = ci->progeny[first_child];
+ for (int k = first_child + 1; k < 8; k++)
if (ci->progeny[k] != NULL)
scheduler_addtask(s, task_type_self, t->subtype, 0, 0,
ci->progeny[k], NULL, 0);
/* Make a task for each pair of progeny. */
- for (j = 0; j < 8; j++)
+ for (int j = 0; j < 8; j++)
if (ci->progeny[j] != NULL)
- for (k = j + 1; k < 8; k++)
+ for (int k = j + 1; k < 8; k++)
if (ci->progeny[k] != NULL)
scheduler_addtask(s, task_type_pair, t->subtype, pts[j][k], 0,
ci->progeny[j], ci->progeny[k], 0);
@@ -211,10 +208,10 @@ void scheduler_splittasks(struct scheduler *s) {
else if (t->type == task_type_pair) {
/* Get a handle on the cells involved. */
- ci = t->ci;
- cj = t->cj;
- hi = ci->dmin;
- hj = cj->dmin;
+ struct cell *ci = t->ci;
+ struct cell *cj = t->cj;
+ const double hi = ci->dmin;
+ const double hj = cj->dmin;
/* Foreign task? */
if (ci->nodeID != s->nodeID && cj->nodeID != s->nodeID) {
@@ -224,7 +221,8 @@ void scheduler_splittasks(struct scheduler *s) {
/* Get the sort ID, use space_getsid and not t->flags
to make sure we get ci and cj swapped if needed. */
- sid = space_getsid(s->space, &ci, &cj, shift);
+ double shift[3];
+ int sid = space_getsid(s->space, &ci, &cj, shift);
/* Should this task be split-up? */
if (ci->split && cj->split &&
@@ -480,9 +478,9 @@ void scheduler_splittasks(struct scheduler *s) {
/* Replace the current task. */
t->type = task_type_none;
- for (j = 0; j < 8; j++)
+ for (int j = 0; j < 8; j++)
if (ci->progeny[j] != NULL)
- for (k = 0; k < 8; k++)
+ for (int k = 0; k < 8; k++)
if (cj->progeny[k] != NULL) {
t = scheduler_addtask(s, task_type_pair, t->subtype, 0, 0,
ci->progeny[j], cj->progeny[k], 0);
@@ -521,8 +519,8 @@ void scheduler_splittasks(struct scheduler *s) {
else if (t->type == task_type_grav_mm) {
/* Get a handle on the cells involved. */
- ci = t->ci;
- cj = t->cj;
+ struct cell *ci = t->ci;
+ struct cell *cj = t->cj;
/* Self-interaction? */
if (cj == NULL) {
@@ -546,7 +544,7 @@ void scheduler_splittasks(struct scheduler *s) {
/* Split this task into tasks on its progeny. */
t->type = task_type_none;
- for (j = 0; j < 8; j++)
+ for (int j = 0; j < 8; j++)
if (ci->progeny[j] != NULL && ci->progeny[j]->gcount > 0) {
if (t->type == task_type_none) {
t->type = task_type_grav_mm;
@@ -555,7 +553,7 @@ void scheduler_splittasks(struct scheduler *s) {
} else
t = scheduler_addtask(s, task_type_grav_mm, task_subtype_none,
0, 0, ci->progeny[j], NULL, 0);
- for (k = j + 1; k < 8; k++)
+ for (int k = j + 1; k < 8; k++)
if (ci->progeny[k] != NULL && ci->progeny[k]->gcount > 0) {
if (t->type == task_type_none) {
t->type = task_type_grav_mm;
@@ -594,7 +592,7 @@ void scheduler_splittasks(struct scheduler *s) {
/* Get the opening angle theta. */
float dx[3], theta;
- for (k = 0; k < 3; k++) {
+ for (int k = 0; k < 3; k++) {
dx[k] = fabs(ci->loc[k] - cj->loc[k]);
if (s->space->periodic && dx[k] > 0.5 * s->space->dim[k])
dx[k] = -dx[k] + s->space->dim[k];
@@ -615,9 +613,9 @@ void scheduler_splittasks(struct scheduler *s) {
/* Split this task into tasks on its progeny. */
t->type = task_type_none;
- for (j = 0; j < 8; j++)
+ for (int j = 0; j < 8; j++)
if (ci->progeny[j] != NULL && ci->progeny[j]->gcount > 0) {
- for (k = 0; k < 8; k++)
+ for (int k = 0; k < 8; k++)
if (cj->progeny[k] != NULL && cj->progeny[k]->gcount > 0) {
if (t->type == task_type_none) {
t->type = task_type_grav_mm;
@@ -663,17 +661,14 @@ struct task *scheduler_addtask(struct scheduler *s, int type, int subtype,
int flags, int wait, struct cell *ci,
struct cell *cj, int tight) {
- int ind;
- struct task *t;
-
/* Get the next free task. */
- ind = atomic_inc(&s->tasks_next);
+ const int ind = atomic_inc(&s->tasks_next);
/* Overflow? */
if (ind >= s->size) error("Task list overflow.");
/* Get a pointer to the new task. */
- t = &s->tasks[ind];
+ struct task *t = &s->tasks[ind];
/* Copy the data. */
t->type = type;
@@ -768,24 +763,24 @@ void scheduler_set_unlocks(struct scheduler *s) {
void scheduler_ranktasks(struct scheduler *s) {
- int i, j = 0, k, temp, left = 0, rank;
- struct task *t, *tasks = s->tasks;
- int *tid = s->tasks_ind, nr_tasks = s->nr_tasks;
+ struct task *tasks = s->tasks;
+ int *tid = s->tasks_ind;
+ const int nr_tasks = s->nr_tasks;
/* Run through the tasks and get all the waits right. */
- for (i = 0, k = 0; k < nr_tasks; k++) {
+ for (int k = 0; k < nr_tasks; k++) {
tid[k] = k;
- for (j = 0; j < tasks[k].nr_unlock_tasks; j++)
+ for (int j = 0; j < tasks[k].nr_unlock_tasks; j++)
tasks[k].unlock_tasks[j]->wait += 1;
}
/* Main loop. */
- for (j = 0, rank = 0; left < nr_tasks; rank++) {
+ for (int j = 0, rank = 0, left = 0; left < nr_tasks; rank++) {
/* Load the tids of tasks with no waits. */
- for (k = left; k < nr_tasks; k++)
+ for (int k = left; k < nr_tasks; k++)
if (tasks[tid[k]].wait == 0) {
- temp = tid[j];
+ int temp = tid[j];
tid[j] = tid[k];
tid[k] = temp;
j += 1;
@@ -795,15 +790,16 @@ void scheduler_ranktasks(struct scheduler *s) {
if (j == left) error("Unsatisfiable task dependencies detected.");
/* Unlock the next layer of tasks. */
- for (i = left; i < j; i++) {
- t = &tasks[tid[i]];
+ for (int i = left; i < j; i++) {
+ struct task *t = &tasks[tid[i]];
t->rank = rank;
tid[i] = t - tasks;
if (tid[i] >= nr_tasks) error("Task index overshoot.");
/* message( "task %i of type %s has rank %i." , i ,
(t->type == task_type_self) ? "self" : (t->type == task_type_pair) ?
"pair" : "sort" , rank ); */
- for (k = 0; k < t->nr_unlock_tasks; k++) t->unlock_tasks[k]->wait -= 1;
+ for (int k = 0; k < t->nr_unlock_tasks; k++)
+ t->unlock_tasks[k]->wait -= 1;
}
/* The new left (no, not tony). */
@@ -825,8 +821,6 @@ void scheduler_ranktasks(struct scheduler *s) {
void scheduler_reset(struct scheduler *s, int size) {
- int k;
-
/* Do we need to re-allocate? */
if (size > s->size) {
@@ -853,7 +847,7 @@ void scheduler_reset(struct scheduler *s, int size) {
s->nr_unlocks = 0;
/* Set the task pointers in the queues. */
- for (k = 0; k < s->nr_queues; k++) s->queues[k].tasks = s->tasks;
+ for (int k = 0; k < s->nr_queues; k++) s->queues[k].tasks = s->tasks;
}
/**
@@ -864,21 +858,23 @@ void scheduler_reset(struct scheduler *s, int size) {
void scheduler_reweight(struct scheduler *s) {
- int k, j, nr_tasks = s->nr_tasks, *tid = s->tasks_ind;
- struct task *t, *tasks = s->tasks;
- int nodeID = s->nodeID;
- float sid_scale[13] = {0.1897, 0.4025, 0.1897, 0.4025, 0.5788, 0.4025, 0.1897,
- 0.4025, 0.1897, 0.4025, 0.5788, 0.4025, 0.5788};
- float wscale = 0.001;
+ const int nr_tasks = s->nr_tasks;
+ int *tid = s->tasks_ind;
+ struct task *tasks = s->tasks;
+ const int nodeID = s->nodeID;
+ const float sid_scale[13] = {0.1897, 0.4025, 0.1897, 0.4025, 0.5788,
+ 0.4025, 0.1897, 0.4025, 0.1897, 0.4025,
+ 0.5788, 0.4025, 0.5788};
+ const float wscale = 0.001;
// ticks tic;
/* Run through the tasks backwards and set their waits and
weights. */
// tic = getticks();
- for (k = nr_tasks - 1; k >= 0; k--) {
- t = &tasks[tid[k]];
+ for (int k = nr_tasks - 1; k >= 0; k--) {
+ struct task *t = &tasks[tid[k]];
t->weight = 0;
- for (j = 0; j < t->nr_unlock_tasks; j++)
+ for (int j = 0; j < t->nr_unlock_tasks; j++)
if (t->unlock_tasks[j]->weight > t->weight)
t->weight = t->unlock_tasks[j]->weight;
if (!t->implicit && t->tic > 0)
@@ -959,8 +955,9 @@ void scheduler_reweight(struct scheduler *s) {
void scheduler_start(struct scheduler *s, unsigned int mask,
unsigned int submask) {
- int nr_tasks = s->nr_tasks, *tid = s->tasks_ind;
- struct task *t, *tasks = s->tasks;
+ const int nr_tasks = s->nr_tasks;
+ int *tid = s->tasks_ind;
+ struct task *tasks = s->tasks;
// ticks tic;
/* Store the masks */
@@ -1025,7 +1022,7 @@ void scheduler_start(struct scheduler *s, unsigned int mask,
/* Loop over the tasks and enqueue whoever is ready. */
// tic = getticks();
for (int k = 0; k < s->nr_tasks; k++) {
- t = &tasks[tid[k]];
+ struct task *t = &tasks[tid[k]];
if (atomic_dec(&t->wait) == 1 && ((1 << t->type) & s->mask) &&
((1 << t->subtype) & s->submask) && !t->skip) {
scheduler_enqueue(s, t);
@@ -1046,10 +1043,8 @@ void scheduler_start(struct scheduler *s, unsigned int mask,
void scheduler_enqueue(struct scheduler *s, struct task *t) {
+ /* The target queue for this task. */
int qid = -1;
-#ifdef WITH_MPI
- int err;
-#endif
/* Fail if this task has already been enqueued before. */
if (t->rid >= 0) error("Task has already been enqueued.");
@@ -1071,6 +1066,9 @@ void scheduler_enqueue(struct scheduler *s, struct task *t) {
/* Otherwise, look for a suitable queue. */
else {
+#ifdef WITH_MPI
+ int err;
+#endif
/* Find the previous owner for each task type, and do
any pre-processing needed. */
@@ -1093,13 +1091,10 @@ void scheduler_enqueue(struct scheduler *s, struct task *t) {
break;
case task_type_recv:
#ifdef WITH_MPI
- if ((err = MPI_Irecv(t->ci->parts, t->ci->count, s->part_mpi_type,
- t->ci->nodeID, t->flags, MPI_COMM_WORLD,
- &t->req)) != MPI_SUCCESS) {
- char buff[MPI_MAX_ERROR_STRING];
- int len;
- MPI_Error_string(err, buff, &len);
- error("Failed to emit irecv for particle data (%s).", buff);
+ err = MPI_Irecv(t->ci->parts, t->ci->count, s->part_mpi_type,
+ t->ci->nodeID, t->flags, MPI_COMM_WORLD, &t->req);
+ if (err != MPI_SUCCESS) {
+ mpi_error(err, "Failed to emit irecv for particle data.");
}
// message( "receiving %i parts with tag=%i from %i to %i." ,
// t->ci->count , t->flags , t->ci->nodeID , s->nodeID );
@@ -1111,13 +1106,10 @@ void scheduler_enqueue(struct scheduler *s, struct task *t) {
break;
case task_type_send:
#ifdef WITH_MPI
- if ((err = MPI_Isend(t->ci->parts, t->ci->count, s->part_mpi_type,
- t->cj->nodeID, t->flags, MPI_COMM_WORLD,
- &t->req)) != MPI_SUCCESS) {
- char buff[MPI_MAX_ERROR_STRING];
- int len;
- MPI_Error_string(err, buff, &len);
- error("Failed to emit isend for particle data (%s).", buff);
+ err = MPI_Isend(t->ci->parts, t->ci->count, s->part_mpi_type,
+ t->cj->nodeID, t->flags, MPI_COMM_WORLD, &t->req);
+ if (err != MPI_SUCCESS) {
+ mpi_error(err, "Failed to emit isend for particle data.");
}
// message( "sending %i parts with tag=%i from %i to %i." ,
// t->ci->count , t->flags , s->nodeID , t->cj->nodeID );
@@ -1164,7 +1156,7 @@ struct task *scheduler_done(struct scheduler *s, struct task *t) {
for (int k = 0; k < t->nr_unlock_tasks; k++) {
struct task *t2 = t->unlock_tasks[k];
- int res = atomic_dec(&t2->wait);
+ const int res = atomic_dec(&t2->wait);
if (res < 1) {
error("Negative wait!");
} else if (res == 1) {
@@ -1203,7 +1195,7 @@ struct task *scheduler_unlock(struct scheduler *s, struct task *t) {
they are ready. */
for (int k = 0; k < t->nr_unlock_tasks; k++) {
struct task *t2 = t->unlock_tasks[k];
- int res = atomic_dec(&t2->wait);
+ const int res = atomic_dec(&t2->wait);
if (res < 1) {
error("Negative wait!");
} else if (res == 1) {
@@ -1240,7 +1232,7 @@ struct task *scheduler_gettask(struct scheduler *s, int qid,
const struct task *prev) {
struct task *res = NULL;
- int k, nr_queues = s->nr_queues;
+ const int nr_queues = s->nr_queues;
unsigned int seed = qid;
/* Check qid. */
@@ -1264,10 +1256,10 @@ struct task *scheduler_gettask(struct scheduler *s, int qid,
/* If unsuccessful, try stealing from the other queues. */
if (s->flags & scheduler_flag_steal) {
int count = 0, qids[nr_queues];
- for (k = 0; k < nr_queues; k++)
+ for (int k = 0; k < nr_queues; k++)
if (s->queues[k].count > 0) qids[count++] = k;
- for (k = 0; k < scheduler_maxsteal && count > 0; k++) {
- int ind = rand_r(&seed) % count;
+ for (int k = 0; k < scheduler_maxsteal && count > 0; k++) {
+ const int ind = rand_r(&seed) % count;
TIMER_TIC
res = queue_gettask(&s->queues[qids[ind]], prev, 0);
TIMER_TOC(timer_qsteal);
@@ -1366,7 +1358,7 @@ void scheduler_init(struct scheduler *s, struct space *space, int nr_tasks,
* @param s The #scheduler
* @param fileName Name of the file to write to
*/
-void scheduler_print_tasks(struct scheduler *s, char *fileName) {
+void scheduler_print_tasks(const struct scheduler *s, const char *fileName) {
const int nr_tasks = s->nr_tasks, *tid = s->tasks_ind;
struct task *t, *tasks = s->tasks;
diff --git a/src/scheduler.h b/src/scheduler.h
index 3f2d8c289d0d691d0d155b20ae0522c5830524aa..9c2a5bd7307817bd536930200ad08e7e37502e08 100644
--- a/src/scheduler.h
+++ b/src/scheduler.h
@@ -128,7 +128,7 @@ struct task *scheduler_unlock(struct scheduler *s, struct task *t);
void scheduler_addunlock(struct scheduler *s, struct task *ta, struct task *tb);
void scheduler_set_unlocks(struct scheduler *s);
void scheduler_dump_queue(struct scheduler *s);
-void scheduler_print_tasks(struct scheduler *s, char *fileName);
+void scheduler_print_tasks(const struct scheduler *s, const char *fileName);
void scheduler_do_rewait(struct task *t_begin, struct task *t_end,
unsigned int mask, unsigned int submask);
diff --git a/src/space.c b/src/space.c
index fa2541c2872c38f5000e78ef2802d9a4f719f9fc..d5eded274d4c2e7279f80ad6f80911e53170cc97 100644
--- a/src/space.c
+++ b/src/space.c
@@ -97,12 +97,10 @@ const int sortlistID[27] = {
int space_getsid(struct space *s, struct cell **ci, struct cell **cj,
double *shift) {
- int k, sid = 0, periodic = s->periodic;
- struct cell *temp;
- double dx[3];
-
/* Get the relative distance between the pairs, wrapping. */
- for (k = 0; k < 3; k++) {
+ const int periodic = s->periodic;
+ double dx[3];
+ for (int k = 0; k < 3; k++) {
dx[k] = (*cj)->loc[k] - (*ci)->loc[k];
if (periodic && dx[k] < -s->dim[k] / 2)
shift[k] = s->dim[k];
@@ -114,15 +112,16 @@ int space_getsid(struct space *s, struct cell **ci, struct cell **cj,
}
/* Get the sorting index. */
- for (k = 0; k < 3; k++)
+ int sid = 0;
+ for (int k = 0; k < 3; k++)
sid = 3 * sid + ((dx[k] < 0.0) ? 0 : ((dx[k] > 0.0) ? 2 : 1));
/* Switch the cells around? */
if (runner_flip[sid]) {
- temp = *ci;
+ struct cell *temp = *ci;
*ci = *cj;
*cj = temp;
- for (k = 0; k < 3; k++) shift[k] = -shift[k];
+ for (int k = 0; k < 3; k++) shift[k] = -shift[k];
}
sid = sortlistID[sid];
@@ -137,10 +136,8 @@ int space_getsid(struct space *s, struct cell **ci, struct cell **cj,
void space_rebuild_recycle(struct space *s, struct cell *c) {
- int k;
-
if (c->split)
- for (k = 0; k < 8; k++)
+ for (int k = 0; k < 8; k++)
if (c->progeny[k] != NULL) {
space_rebuild_recycle(s, c->progeny[k]);
space_recycle(s, c->progeny[k]);
@@ -158,19 +155,19 @@ void space_rebuild_recycle(struct space *s, struct cell *c) {
void space_regrid(struct space *s, double cell_max, int verbose) {
- float h_max = s->cell_min / kernel_gamma / space_stretch, dmin;
- int i, j, k, cdim[3], nr_parts = s->nr_parts;
+ float h_max = s->cell_min / kernel_gamma / space_stretch;
+ const size_t nr_parts = s->nr_parts;
struct cell *restrict c;
ticks tic = getticks();
/* Run through the parts and get the current h_max. */
// tic = getticks();
if (s->cells != NULL) {
- for (k = 0; k < s->nr_cells; k++) {
+ for (int k = 0; k < s->nr_cells; k++) {
if (s->cells[k].h_max > h_max) h_max = s->cells[k].h_max;
}
} else {
- for (k = 0; k < nr_parts; k++) {
+ for (int k = 0; k < nr_parts; k++) {
if (s->parts[k].h > h_max) h_max = s->parts[k].h;
}
s->h_max = h_max;
@@ -190,7 +187,8 @@ void space_regrid(struct space *s, double cell_max, int verbose) {
if (verbose) message("h_max is %.3e (cell_max=%.3e).", h_max, cell_max);
/* Get the new putative cell dimensions. */
- for (k = 0; k < 3; k++)
+ int cdim[3];
+ for (int k = 0; k < 3; k++)
cdim[k] =
floor(s->dim[k] / fmax(h_max * kernel_gamma * space_stretch, cell_max));
@@ -213,7 +211,7 @@ void space_regrid(struct space *s, double cell_max, int verbose) {
/* Free the old cells, if they were allocated. */
if (s->cells != NULL) {
- for (k = 0; k < s->nr_cells; k++) {
+ for (int k = 0; k < s->nr_cells; k++) {
space_rebuild_recycle(s, &s->cells[k]);
if (s->cells[k].sort != NULL) free(s->cells[k].sort);
}
@@ -222,12 +220,12 @@ void space_regrid(struct space *s, double cell_max, int verbose) {
}
/* Set the new cell dimensions only if smaller. */
- for (k = 0; k < 3; k++) {
+ for (int k = 0; k < 3; k++) {
s->cdim[k] = cdim[k];
s->h[k] = s->dim[k] / cdim[k];
s->ih[k] = 1.0 / s->h[k];
}
- dmin = fminf(s->h[0], fminf(s->h[1], s->h[2]));
+ const float dmin = fminf(s->h[0], fminf(s->h[1], s->h[2]));
/* Allocate the highest level of cells. */
s->tot_cells = s->nr_cells = cdim[0] * cdim[1] * cdim[2];
@@ -235,13 +233,13 @@ void space_regrid(struct space *s, double cell_max, int verbose) {
s->nr_cells * sizeof(struct cell)) != 0)
error("Failed to allocate cells.");
bzero(s->cells, s->nr_cells * sizeof(struct cell));
- for (k = 0; k < s->nr_cells; k++)
+ for (int k = 0; k < s->nr_cells; k++)
if (lock_init(&s->cells[k].lock) != 0) error("Failed to init spinlock.");
/* Set the cell location and sizes. */
- for (i = 0; i < cdim[0]; i++)
- for (j = 0; j < cdim[1]; j++)
- for (k = 0; k < cdim[2]; k++) {
+ for (int i = 0; i < cdim[0]; i++)
+ for (int j = 0; j < cdim[1]; j++)
+ for (int k = 0; k < cdim[2]; k++) {
c = &s->cells[cell_getid(cdim, i, j, k)];
c->loc[0] = i * s->h[0];
c->loc[1] = j * s->h[1];
@@ -271,7 +269,7 @@ void space_regrid(struct space *s, double cell_max, int verbose) {
else {
/* Free the old cells, if they were allocated. */
- for (k = 0; k < s->nr_cells; k++) {
+ for (int k = 0; k < s->nr_cells; k++) {
space_rebuild_recycle(s, &s->cells[k]);
s->cells[k].sorts = NULL;
s->cells[k].nr_tasks = 0;