space.c 63.6 KB
Newer Older
Pedro Gonnet's avatar
Pedro Gonnet committed
1
/*******************************************************************************
2
 * This file is part of SWIFT.
Pedro Gonnet's avatar
Pedro Gonnet committed
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 * Coypright (c) 2012 Pedro Gonnet (pedro.gonnet@durham.ac.uk)
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published
 * by the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 * 
 ******************************************************************************/

/* Config parameters. */
#include "../config.h"

/* Some standard headers. */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
#include <float.h>
#include <limits.h>
#include <math.h>

/* Local headers. */
#include "cycle.h"
#include "lock.h"
35
36
37
#include "task.h"
#include "part.h"
#include "cell.h"
Pedro Gonnet's avatar
Pedro Gonnet committed
38
39
40
41
#include "space.h"
#include "runner.h"

/* Error macro. */
42
#define error(s) { fprintf( stderr , "%s:%s:%i: %s\n" , __FILE__ , __FUNCTION__ , __LINE__ , s ); abort(); }
Pedro Gonnet's avatar
Pedro Gonnet committed
43
44
45

/* Split size. */
int space_splitsize = space_splitsize_default;
46
int space_subsize = space_subsize_default;
Pedro Gonnet's avatar
Pedro Gonnet committed
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

/* Map shift vector to sortlist. */
const int sortlistID[27] = {
    /* ( -1 , -1 , -1 ) */   0 ,
    /* ( -1 , -1 ,  0 ) */   1 , 
    /* ( -1 , -1 ,  1 ) */   2 ,
    /* ( -1 ,  0 , -1 ) */   3 ,
    /* ( -1 ,  0 ,  0 ) */   4 , 
    /* ( -1 ,  0 ,  1 ) */   5 ,
    /* ( -1 ,  1 , -1 ) */   6 ,
    /* ( -1 ,  1 ,  0 ) */   7 , 
    /* ( -1 ,  1 ,  1 ) */   8 ,
    /* (  0 , -1 , -1 ) */   9 ,
    /* (  0 , -1 ,  0 ) */   10 , 
    /* (  0 , -1 ,  1 ) */   11 ,
    /* (  0 ,  0 , -1 ) */   12 ,
    /* (  0 ,  0 ,  0 ) */   0 , 
    /* (  0 ,  0 ,  1 ) */   12 ,
    /* (  0 ,  1 , -1 ) */   11 ,
    /* (  0 ,  1 ,  0 ) */   10 , 
    /* (  0 ,  1 ,  1 ) */   9 ,
    /* (  1 , -1 , -1 ) */   8 ,
    /* (  1 , -1 ,  0 ) */   7 , 
    /* (  1 , -1 ,  1 ) */   6 ,
    /* (  1 ,  0 , -1 ) */   5 ,
    /* (  1 ,  0 ,  0 ) */   4 , 
    /* (  1 ,  0 ,  1 ) */   3 ,
    /* (  1 ,  1 , -1 ) */   2 ,
    /* (  1 ,  1 ,  0 ) */   1 , 
    /* (  1 ,  1 ,  1 ) */   0 
    };
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116


/**
 * @brief Mapping function to set dt_min and dt_max.
 */

void space_map_prepare ( struct cell *c , void *data ) {

    int k;
    float dt_min, dt_max, h_max, dx_max;
    struct part *p;

    /* No children? */
    if ( !c->split ) {
    
        /* Init with first part. */
        p = &c->parts[0];
        dt_min = p->dt;
        dt_max = p->dt;
        h_max = p->h;
        dx_max = sqrtf( (p->x[0] - p->x_old[0])*(p->x[0] - p->x_old[0]) +
                        (p->x[1] - p->x_old[1])*(p->x[1] - p->x_old[1]) +
                        (p->x[2] - p->x_old[2])*(p->x[2] - p->x_old[2]) )*2 + p->h;
    
        /* Loop over parts. */
        for ( k = 1 ; k < c->count ; k++ ) {
            p = &c->parts[k];
            dt_min = fminf( dt_min , p->dt );
            dt_max = fmaxf( dt_max , p->dt );
            h_max = fmaxf( h_max , p->h );
            dx_max = fmaxf( dx_max , sqrtf( (p->x[0] - p->x_old[0])*(p->x[0] - p->x_old[0]) +
                                            (p->x[1] - p->x_old[1])*(p->x[1] - p->x_old[1]) +
                                            (p->x[2] - p->x_old[2])*(p->x[2] - p->x_old[2]) )*2 + p->h );
            }
            
        }
        
    /* Otherwise, agregate from children. */
    else {
Pedro Gonnet's avatar
Pedro Gonnet committed
117
    
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
        /* Init with the first non-null child. */
        for ( k = 0 ; c->progeny[k] == 0 ; k++ );
        dt_min = c->progeny[k]->dt_min;
        dt_max = c->progeny[k]->dt_max;
        h_max = c->progeny[k]->h_max;
        dx_max = c->progeny[k]->dx_max;
        
        /* Loop over the remaining progeny. */
        for ( k += 1 ; k < 8 ; k++ )
            if ( c->progeny[k] != NULL ) {
                dt_min = fminf( dt_min , c->progeny[k]->dt_min );
                dt_max = fmaxf( dt_max , c->progeny[k]->dt_max );
                h_max = fmaxf( h_max , c->progeny[k]->h_max );
                dx_max = fmaxf( dx_max , c->progeny[k]->dx_max );
                }
Pedro Gonnet's avatar
Pedro Gonnet committed
133
    
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
        }

    /* Store the values. */
    c->dt_min = dt_min;
    c->dt_max = dt_max;
    c->h_max = h_max;
    c->dx_max = dx_max;
    
    /* Clean out the task pointers. */
    c->sorts[0] = NULL;
    c->nr_tasks = 0;
    c->nr_density = 0;
    
    }


/**
 * @brief Check the integrity of the space and rebuild if necessary.
 *
 * @param s The #space.
 *
 * Runs through the tasks and marks those as "skip" which have no
 * effect for the current @c dt_max. Verifies the integrity of the
 * cell tree for those tasks and triggers a rebuild if necessary.
 */
 
