Skip to content
GitLab
Commit f6f7239b authored by Peter W. Draper's avatar Peter W. Draper
Browse files

Merge branch 'local_variable_cleanup' into 'master' 

Local variable cleanup

Yet another batch of cleanups.

See merge request !123
parents 6b59015f 1fce2ba4
Hide whitespace changes
Inline Side-by-side
src/proxy.c
View file @ f6f7239b
......@@ -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) {
......
src/proxy.h
View file @ f6f7239b
......@@ -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);
......
src/scheduler.c
View file @ f6f7239b
......@@ -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;
......
src/scheduler.h
View file @ f6f7239b
......@@ -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);
......
src/space.c
View file @ f6f7239b
......@@ -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++) {