void space_prepare ( struct space *s ) {

    int k;
    struct task *t;
    float dt_max = s->dt_max;
    int counts[ task_type_count + 1 ];
    
    /* Traverse the cells and set their dt_min and dt_max. */
    space_map_cells_post( s , 1 , &space_map_prepare , NULL );
    
    /* Run through the tasks and mark as skip or not. */
    for ( k = 0 ; k < s->nr_tasks ; k++ ) {
        t = &s->tasks[k];
        if ( t->type == task_type_sort ||
             t->type == task_type_self ||
             t->type == task_type_ghost ||
             ( t->type == task_type_sub && t->cj == NULL ) )
            t->skip = ( t->ci->dt_min > dt_max );
        else if ( t->type == task_type_pair || ( t->type == task_type_sub && t->cj != NULL ) ) {
            t->skip = ( t->ci->dt_min > dt_max && t->cj->dt_min > dt_max );
            if ( !t->skip && t->tight &&
                 ( t->ci->dx_max > t->ci->dmin || t->cj->dx_max > t->cj->dmin ) )
                break;
            }
        }
        
    /* Did this not go through? */
    if ( k < s->nr_tasks ) {
    
        /* Re-build the space. */
        space_rebuild( s , 0.0 );
    
        /* Traverse the cells and set their dt_min and dt_max. */
        space_map_cells_post( s , 1 , &space_map_prepare , NULL );
    
        /* Run through the tasks and mark as skip or not. */
        for ( k = 0 ; k < s->nr_tasks ; k++ ) {
            t = &s->tasks[k];
            if ( t->type == task_type_sort || t->type == task_type_self || t->type == task_type_ghost )
                t->skip = ( t->ci->dt_min > dt_max );
            else if ( t->type == task_type_pair )
                t->skip = ( t->ci->dt_min > dt_max && t->cj->dt_min > dt_max );
            }
            
        }

    /* Store the condensed particle data. */         
    #pragma omp parallel for schedule(static)
    for ( k = 0 ; k < s->nr_parts ; k++ ) {
        s->cparts[k].x[0] = s->parts[k].x[0];
        s->cparts[k].x[1] = s->parts[k].x[1];
        s->cparts[k].x[2] = s->parts[k].x[2];
        s->cparts[k].h = s->parts[k].h;
        s->cparts[k].dt = s->parts[k].dt;
        }

    /* Now that we have the cell structre, re-build the tasks. */
    // tic = getticks();
    space_maketasks( s , 1 );
    // printf( "space_prepare: maketasks took %.3f ms.\n" , (double)(getticks() - tic) / CPU_TPS * 1000 );
    
    /* Count the number of each task type. */
    for ( k = 0 ; k <= task_type_count ; k++ )
        counts[k] = 0;
    for ( k = 0 ; k < s->nr_tasks ; k++ )
        if ( !s->tasks[k].skip )
            counts[ (int)s->tasks[k].type ] += 1;
        else
            counts[ task_type_count ] += 1;
    printf( "space_prepare: task counts are [ %s=%i" , taskID_names[0] , counts[0] );
    for ( k = 1 ; k < task_type_count ; k++ )
        printf( " %s=%i" , taskID_names[k] , counts[k] );
    printf( " skipped=%i ]\n" , counts[ task_type_count ] ); fflush(stdout);
    
    }
    
    
/** 
 * @brief Sort the tasks in topological order over all queues.
 *
 * @param s The #space.
 */
 
void space_ranktasks ( struct space *s ) {

    int i, j = 0, k, temp, left = 0, rank;
    struct task *t;
    int *tid = s->tasks_ind;
    
    /* Run throught the tasks and get all the waits right. */
    for ( k = 0 ; k < s->nr_tasks ; k++ ) {
        tid[k] = k;
        for ( j = 0 ; j < s->tasks[k].nr_unlock_tasks ; j++ )
            s->tasks[k].unlock_tasks[j]->wait += 1;
        }
        
    /* Main loop. */
    for ( j = 0 , rank = 0 ; left < s->nr_tasks ; rank++ ) {
        
        /* Load the tids of tasks with no waits. */
        for ( k = left ; k < s->nr_tasks ; k++ )
            if ( s->tasks[ tid[k] ].wait == 0 ) {
                temp = tid[j]; tid[j] = tid[k]; tid[k] = temp;
                j += 1;
                }

        /* Traverse the task tree and add tasks with no weight. */
        for ( i = left ; i < j ; i++ ) {
            t = &s->tasks[ tid[i] ];
            t->rank = rank;
            s->tasks_ind[i] = t - s->tasks;
            /* printf( "engine_ranktasks: task %i of type %s has rank %i.\n" , 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;
            }
            
        /* The new left (no, not tony). */
        left = j;
            
        }
        
    }


285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
/**
 * @brief Get the shift-id of the given pair of cells, swapping them
 *      if need be.
 *
 * @param s The space
 * @param ci Pointer to first #cell.
 * @param cj Pointer second #cell.
 * @param shift Vector from ci to cj.
 *
 * @return The shift ID and set shift, may or may not swap ci and cj.
 */
 
int space_getsid ( struct space *s , struct cell **ci , struct cell **cj , double *shift ) {

    int k, sid = 0;
    struct cell *temp;
    double dx[3];

    /* Get the relative distance between the pairs, wrapping. */
    for ( k = 0 ; k < 3 ; k++ ) {
        dx[k] = (*cj)->loc[k] - (*ci)->loc[k];
        if ( dx[k] < -s->dim[k]/2 )
            shift[k] = s->dim[k];
        else if ( dx[k] > s->dim[k]/2 )
            shift[k] = -s->dim[k];
        else
            shift[k] = 0.0;
        dx[k] += shift[k];
        }
        
    /* Get the sorting index. */
    for ( 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; *ci = *cj; *cj = temp;
        for ( k = 0 ; k < 3 ; k++ )
            shift[k] = -shift[k];
        }
    sid = sortlistID[sid];
    
    /* Return the sort ID. */
    return sid;

    }


333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
/**
 * @breif Recursively dismantle a cell tree.
 *
 */
 
void space_rebuild_recycle ( struct space *s , struct cell *c ) {
    
    int k;
    
    if ( c->split )
        for ( k = 0 ; k < 8 ; k++ )
            if ( c->progeny[k] != NULL ) {
                space_rebuild_recycle( s , c->progeny[k] );
                space_recycle( s , c->progeny[k] );
                c->progeny[k] = NULL;
                }
    
    }

/**
 * @breif Recursively rebuild a cell tree.
 *
 */
 
int space_rebuild_recurse ( struct space *s , struct cell *c ) {
    
    int k, count, changes = 0, wasmt[8];
360
    float h, h_limit, h_max = 0.0f, dt_min = c->parts[0].dt, dt_max = dt_min;
361
362
363
364
365
366
367
368
369
370
371
372
373
374
    struct cell *temp;
    
    /* If the cell is already split, check that the split is still ok. */
    if ( c->split ) {
    
        /* Check the depth. */
        if ( c->depth > s->maxdepth )
            s->maxdepth = c->depth;

        /* Set the minimum cutoff. */
        h_limit = fmin( c->h[0] , fmin( c->h[1] , c->h[2] ) ) / 2;

        /* Count the particles below that. */
        for ( count = 0 , k = 0 ; k < c->count ; k++ ) {
375
            h = c->parts[k].h;
376
377
378
379
            if ( h <= h_limit )
                count += 1;
            if ( h > h_max )
                h_max = h;
380
381
382
383
            if ( c->parts[k].dt < dt_min )
                dt_min = c->parts[k].dt;
            if ( c->parts[k].dt > dt_max )
                dt_max = c->parts[k].dt;
384
385
            }
        c->h_max = h_max;
386
387
        c->dt_min = dt_min;
        c->dt_max = dt_max;
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
            
        /* Un-split? */
        if ( count < c->count*space_splitratio || c->count < space_splitsize ) {
        
            /* Get rid of the progeny. */
            space_rebuild_recycle( s , c );
            
            /* Re-set the split flag. */
            c->split = 0;
        
            }
        
        /* Otherwise, recurse on the kids. */
        else {
        
            /* Populate all progeny. */
            for ( k = 0 ; k < 8 ; k++ )
                if ( ( wasmt[k] = ( c->progeny[k] == NULL ) ) ) {
                    temp = space_getcell( s );
                    temp->count = 0;
                    temp->loc[0] = c->loc[0];
                    temp->loc[1] = c->loc[1];
                    temp->loc[2] = c->loc[2];
                    temp->h[0] = c->h[0]/2;
                    temp->h[1] = c->h[1]/2;
                    temp->h[2] = c->h[2]/2;
                    if ( k & 4 )
                        temp->loc[0] += temp->h[0];
                    if ( k & 2 )
                        temp->loc[1] += temp->h[1];
                    if ( k & 1 )
                        temp->loc[2] += temp->h[2];
                    temp->depth = c->depth + 1;
                    temp->split = 0;
                    temp->h_max = 0.0;
                    temp->parent = c;
                    c->progeny[k] = temp;
                    }
        
            /* Make sure each part is in its place. */
            cell_split( c );
            
            /* Remove empty progeny. */
            for ( k = 0 ; k < 8 ; k++ )
                if ( c->progeny[k]->count == 0 ) {
                    changes += !wasmt[k];
                    space_recycle( s , c->progeny[k] );
                    c->progeny[k] = NULL;
                    }
                else
                    changes += wasmt[k];
        
            /* Recurse. */
            for ( k = 0 ; k < 8 ; k++ )
                if ( c->progeny[k] != NULL )
                    changes += space_rebuild_recurse( s , c->progeny[k] );
                    
            }
    
        }
        
    /* Otherwise, try to split it anyway. */
    else {
        space_split( s , c );
        changes += c->split;
        }
        
    /* Return the grand total. */
    return changes;
    
    }

/**
 * @breif Re-build the cells as well as the tasks.
 *
 * @param s The #space in which to update the cells.
 * @param force Flag to force re-building the cells and tasks.
 *
 */
 
468
void space_rebuild ( struct space *s , double cell_max ) {
469

470
    float h_max = s->cell_min, h_min = s->parts[0].h, dmin;
471
    int i, j, k, cdim[3];
472
473
474
475
    struct cell *restrict c;
    struct part *restrict finger, *restrict p;
    struct cpart *restrict cfinger;
    int *ind;
476
    // ticks tic;
477
    
478
479
480
    /* Be verbose about this. */
    printf( "space_rebuild: (re)building space...\n" ); fflush(stdout);
    
481
    /* Run through the parts and get the current h_max. */
482
    // tic = getticks();
483
    for ( k = 0 ; k < s->nr_parts ; k++ ) {
484
485
        if ( s->parts[k].h > h_max )
            h_max = s->parts[k].h;
486
487
        else if ( s->parts[k].h < h_min )
            h_min = s->parts[k].h;
488
        }
489
490
    s->h_min = h_min;
    s->h_max = h_max;
491
    // printf( "space_rebuild: getting h_min and h_max took %.3f ms.\n" , (double)(getticks() - tic) / CPU_TPS * 1000 );
492
493
494
    
    /* Get the new putative cell dimensions. */
    for ( k = 0 ; k < 3 ; k++ )
Pedro Gonnet's avatar
Pedro Gonnet committed
495
        cdim[k] = floor( s->dim[k] / fmax( h_max*space_stretch , cell_max ) );
496
497
        
    /* Do we need to re-build the upper-level cells? */
498
    // tic = getticks();
499
500
    if ( s->cells == NULL ||
         cdim[0] < s->cdim[0] || cdim[1] < s->cdim[1] || cdim[2] < s->cdim[2] ) {
501
502
503
    
        /* Free the old cells, if they were allocated. */
        if ( s->cells != NULL ) {
504
            for ( k = 0 ; k < s->nr_cells ; k++ ) {
505
                space_rebuild_recycle( s , &s->cells[k] );
506
507
508
                if ( s->cells[k].sort != NULL )
                    free( s->cells[k].sort );
                }
509
510
511
512
            free( s->cells );
            s->maxdepth = 0;
            }
            
513
        /* Set the new cell dimensions only if smaller. */
514
515
516
517
518
        for ( 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];
            }
519
        dmin = fminf( s->h[0] , fminf( s->h[1] , s->h[2] ) );
520

521
        /* Allocate the highest level of cells. */
Pedro Gonnet's avatar
Pedro Gonnet committed
522
        s->tot_cells = s->nr_cells = cdim[0] * cdim[1] * cdim[2];
523
524
525
526
527
528
529
530
531
532
533
534
535
536
        if ( posix_memalign( (void *)&s->cells , 64 , 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++ )
            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++ ) {
                    c = &s->cells[ cell_getid( cdim , i , j , k ) ];
                    c->loc[0] = i*s->h[0]; c->loc[1] = j*s->h[1]; c->loc[2] = k*s->h[2];
                    c->h[0] = s->h[0]; c->h[1] = s->h[1]; c->h[2] = s->h[2];
537
                    c->dmin = dmin;
538
539
540
541
                    c->depth = 0;
                    }
                    
        } /* re-build upper-level cells? */
542
    // printf( "space_rebuild: rebuilding upper-level cells took %.3f ms.\n" , (double)(getticks() - tic) / CPU_TPS * 1000 );
543
        
544
545
        
    /* Run through the particles and get their cell index. */
546
    // tic = getticks();
547
548
    if ( ( ind = (int *)malloc( sizeof(int) * s->nr_parts ) ) == NULL )
        error( "Failed to allocate temporary particle indices." );
549
550
551
    for ( k = 0 ; k < s->nr_cells ; k++ )
        s->cells[ k ].count = 0;
    for ( k = 0 ; k < s->nr_parts ; k++ )  {
552
553
554
555
556
557
558
        p = &s->parts[k];
        for ( j = 0 ; j < 3 ; j++ )
            if ( p->x[j] < 0.0 )
                p->x[j] += s->dim[j];
            else if ( p->x[j] >= s->dim[j] )
                p->x[j] -= s->dim[j];
        ind[k] = cell_getid( s->cdim , p->x[0]*s->ih[0] , p->x[1]*s->ih[1] , p->x[2]*s->ih[2] );
559
560
        s->cells[ ind[k] ].count += 1;
        }
561
    // printf( "space_rebuild: getting particle indices took %.3f ms.\n" , (double)(getticks() - tic) / CPU_TPS * 1000 );
562
563

    /* Sort the parts according to their cells. */
564
    // tic = getticks();
Pedro Gonnet's avatar
Pedro Gonnet committed
565
    parts_sort( s->parts , ind , s->nr_parts , 0 , s->nr_cells );
566
    // printf( "space_rebuild: parts_sort took %.3f ms.\n" , (double)(getticks() - tic) / CPU_TPS * 1000 );
567
568
569
    
    /* We no longer need the indices as of here. */
    free( ind );    
570

571
    /* Store the current positions. */         
572
573
    // tic = getticks();
    #pragma omp parallel for schedule(static)
574
    for ( k = 0 ; k < s->nr_parts ; k++ ) {
575
576
577
        s->parts[k].x_old[0] = s->parts[k].x[0];
        s->parts[k].x_old[1] = s->parts[k].x[1];
        s->parts[k].x_old[2] = s->parts[k].x[2];
578
        }
579
    // printf( "space_rebuild: storing old positions took %.3f ms.\n" , (double)(getticks() - tic) / CPU_TPS * 1000 );
580
581

    /* Hook the cells up to the parts. */
582
    // tic = getticks();
583
584
585
    finger = s->parts;
    cfinger = s->cparts;
    for ( k = 0 ; k < s->nr_cells ; k++ ) {
586
587
588
589
590
591
        c = &s->cells[ k ];
        c->parts = finger;
        c->cparts = cfinger;
        finger = &finger[ c->count ];
        cfinger = &cfinger[ c->count ];
        }
592
    // printf( "space_rebuild: hooking up cells took %.3f ms.\n" , (double)(getticks() - tic) / CPU_TPS * 1000 );
593
594
        
        
595
596
    /* At this point, we have the upper-level cells, old or new. Now make
       sure that the parts in each cell are ok. */
597
    // tic = getticks();
598
    #pragma omp parallel for schedule(dynamic,1) shared(s)
599
    for ( k = 0 ; k < s->nr_cells ; k++ )
600
        space_rebuild_recurse( s , &s->cells[k] );
601
    // printf( "space_rebuild: space_rebuild_recurse took %.3f ms.\n" , (double)(getticks() - tic) / CPU_TPS * 1000 );
602
603
604
605
        
    }


606
/**
607
 * @brief Sort the particles and condensed particles according to the given indices.
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
 *
 * @param parts The list of #part
 * @param ind The indices with respect to which the parts are sorted.
 * @param N The number of parts
 * @param min Lowest index.
 * @param max highest index.
 *
 * This function calls itself recursively.
 */
 
void parts_sort ( struct part *parts , int *ind , int N , int min , int max ) {

    int pivot = (min + max) / 2;
    int i = 0, j = N-1;
    int temp_i;
    struct part temp_p;
    
625
626
627
628
629
630
    /* If N is small enough, just do insert sort. */
    if ( N < 16 ) {
    
        for ( i = 1 ; i < N ; i++ )
            if ( ind[i] < ind[i-1] ) {
                temp_i = ind[i];
Pedro Gonnet's avatar
Pedro Gonnet committed
631
                temp_p = parts[i];
632
633
634
635
636
637
638
639
                for ( j = i ; j > 0 && ind[j-1] > temp_i ; j-- ) {
                    ind[j] = ind[j-1];
                    parts[j] = parts[j-1];
                    }
                ind[j] = temp_i;
                parts[j] = temp_p;
                }
    
640
641
        }
        
642
643
644
645
646
647
648
649
650
651
652
653
654
    /* Otherwise, recurse with Quicksort. */
    else {
    
        /* One pass of quicksort. */
        while ( i < j ) {
            while ( i < N && ind[i] <= pivot )
                i++;
            while ( j >= 0 && ind[j] > pivot )
                j--;
            if ( i < j ) {
                temp_i = ind[i]; ind[i] = ind[j]; ind[j] = temp_i;
                temp_p = parts[i]; parts[i] = parts[j]; parts[j] = temp_p;
                }
655
            }
656
657

        /* Verify sort. */
Pedro Gonnet's avatar
Pedro Gonnet committed
658
        /* for ( int k = 0 ; k <= j ; k++ )
659
660
661
662
663
664
665
666
            if ( ind[k] > pivot ) {
                printf( "parts_sort: sorting failed at k=%i, ind[k]=%i, pivot=%i, i=%i, j=%i, N=%i.\n" , k , ind[k] , pivot , i , j , N );
                error( "Sorting failed (<=pivot)." );
                }
        for ( int k = j+1 ; k < N ; k++ )
            if ( ind[k] <= pivot ) {
                printf( "parts_sort: sorting failed at k=%i, ind[k]=%i, pivot=%i, i=%i, j=%i, N=%i.\n" , k , ind[k] , pivot , i , j , N );
                error( "Sorting failed (>pivot)." );
Pedro Gonnet's avatar
Pedro Gonnet committed
667
                } */
668

Pedro Gonnet's avatar
Pedro Gonnet committed
669
670
671
        /* Recurse on the left? */
        if ( j > 0  && pivot > min )
            parts_sort( parts , ind , j+1 , min , pivot );
672

Pedro Gonnet's avatar
Pedro Gonnet committed
673
674
675
        /* Recurse on the right? */
        if ( i < N && pivot+1 < max )
            parts_sort( &parts[i], &ind[i], N-i , pivot+1 , max );
676
            
677
678
        }
    
679
680
681
    }


Pedro Gonnet's avatar
Pedro Gonnet committed
682
/**
683
 * @brief Mapping function to free the sorted indices buffers.
Pedro Gonnet's avatar
Pedro Gonnet committed
684
685
686
687
688
689
690
691
692
693
694
695
 */

void space_map_clearsort ( struct cell *c , void *data ) {

    if ( c->sort != NULL ) {
        free( c->sort );
        c->sort = NULL;
        }

    }


696
697
/**
 * @brief Mapping function to append a ghost task to each cell.
Pedro Gonnet's avatar
Pedro Gonnet committed
698
699
700
701
 *
 * Looks for the super cell, e.g. the highest-level cell above each
 * cell for which a pair is defined. All ghosts below this cell will
 * depend on the ghost of their parents (sounds spooky, but it isn't).
702
703
704
705
706
 */

void space_map_mkghosts ( struct cell *c , void *data ) {

    struct space *s = (struct space *)data;
Pedro Gonnet's avatar
Pedro Gonnet committed
707
    struct cell *finger;
708

Pedro Gonnet's avatar
Pedro Gonnet committed
709
710
711
712
713
714
715
    /* Find the super cell, i.e. the highest cell hierarchically above
       this one to still have at least one task associated with it. */
    c->super = c;
    for ( finger = c->parent ; finger != NULL ; finger = finger->parent )
        if ( finger->nr_tasks > 0 )
            c->super = finger;
            
Pedro Gonnet's avatar
Pedro Gonnet committed
716
    /* Make the ghost task */
Pedro Gonnet's avatar
Pedro Gonnet committed
717
    if ( c->super != c || c->nr_tasks > 0 )
718
        c->ghost = space_addtask( s , task_type_ghost , task_subtype_none , 0 , 0 , c , NULL , 0 );
Pedro Gonnet's avatar
Pedro Gonnet committed
719
720
721
722
723
724
725
726
727

    /* If we are not the super cell ourselves, make our ghost depend
       on our parent cell. */
    if ( c->super != c )
        task_addunlock( c->parent->ghost , c->ghost );
    
    }


Pedro Gonnet's avatar
Pedro Gonnet committed
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
/**
 * @brief Map a function to all particles in a aspace.
 *
 * @param s The #space we are working in.
 */
 
void space_map_parts ( struct space *s , void (*fun)( struct part *p , struct cell *c , void *data ) , void *data ) {

    int i;

    void rec_map ( struct cell *c ) {
    
        int k;
        
        /* No progeny? */
        if ( !c->split )
            for ( k = 0 ; k < c->count ; k++ )
                fun( &c->parts[k] , c , data );
                
        /* Otherwise, recurse. */
        else
            for ( k = 0 ; k < 8 ; k++ )
                if ( c->progeny[k] != NULL )
                    rec_map( c->progeny[k] );
                
        }
        
    /* Call the recursive function on all higher-level cells. */
    for ( i = 0 ; i < s->nr_cells ; i++ )
        rec_map( &s->cells[i] );

    }


/**
 * @brief Map a function to all particles in a aspace.
 *
 * @param s The #space we are working in.
766
 * @param full Map to all cells, including cells with sub-cells.
Pedro Gonnet's avatar
Pedro Gonnet committed
767
768
 */
 
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
void space_map_cells_post ( struct space *s , int full , void (*fun)( struct cell *c , void *data ) , void *data ) {

    int i;

    void rec_map ( struct cell *c ) {
    
        int k;
        
        /* Recurse. */
        if ( c->split )
            for ( k = 0 ; k < 8 ; k++ )
                if ( c->progeny[k] != NULL )
                    rec_map( c->progeny[k] );
                
        /* No progeny? */
        if ( full || !c->split )
            fun( c , data );
                
        }
        
    /* Call the recursive function on all higher-level cells. */
    for ( i = 0 ; i < s->nr_cells ; i++ )
        rec_map( &s->cells[i] );

    }


void space_map_cells_pre ( struct space *s , int full , void (*fun)( struct cell *c , void *data ) , void *data ) {
Pedro Gonnet's avatar
Pedro Gonnet committed
797
798
799
800
801
802
803
804

    int i;

    void rec_map ( struct cell *c ) {
    
        int k;
        
        /* No progeny? */
805
        if ( full || !c->split )
Pedro Gonnet's avatar
Pedro Gonnet committed
806
807
            fun( c , data );
                
808
809
        /* Recurse. */
        if ( c->split )
Pedro Gonnet's avatar
Pedro Gonnet committed
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
            for ( k = 0 ; k < 8 ; k++ )
                if ( c->progeny[k] != NULL )
                    rec_map( c->progeny[k] );
                
        }
        
    /* Call the recursive function on all higher-level cells. */
    for ( i = 0 ; i < s->nr_cells ; i++ )
        rec_map( &s->cells[i] );

    }


/**
 * @brief Add a #task to the #space.
 *
 * @param s The #space we are working in.
 */
 
829
struct task *space_addtask ( struct space *s , int type , int subtype , int flags , int wait , struct cell *ci , struct cell *cj , int tight ) {
Pedro Gonnet's avatar
Pedro Gonnet committed
830

831
832
833
834
835
836
837
    struct task *t;
    
    /* Lock the space. */
    lock_lock( &s->lock );
    
    /* Get the next free task. */
    t = &s->tasks[ s->nr_tasks ];
Pedro Gonnet's avatar
Pedro Gonnet committed
838
839
840
    
    /* Copy the data. */
    t->type = type;
841
    t->subtype = subtype;
Pedro Gonnet's avatar
Pedro Gonnet committed
842
843
844
845
    t->flags = flags;
    t->wait = wait;
    t->ci = ci;
    t->cj = cj;
846
847
848
849
    t->skip = 0;
    t->tight = 0;
    t->nr_unlock_tasks = 0;
    t->nr_unlock_cells = 0;
Pedro Gonnet's avatar
Pedro Gonnet committed
850
851
852
853
    
    /* Increase the task counter. */
    s->nr_tasks += 1;
    
854
855
856
    /* Unock the space. */
    lock_unlock_blind( &s->lock );
    
Pedro Gonnet's avatar
Pedro Gonnet committed
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
    /* Return a pointer to the new task. */
    return t;

    }



/**
 * @brief Split tasks that may be too large.
 *
 * @param s The #space we are working in.
 */
 
void space_splittasks ( struct space *s ) {

872
    int j, k, sid, tid;
Pedro Gonnet's avatar
Pedro Gonnet committed
873
874
875
    struct cell *ci, *cj;
    double hi, hj, shift[3];
    struct task *t;
876
    float dt_max = s->dt_max;
877
878
879
880
881
    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 } ,
882
883
                      { -1 , -1 , -1 , -1 , -1 , -1 , 11 , 10 } ,
                      { -1 , -1 , -1 , -1 , -1 , -1 , -1 , 12 } };
Pedro Gonnet's avatar
Pedro Gonnet committed
884
885
886
887
888
889

    /* Loop through the tasks... */
    for ( tid = 0 ; tid < s->nr_tasks ; tid++ ) {
    
        /* Get a pointer on the task. */
        t = &s->tasks[tid];
890
891
892
893
894
895
        
        /* Self-interaction? */
        if ( t->type == task_type_self ) {
        
            /* Get a handle on the cell involved. */
            ci = t->ci;
Pedro Gonnet's avatar
Pedro Gonnet committed
896
            
897
898
            /* Ingore this task? */
            if ( ci->dt_min > dt_max ) {
899
                t->skip = 1;
900
901
902
                continue;
                }
            
903
904
905
            /* Is this cell even split? */
            if ( !ci->split )
                continue;
Pedro Gonnet's avatar
Pedro Gonnet committed
906
            
907
            /* Make a sub? */
908
            if ( space_dosub && ci->count < space_subsize ) {
909
910
911
912
913
914
            
                /* convert to a self-subtask. */
                t->type = task_type_sub;
                
                /* Wait for this tasks sorts, as we will now have pairwise
                   components in this sub. */
915
                space_addsorts( s , t , ci , NULL , -1 );
916
917
918
919
920
921
922
923
924
925
926
927
928
929
            
                }
                
            /* Otherwise, make tasks explicitly. */
            else {
            
                /* Take a step back (we're going to recycle the current task)... */
                tid -= 1;

                /* Add the self taks. */
                for ( k = 0 ; ci->progeny[k] == NULL ; k++ );
                t->ci = ci->progeny[k];
                for ( k += 1 ; k < 8 ; k++ )
                    if ( ci->progeny[k] != NULL )
930
                        space_addtask( s , task_type_self , task_subtype_density , 0 , 0 , ci->progeny[k] , NULL , 0 );
931
932
933
            
                /* Make a task for each pair of progeny. */
                for ( j = 0 ; j < 8 ; j++ )
934
                    if ( ci->progeny[j] != NULL )
935
                        for ( k = j + 1 ; k < 8 ; k++ )
936
                            if ( ci->progeny[k] != NULL )
937
                                space_addtask( s , task_type_pair , task_subtype_density , pts[j][k] , 0 , ci->progeny[j] , ci->progeny[k] , 0 );
Pedro Gonnet's avatar
Pedro Gonnet committed
938
                }
939
940
941
942
943
944
945
946
947
        
            }
    
        /* Pair interaction? */
        else if ( t->type == task_type_pair ) {
            
            /* Get a handle on the cells involved. */
            ci = t->ci;
            cj = t->cj;
948
949
            hi = fmin( ci->h[0] , fmin( ci->h[1] , ci->h[2] ) );
            hj = fmin( cj->h[0] , fmin( cj->h[1] , cj->h[2] ) );
950

951
952
            /* Ingore this task? */
            if ( ci->dt_min > dt_max && cj->dt_min > dt_max ) {
953
                t->skip = 1;
954
955
956
957
958
959
960
                continue;
                }
            
            /* 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 , &ci , &cj , shift );
                
961
962
            /* Should this task be split-up? */
            if ( ci->split && cj->split &&
963
                 ci->h_max < hi/2 && cj->h_max < hj/2 ) {
964
965
                 
                /* Replace by a single sub-task? */
966
967
                if ( space_dosub &&
                     ci->count < space_subsize && cj->count < space_subsize &&
968
                     sid != 0 && sid != 2 && sid != 6 && sid != 8 ) {
Pedro Gonnet's avatar
Pedro Gonnet committed
969
                
970
971
972
                    /* Make this task a sub task. */
                    t->type = task_type_sub;
                    t->flags = sid;
973
                    t->ci = ci; t->cj = cj;
Pedro Gonnet's avatar
Pedro Gonnet committed
974
                    
975
976
                    /* Create the sorts recursively. */
                    space_addsorts( s , t , ci , cj , sid );
977
978
979
980
981
982
983
984
985
986
987
988
989
                    
                    /* Don't go any further. */
                    continue;
                
                    }

                /* Take a step back (we're going to recycle the current task)... */
                tid -= 1;

                /* For each different sorting type... */
                switch ( sid ) {

                    case 0: /* (  1 ,  1 ,  1 ) */
990
                        t->ci = ci->progeny[7]; t->cj = cj->progeny[0]; t->flags = 0;
991
992
993
                        break;

                    case 1: /* (  1 ,  1 ,  0 ) */
994
995
996
997
                        t->ci = ci->progeny[6]; t->cj = cj->progeny[0]; t->flags = 1; t->tight = 1;
                        t = space_addtask( s , task_type_pair , t->subtype , 1 , 0 , ci->progeny[7] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 0 , 0 , ci->progeny[6] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 2 , 0 , ci->progeny[7] , cj->progeny[0] , 1 );
998
999
1000
                        break;

                    case 2: /* (  1 ,  1 , -1 ) */
1001
                        t->ci = ci->progeny[6]; t->cj = cj->progeny[1]; t->flags = 2; t->tight = 1;
1002
1003
1004
                        break;

                    case 3: /* (  1 ,  0 ,  1 ) */
1005
1006
1007
1008
                        t->ci = ci->progeny[5]; t->cj = cj->progeny[0]; t->flags = 3; t->tight = 1;
                        t = space_addtask( s , task_type_pair , t->subtype , 3 , 0 , ci->progeny[7] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 0 , 0 , ci->progeny[5] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 6 , 0 , ci->progeny[7] , cj->progeny[0] , 1 );
1009
1010
1011
                        break;

                    case 4: /* (  1 ,  0 ,  0 ) */
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
                        t->ci = ci->progeny[4]; t->cj = cj->progeny[0]; t->flags = 4; t->tight = 1;
                        t = space_addtask( s , task_type_pair , t->subtype , 5 , 0 , ci->progeny[5] , cj->progeny[0] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 7 , 0 , ci->progeny[6] , cj->progeny[0] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 8 , 0 , ci->progeny[7] , cj->progeny[0] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 3 , 0 , ci->progeny[4] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 4 , 0 , ci->progeny[5] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 6 , 0 , ci->progeny[6] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 7 , 0 , ci->progeny[7] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 1 , 0 , ci->progeny[4] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 2 , 0 , ci->progeny[5] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 4 , 0 , ci->progeny[6] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 5 , 0 , ci->progeny[7] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 0 , 0 , ci->progeny[4] , cj->progeny[3] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 1 , 0 , ci->progeny[5] , cj->progeny[3] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 3 , 0 , ci->progeny[6] , cj->progeny[3] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 4 , 0 , ci->progeny[7] , cj->progeny[3] , 1 );
1028
1029
1030
                        break;

                    case 5: /* (  1 ,  0 , -1 ) */
1031
1032
1033
1034
                        t->ci = ci->progeny[4]; t->cj = cj->progeny[1]; t->flags = 5; t->tight = 1;
                        t = space_addtask( s , task_type_pair , t->subtype , 5 , 0 , ci->progeny[6] , cj->progeny[3] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 2 , 0 , ci->progeny[4] , cj->progeny[3] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 8 , 0 , ci->progeny[6] , cj->progeny[1] , 1 );
1035
1036
1037
                        break;

                    case 6: /* (  1 , -1 ,  1 ) */
1038
                        t->ci = ci->progeny[5]; t->cj = cj->progeny[2]; t->flags = 6; t->tight = 1;
1039
1040
1041
                        break;

                    case 7: /* (  1 , -1 ,  0 ) */
1042
1043
1044
1045
                        t->ci = ci->progeny[4]; t->cj = cj->progeny[3]; t->flags = 6; t->tight = 1;
                        t = space_addtask( s , task_type_pair , t->subtype , 8 , 0 , ci->progeny[5] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 7 , 0 , ci->progeny[4] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 7 , 0 , ci->progeny[5] , cj->progeny[3] , 1 );
1046
1047
1048
                        break;

                    case 8: /* (  1 , -1 , -1 ) */
1049
                        t->ci = ci->progeny[4]; t->cj = cj->progeny[3]; t->flags = 8; t->tight = 1;
1050
1051
1052
                        break;

                    case 9: /* (  0 ,  1 ,  1 ) */
1053
1054
1055
1056
                        t->ci = ci->progeny[3]; t->cj = cj->progeny[0]; t->flags = 9; t->tight = 1;
                        t = space_addtask( s , task_type_pair , t->subtype , 9 , 0 , ci->progeny[7] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 0 , 0 , ci->progeny[3] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 8 , 0 , ci->progeny[7] , cj->progeny[0] , 1 );
1057
1058
1059
                        break;

                    case 10: /* (  0 ,  1 ,  0 ) */
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
                        t->ci = ci->progeny[2]; t->cj = cj->progeny[0]; t->flags = 10; t->tight = 1;
                        t = space_addtask( s , task_type_pair , t->subtype , 11 , 0 , ci->progeny[3] , cj->progeny[0] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 7 , 0 , ci->progeny[6] , cj->progeny[0] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 6 , 0 , ci->progeny[7] , cj->progeny[0] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 9 , 0 , ci->progeny[2] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 10 , 0 , ci->progeny[3] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 8 , 0 , ci->progeny[6] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 7 , 0 , ci->progeny[7] , cj->progeny[1] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 1 , 0 , ci->progeny[2] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 2 , 0 , ci->progeny[3] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 10 , 0 , ci->progeny[6] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 11 , 0 , ci->progeny[7] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 0 , 0 , ci->progeny[2] , cj->progeny[5] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 1 , 0 , ci->progeny[3] , cj->progeny[5] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 9 , 0 , ci->progeny[6] , cj->progeny[5] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 10 , 0 , ci->progeny[7] , cj->progeny[5] , 1 );
1076
1077
1078
                        break;

                    case 11: /* (  0 ,  1 , -1 ) */
1079
1080
1081
1082
                        t->ci = ci->progeny[2]; t->cj = cj->progeny[1]; t->flags = 11; t->tight = 1;
                        t = space_addtask( s , task_type_pair , t->subtype , 11 , 0 , ci->progeny[6] , cj->progeny[5] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 2 , 0 , ci->progeny[2] , cj->progeny[5] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 6 , 0 , ci->progeny[6] , cj->progeny[1] , 1 );
1083
1084
1085
                        break;

                    case 12: /* (  0 ,  0 ,  1 ) */
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
                        t->ci = ci->progeny[1]; t->cj = cj->progeny[0]; t->flags = 12; t->tight = 1;
                        t = space_addtask( s , task_type_pair , t->subtype , 11 , 0 , ci->progeny[3] , cj->progeny[0] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 5 , 0 , ci->progeny[5] , cj->progeny[0] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 2 , 0 , ci->progeny[7] , cj->progeny[0] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 9 , 0 , ci->progeny[1] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 12 , 0 , ci->progeny[3] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 8 , 0 , ci->progeny[5] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 5 , 0 , ci->progeny[7] , cj->progeny[2] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 3 , 0 , ci->progeny[1] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 6 , 0 , ci->progeny[3] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 12 , 0 , ci->progeny[5] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 11 , 0 , ci->progeny[7] , cj->progeny[4] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 0 , 0 , ci->progeny[1] , cj->progeny[6] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 3 , 0 , ci->progeny[3] , cj->progeny[6] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 9 , 0 , ci->progeny[5] , cj->progeny[6] , 1 );
                        t = space_addtask( s , task_type_pair , t->subtype , 12 , 0 , ci->progeny[7] , cj->progeny[6] , 1 );
1102
1103
1104
1105
1106
                        break;

                    }

                } /* split this task? */
Pedro Gonnet's avatar
Pedro Gonnet committed
1107
                
1108
1109
1110
1111
1112
            /* Otherwise, if not spilt, stitch-up the sorting. */
            else {
            
                /* Create the sort for ci. */
                if ( ci->sorts[0] == NULL )
1113
                    ci->sorts[0] = space_addtask( s , task_type_sort , 0 , 1 << sid , 0 , ci , NULL , 0 );
1114
1115
1116
1117
1118
                ci->sorts[0]->flags |= (1 << sid);
                task_addunlock( ci->sorts[0] , t );
                
                /* Create the sort for cj. */
                if ( cj->sorts[0] == NULL )
1119
                    cj->sorts[0] = space_addtask( s , task_type_sort , 0 , 1 << sid , 0 , cj , NULL , 0 );
1120
1121
1122
1123
1124
                cj->sorts[0]->flags |= (1 << sid);
                task_addunlock( cj->sorts[0] , t );
                
                }
                
1125
            } /* pair interaction? */
Pedro Gonnet's avatar
Pedro Gonnet committed
1126
1127
1128
1129
1130
1131
1132
    
        } /* loop over all tasks. */
        
    }
    
    
/**
1133
 * @brief Generate the sorts for a sub recursively.
Pedro Gonnet's avatar
Pedro Gonnet committed
1134
1135
1136
1137
 *
 * @param s The #space we are working in.
 */
 
1138
void space_addsorts ( struct space *s , struct task *t , struct cell *ci , struct cell *cj , int sid ) {
Pedro Gonnet's avatar
Pedro Gonnet committed
1139

1140
1141
1142
    float h;
    double shift[3];
    int j, k;
Pedro Gonnet's avatar
Pedro Gonnet committed
1143

1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
    /* Get the cell dimensions. */
    h = fmin( ci->h[0] , fmin( ci->h[1] , ci->h[2] ) );
    
    /* Single-cell sub? */
    if ( cj == NULL ) {
    
        /* If there is further splitting, add the pairs recursively. */
        if ( ci->split ) {
        
            /* Recurse for each progeny. */
            for ( j = 0 ; j < 8 ; j++ )
                if ( ci->progeny[j] != NULL )
                    space_addsorts( s , t , ci->progeny[j] , NULL , -1 );

            /* Recurse for each pair of progeny. */
            for ( j = 0 ; j < 8 ; j++ )
                if ( ci->progeny[j] != NULL )
                    for ( k = j + 1 ; k < 8 ; k++ )
                        if ( ci->progeny[k] != NULL )
                            space_addsorts( s , t , ci->progeny[j] , ci->progeny[k] , -1 );
Pedro Gonnet's avatar
Pedro Gonnet committed
1164

1165
            }
Pedro Gonnet's avatar
Pedro Gonnet committed
1166

1167
        }
Pedro Gonnet's avatar
Pedro Gonnet committed
1168
        
1169
1170
    /* Otherwise, it's a pair. */
    else {
Pedro Gonnet's avatar
Pedro Gonnet committed
1171
        
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
        /* Get the sort ID if not specified. */
        // if ( sid < 0 )
            sid = space_getsid( s , &ci , &cj , shift );
        
        /* If there is no further splitting, add the sorts. */
        if ( !ci->split || !cj->split ||
             ci->h_max*2 >= h || cj->h_max*2 >= h ) {
            
            /* Create and add the sort for ci. */
            if ( ci->sorts[0] == NULL )
1182
                ci->sorts[0] = space_addtask( s , task_type_sort , 0 , 1 << sid , 0 , ci , NULL , 0 );
1183
1184
1185
1186
1187
            ci->sorts[0]->flags |= (1 << sid);
            task_addunlock( ci->sorts[0] , t );
            
            /* Create and add the sort for cj. */
            if ( cj->sorts[0] == NULL )
1188
                cj->sorts[0] = space_addtask( s , task_type_sort , 0 , 1 << sid , 0 , cj , NULL , 0 );
1189
1190
            cj->sorts[0]->flags |= (1 << sid);
            task_addunlock( cj->sorts[0] , t );
Pedro Gonnet's avatar
Pedro Gonnet committed
1191
1192

            }
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317

        /* Otherwise, recurse. */
        else {
                
            /* For each different sorting type... */
            switch ( sid ) {

                case 0: /* (  1 ,  1 ,  1 ) */
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[0] , 0 );
                    break;

                case 1: /* (  1 ,  1 ,  0 ) */
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[0] , 1 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[1] , 1 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[1] , 0 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[0] , 2 );
                    break;

                case 2: /* (  1 ,  1 , -1 ) */
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[1] , 2 );
                    break;

                case 3: /* (  1 ,  0 ,  1 ) */
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[0] , 3 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[2] , 3 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[2] , 0 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[0] , 6 );
                    break;

                case 4: /* (  1 ,  0 ,  0 ) */
                    space_addsorts( s , t , ci->progeny[4] , cj->progeny[0] , 4 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[0] , 5 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[0] , 7 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[0] , 8 );
                    space_addsorts( s , t , ci->progeny[4] , cj->progeny[1] , 3 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[1] , 4 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[1] , 6 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[1] , 7 );
                    space_addsorts( s , t , ci->progeny[4] , cj->progeny[2] , 1 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[2] , 2 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[2] , 4 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[2] , 5 );
                    space_addsorts( s , t , ci->progeny[4] , cj->progeny[3] , 0 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[3] , 1 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[3] , 3 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[3] , 4 );
                    break;

                case 5: /* (  1 ,  0 , -1 ) */
                    space_addsorts( s , t , ci->progeny[4] , cj->progeny[1] , 5 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[3] , 5 );
                    space_addsorts( s , t , ci->progeny[4] , cj->progeny[3] , 2 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[1] , 8 );
                    break;

                case 6: /* (  1 , -1 ,  1 ) */
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[2] , 6 );
                    break;

                case 7: /* (  1 , -1 ,  0 ) */
                    space_addsorts( s , t , ci->progeny[4] , cj->progeny[3] , 6 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[2] , 8 );
                    space_addsorts( s , t , ci->progeny[4] , cj->progeny[2] , 7 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[3] , 7 );
                    break;

                case 8: /* (  1 , -1 , -1 ) */
                    space_addsorts( s , t , ci->progeny[4] , cj->progeny[3] , 8 );
                    break;

                case 9: /* (  0 ,  1 ,  1 ) */
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[0] , 9 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[4] , 9 );
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[4] , 0 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[0] , 8 );
                    break;

                case 10: /* (  0 ,  1 ,  0 ) */
                    space_addsorts( s , t , ci->progeny[2] , cj->progeny[0] , 10 );
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[0] , 11 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[0] , 7 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[0] , 6 );
                    space_addsorts( s , t , ci->progeny[2] , cj->progeny[1] , 9 );
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[1] , 10 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[1] , 8 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[1] , 7 );
                    space_addsorts( s , t , ci->progeny[2] , cj->progeny[4] , 1 );
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[4] , 2 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[4] , 10 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[4] , 11 );
                    space_addsorts( s , t , ci->progeny[2] , cj->progeny[5] , 0 );
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[5] , 1 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[5] , 9 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[5] , 10 );
                    break;

                case 11: /* (  0 ,  1 , -1 ) */
                    space_addsorts( s , t , ci->progeny[2] , cj->progeny[1] , 11 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[5] , 11 );
                    space_addsorts( s , t , ci->progeny[2] , cj->progeny[5] , 2 );
                    space_addsorts( s , t , ci->progeny[6] , cj->progeny[1] , 6 );
                    break;

                case 12: /* (  0 ,  0 ,  1 ) */
                    space_addsorts( s , t , ci->progeny[1] , cj->progeny[0] , 12 );
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[0] , 11 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[0] , 5 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[0] , 2 );
                    space_addsorts( s , t , ci->progeny[1] , cj->progeny[2] , 9 );
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[2] , 12 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[2] , 8 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[2] , 5 );
                    space_addsorts( s , t , ci->progeny[1] , cj->progeny[4] , 3 );
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[4] , 6 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[4] , 12 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[4] , 11 );
                    space_addsorts( s , t , ci->progeny[1] , cj->progeny[6] , 0 );
                    space_addsorts( s , t , ci->progeny[3] , cj->progeny[6] , 3 );
                    space_addsorts( s , t , ci->progeny[5] , cj->progeny[6] , 9 );
                    space_addsorts( s , t , ci->progeny[7] , cj->progeny[6] , 12 );
                    break;

                } /* switch. */

            } /* recurse. */
Pedro Gonnet's avatar
Pedro Gonnet committed
1318
            
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
        } /* it's a pair. */

    }
    
    
/**
 * @brief Fill the #space's task list.
 *
 * @param s The #space we are working in.
 * @param do_sort Flag to add sorting tasks to the list.
 */
 
void space_maketasks ( struct space *s , int do_sort ) {

    int i, j, k, ii, jj, kk, iii, jjj, kkk, cid, cjd, sid;
    int *cdim = s->cdim;
    struct task *t, *t2;
    struct cell *ci, *cj;
    // float dt_max = s->dt_max;
Pedro Gonnet's avatar
Pedro Gonnet committed
1338
1339

    /* Allocate the task-list, if needed. */
1340
    if ( s->tasks == NULL || s->tasks_size < s->tot_cells * space_maxtaskspercell ) {
1341
1342
1343
1344
        if ( s->tasks != NULL )
            free( s->tasks );
        if ( s->tasks_ind != NULL )
            free( s->tasks_ind );
1345
        s->tasks_size = s->tot_cells * space_maxtaskspercell;
1346
        if ( posix_memalign( (void *)&s->tasks , 64 , sizeof(struct task) * s->tasks_size ) != 0 )
Pedro Gonnet's avatar
Pedro Gonnet committed
1347
            error( "Failed to allocate task list." );
1348
1349
1350
        if ( ( s->tasks_ind = (int *)malloc( sizeof(int) * s->tasks_size ) ) == NULL )
            error( "Failed to allocate task indices." );
        }
Pedro Gonnet's avatar
Pedro Gonnet committed
1351
1352
1353
1354
1355
1356
1357
1358
1359
    s->nr_tasks = 0;
    
    /* Run through the highest level of cells and add pairs. */
    for ( i = 0 ; i < cdim[0] ; i++ )
        for ( j = 0 ; j < cdim[1] ; j++ )
            for ( k = 0 ; k < cdim[2] ; k++ ) {
                cid = cell_getid( cdim , i , j , k );
                if ( s->cells[cid].count == 0 )
                    continue;
1360
1361
1362
1363
                ci = &s->cells[cid];
                if ( ci->count == 0 )
                    continue;
                // if ( ci->dt_min <= dt_max )
1364
                    space_addtask( s , task_type_self , task_subtype_density , 0 , 0 , ci , NULL , 0 );
Pedro Gonnet's avatar
Pedro Gonnet committed
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
                for ( ii = -1 ; ii < 2 ; ii++ ) {
                    iii = i + ii;
                    if ( !s->periodic && ( iii < 0 || iii >= cdim[0] ) )
                        continue;
                    iii = ( iii + cdim[0] ) % cdim[0];
                    for ( jj = -1 ; jj < 2 ; jj++ ) {
                        jjj = j + jj;
                        if ( !s->periodic && ( jjj < 0 || jjj >= cdim[1] ) )
                            continue;
                        jjj = ( jjj + cdim[1] ) % cdim[1];
                        for ( kk = -1 ; kk < 2 ; kk++ ) {
                            kkk = k + kk;
                            if ( !s->periodic && ( kkk < 0 || kkk >= cdim[2] ) )
                                continue;
                            kkk = ( kkk + cdim[2] ) % cdim[2];
                            cjd = cell_getid( cdim , iii , jjj , kkk );
1381
1382
1383
                            cj = &s->cells[cjd];
                            if ( cid >= cjd || cj->count == 0 /* ||
                                 ( ci->dt_min > dt_max && cj->dt_min > dt_max ) */ )
Pedro Gonnet's avatar
Pedro Gonnet committed
1384
                                continue;
1385
                            sid = sortlistID[ (kk+1) + 3*( (jj+1) + 3*(ii+1) ) ];
1386
                            t = space_addtask( s , task_type_pair , task_subtype_density , sid , 0 , ci , cj , 1 );
Pedro Gonnet's avatar
Pedro Gonnet committed
1387
1388
1389
1390
1391
1392
1393
                            }
                        }
                    }
                }

    /* Split the tasks. */
    space_splittasks( s );
1394
    
1395
    /* Make each sort depend on the sorts of its progeny. */