runner_doiact_vec.c 36.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/*******************************************************************************
 * This file is part of SWIFT.
 * Copyright (c) 2016 James Willis (james.s.willis@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"

/* This object's header. */
#include "runner_doiact_vec.h"

26
27
28
/* Local headers. */
#include "active.h"

James Willis's avatar
James Willis committed
29
#ifdef WITH_VECTORIZATION
James Willis's avatar
James Willis committed
30
31
32
/**
 * @brief Compute the vector remainder interactions from the secondary cache.
 *
Matthieu Schaller's avatar
Matthieu Schaller committed
33
 * @param int_cache (return) secondary #cache of interactions between two
James Willis's avatar
James Willis committed
34
 * particles.
James Willis's avatar
James Willis committed
35
 * @param icount Interaction count.
Matthieu Schaller's avatar
Matthieu Schaller committed
36
 * @param rhoSum (return) #vector holding the cumulative sum of the density
James Willis's avatar
James Willis committed
37
 * update on pi.
Matthieu Schaller's avatar
Matthieu Schaller committed
38
 * @param rho_dhSum (return) #vector holding the cumulative sum of the density
James Willis's avatar
James Willis committed
39
 * gradient update on pi.
Matthieu Schaller's avatar
Matthieu Schaller committed
40
 * @param wcountSum (return) #vector holding the cumulative sum of the wcount
James Willis's avatar
James Willis committed
41
 * update on pi.
Matthieu Schaller's avatar
Matthieu Schaller committed
42
 * @param wcount_dhSum (return) #vector holding the cumulative sum of the wcount
James Willis's avatar
James Willis committed
43
 * gradient update on pi.
Matthieu Schaller's avatar
Matthieu Schaller committed
44
 * @param div_vSum (return) #vector holding the cumulative sum of the divergence
James Willis's avatar
James Willis committed
45
 * update on pi.
Matthieu Schaller's avatar
Matthieu Schaller committed
46
 * @param curlvxSum (return) #vector holding the cumulative sum of the curl of
James Willis's avatar
James Willis committed
47
 * vx update on pi.
Matthieu Schaller's avatar
Matthieu Schaller committed
48
 * @param curlvySum (return) #vector holding the cumulative sum of the curl of
James Willis's avatar
James Willis committed
49
 * vy update on pi.
Matthieu Schaller's avatar
Matthieu Schaller committed
50
 * @param curlvzSum (return) #vector holding the cumulative sum of the curl of
James Willis's avatar
James Willis committed
51
 * vz update on pi.
James Willis's avatar
James Willis committed
52
53
54
55
 * @param v_hi_inv #vector of 1/h for pi.
 * @param v_vix #vector of x velocity of pi.
 * @param v_viy #vector of y velocity of pi.
 * @param v_viz #vector of z velocity of pi.
Matthieu Schaller's avatar
Matthieu Schaller committed
56
 * @param icount_align (return) Interaction count after the remainder
James Willis's avatar
James Willis committed
57
 * interactions have been performed, should be a multiple of the vector length.
James Willis's avatar
James Willis committed
58
 */
James Willis's avatar
James Willis committed
59
__attribute__((always_inline)) INLINE static void calcRemInteractions(
Matthieu Schaller's avatar
Matthieu Schaller committed
60
61
62
63
64
    struct c2_cache *const int_cache, const int icount, vector *rhoSum,
    vector *rho_dhSum, vector *wcountSum, vector *wcount_dhSum,
    vector *div_vSum, vector *curlvxSum, vector *curlvySum, vector *curlvzSum,
    vector v_hi_inv, vector v_vix, vector v_viy, vector v_viz,
    int *icount_align) {
65
66
67
68
69

#ifdef HAVE_AVX512_F
  KNL_MASK_16 knl_mask, knl_mask2;
#endif
  vector int_mask, int_mask2;
James Willis's avatar
James Willis committed
70
71

  /* Work out the number of remainder interactions and pad secondary cache. */
72
73
74
75
76
77
  *icount_align = icount;
  int rem = icount % (NUM_VEC_PROC * VEC_SIZE);
  if (rem != 0) {
    int pad = (NUM_VEC_PROC * VEC_SIZE) - rem;
    *icount_align += pad;

James Willis's avatar
James Willis committed
78
/* Initialise masks to true. */
79
80
81
82
83
84
85
86
87
#ifdef HAVE_AVX512_F
    knl_mask = 0xFFFF;
    knl_mask2 = 0xFFFF;
    int_mask.m = vec_setint1(0xFFFFFFFF);
    int_mask2.m = vec_setint1(0xFFFFFFFF);
#else
    int_mask.m = vec_setint1(0xFFFFFFFF);
    int_mask2.m = vec_setint1(0xFFFFFFFF);
#endif
James Willis's avatar
James Willis committed
88
89
90
    /* Pad secondary cache so that there are no contributions in the interaction
     * function. */
    for (int i = icount; i < *icount_align; i++) {
91
92
93
94
95
96
97
98
      int_cache->mq[i] = 0.f;
      int_cache->r2q[i] = 1.f;
      int_cache->dxq[i] = 0.f;
      int_cache->dyq[i] = 0.f;
      int_cache->dzq[i] = 0.f;
      int_cache->vxq[i] = 0.f;
      int_cache->vyq[i] = 0.f;
      int_cache->vzq[i] = 0.f;
99
100
101
102
103
104
105
    }

    /* Zero parts of mask that represent the padded values.*/
    if (pad < VEC_SIZE) {
#ifdef HAVE_AVX512_F
      knl_mask2 = knl_mask2 >> pad;
#else
James Willis's avatar
James Willis committed
106
      for (int i = VEC_SIZE - pad; i < VEC_SIZE; i++) int_mask2.i[i] = 0;
107
#endif
James Willis's avatar
James Willis committed
108
    } else {
109
110
111
112
#ifdef HAVE_AVX512_F
      knl_mask = knl_mask >> (VEC_SIZE - rem);
      knl_mask2 = 0;
#else
James Willis's avatar
James Willis committed
113
      for (int i = rem; i < VEC_SIZE; i++) int_mask.i[i] = 0;
114
115
116
117
      int_mask2.v = vec_setzero();
#endif
    }

James Willis's avatar
James Willis committed
118
119
    /* Perform remainder interaction and remove remainder from aligned
     * interaction count. */
120
    *icount_align = icount - rem;
James Willis's avatar
James Willis committed
121
122
123
124
125
126
127
128
    runner_iact_nonsym_2_vec_density(
        &int_cache->r2q[*icount_align], &int_cache->dxq[*icount_align],
        &int_cache->dyq[*icount_align], &int_cache->dzq[*icount_align],
        v_hi_inv, v_vix, v_viy, v_viz, &int_cache->vxq[*icount_align],
        &int_cache->vyq[*icount_align], &int_cache->vzq[*icount_align],
        &int_cache->mq[*icount_align], rhoSum, rho_dhSum, wcountSum,
        wcount_dhSum, div_vSum, curlvxSum, curlvySum, curlvzSum, int_mask,
        int_mask2,
129
#ifdef HAVE_AVX512_F
James Willis's avatar
James Willis committed
130
        knl_mask, knl_mask2);
131
#else
James Willis's avatar
James Willis committed
132
        0, 0);
133
134
135
136
#endif
  }
}

James Willis's avatar
James Willis committed
137
/**
James Willis's avatar
James Willis committed
138
139
 * @brief Left-packs the values needed by an interaction into the secondary
 * cache (Supports AVX, AVX2 and AVX512 instruction sets).
James Willis's avatar
James Willis committed
140
141
 *
 * @param mask Contains which particles need to interact.
Matthieu Schaller's avatar
Matthieu Schaller committed
142
 * @param pjd Index of the particle to store into.
James Willis's avatar
James Willis committed
143
144
145
146
147
148
149
150
151
 * @param v_r2 #vector of the separation between two particles squared.
 * @param v_dx #vector of the x separation between two particles.
 * @param v_dy #vector of the y separation between two particles.
 * @param v_dz #vector of the z separation between two particles.
 * @param v_mj #vector of the mass of particle pj.
 * @param v_vjx #vector of x velocity of pj.
 * @param v_vjy #vector of y velocity of pj.
 * @param v_vjz #vector of z velocity of pj.
 * @param cell_cache #cache of all particles in the cell.
Matthieu Schaller's avatar
Matthieu Schaller committed
152
 * @param int_cache (return) secondary #cache of interactions between two
James Willis's avatar
James Willis committed
153
 * particles.
James Willis's avatar
James Willis committed
154
155
 * @param icount Interaction count.
 * @param rhoSum #vector holding the cumulative sum of the density update on pi.
James Willis's avatar
James Willis committed
156
157
158
159
160
161
162
163
164
165
166
167
168
169
 * @param rho_dhSum #vector holding the cumulative sum of the density gradient
 * update on pi.
 * @param wcountSum #vector holding the cumulative sum of the wcount update on
 * pi.
 * @param wcount_dhSum #vector holding the cumulative sum of the wcount gradient
 * update on pi.
 * @param div_vSum #vector holding the cumulative sum of the divergence update
 * on pi.
 * @param curlvxSum #vector holding the cumulative sum of the curl of vx update
 * on pi.
 * @param curlvySum #vector holding the cumulative sum of the curl of vy update
 * on pi.
 * @param curlvzSum #vector holding the cumulative sum of the curl of vz update
 * on pi.
James Willis's avatar
James Willis committed
170
171
172
173
174
 * @param v_hi_inv #vector of 1/h for pi.
 * @param v_vix #vector of x velocity of pi.
 * @param v_viy #vector of y velocity of pi.
 * @param v_viz #vector of z velocity of pi.
 */
James Willis's avatar
James Willis committed
175
176
177
178
179
180
181
182
183
184
185
__attribute__((always_inline)) INLINE static void storeInteractions(
    const int mask, const int pjd, vector *v_r2, vector *v_dx, vector *v_dy,
    vector *v_dz, vector *v_mj, vector *v_vjx, vector *v_vjy, vector *v_vjz,
    const struct cache *const cell_cache, struct c2_cache *const int_cache,
    int *icount, vector *rhoSum, vector *rho_dhSum, vector *wcountSum,
    vector *wcount_dhSum, vector *div_vSum, vector *curlvxSum,
    vector *curlvySum, vector *curlvzSum, vector v_hi_inv, vector v_vix,
    vector v_viy, vector v_viz) {

/* Left-pack values needed into the secondary cache using the interaction mask.
 */
186
187
188
189
190
#if defined(HAVE_AVX2) || defined(HAVE_AVX512_F)
  int pack = 0;

#ifdef HAVE_AVX512_F
  pack += __builtin_popcount(mask);
James Willis's avatar
James Willis committed
191
192
193
194
195
196
197
198
  VEC_LEFT_PACK(v_r2->v, mask, &int_cache->r2q[*icount]);
  VEC_LEFT_PACK(v_dx->v, mask, &int_cache->dxq[*icount]);
  VEC_LEFT_PACK(v_dy->v, mask, &int_cache->dyq[*icount]);
  VEC_LEFT_PACK(v_dz->v, mask, &int_cache->dzq[*icount]);
  VEC_LEFT_PACK(v_mj->v, mask, &int_cache->mq[*icount]);
  VEC_LEFT_PACK(v_vjx->v, mask, &int_cache->vxq[*icount]);
  VEC_LEFT_PACK(v_vjy->v, mask, &int_cache->vyq[*icount]);
  VEC_LEFT_PACK(v_vjz->v, mask, &int_cache->vzq[*icount]);
199
200
#else
  vector v_mask;
James Willis's avatar
James Willis committed
201
202
203
204
205
206
207
208
209
210
  VEC_FORM_PACKED_MASK(mask, v_mask.m, pack);

  VEC_LEFT_PACK(v_r2->v, v_mask.m, &int_cache->r2q[*icount]);
  VEC_LEFT_PACK(v_dx->v, v_mask.m, &int_cache->dxq[*icount]);
  VEC_LEFT_PACK(v_dy->v, v_mask.m, &int_cache->dyq[*icount]);
  VEC_LEFT_PACK(v_dz->v, v_mask.m, &int_cache->dzq[*icount]);
  VEC_LEFT_PACK(v_mj->v, v_mask.m, &int_cache->mq[*icount]);
  VEC_LEFT_PACK(v_vjx->v, v_mask.m, &int_cache->vxq[*icount]);
  VEC_LEFT_PACK(v_vjy->v, v_mask.m, &int_cache->vyq[*icount]);
  VEC_LEFT_PACK(v_vjz->v, v_mask.m, &int_cache->vzq[*icount]);
211

212
#endif /* HAVE_AVX512_F */
213
214
215

  (*icount) += pack;
#else
James Willis's avatar
James Willis committed
216
  /* Quicker to do it serially in AVX rather than use intrinsics. */
James Willis's avatar
James Willis committed
217
  for (int bit_index = 0; bit_index < VEC_SIZE; bit_index++) {
218
219
    if (mask & (1 << bit_index)) {
      /* Add this interaction to the queue. */
220
221
222
223
224
225
226
227
      int_cache->r2q[*icount] = v_r2->f[bit_index];
      int_cache->dxq[*icount] = v_dx->f[bit_index];
      int_cache->dyq[*icount] = v_dy->f[bit_index];
      int_cache->dzq[*icount] = v_dz->f[bit_index];
      int_cache->mq[*icount] = cell_cache->m[pjd + bit_index];
      int_cache->vxq[*icount] = cell_cache->vx[pjd + bit_index];
      int_cache->vyq[*icount] = cell_cache->vy[pjd + bit_index];
      int_cache->vzq[*icount] = cell_cache->vz[pjd + bit_index];
228
229
230
231

      (*icount)++;
    }
  }
232

James Willis's avatar
James Willis committed
233
234
#endif /* defined(HAVE_AVX2) || defined(HAVE_AVX512_F) */

James Willis's avatar
James Willis committed
235
  /* Flush the c2 cache if it has reached capacity. */
James Willis's avatar
James Willis committed
236
  if (*icount >= (C2_CACHE_SIZE - (NUM_VEC_PROC * VEC_SIZE))) {
237
238

    int icount_align = *icount;
James Willis's avatar
James Willis committed
239

James Willis's avatar
James Willis committed
240
    /* Peform remainder interactions. */
Matthieu Schaller's avatar
Matthieu Schaller committed
241
242
243
    calcRemInteractions(int_cache, *icount, rhoSum, rho_dhSum, wcountSum,
                        wcount_dhSum, div_vSum, curlvxSum, curlvySum, curlvzSum,
                        v_hi_inv, v_vix, v_viy, v_viz, &icount_align);
244
245
246
247

    vector int_mask, int_mask2;
    int_mask.m = vec_setint1(0xFFFFFFFF);
    int_mask2.m = vec_setint1(0xFFFFFFFF);
James Willis's avatar
James Willis committed
248
249

    /* Perform interactions. */
James Willis's avatar
James Willis committed
250
251
252
253
254
255
256
    for (int pjd = 0; pjd < icount_align; pjd += (NUM_VEC_PROC * VEC_SIZE)) {
      runner_iact_nonsym_2_vec_density(
          &int_cache->r2q[pjd], &int_cache->dxq[pjd], &int_cache->dyq[pjd],
          &int_cache->dzq[pjd], v_hi_inv, v_vix, v_viy, v_viz,
          &int_cache->vxq[pjd], &int_cache->vyq[pjd], &int_cache->vzq[pjd],
          &int_cache->mq[pjd], rhoSum, rho_dhSum, wcountSum, wcount_dhSum,
          div_vSum, curlvxSum, curlvySum, curlvzSum, int_mask, int_mask2, 0, 0);
257
    }
James Willis's avatar
James Willis committed
258
259

    /* Reset interaction count. */
260
261
262
    *icount = 0;
  }
}
263

264
265
/**
 * @brief Populates the arrays max_di and max_dj with the maximum distances of
James Willis's avatar
James Willis committed
266
267
268
 * particles into their neighbouring cells. Also finds the first pi that
 * interacts with any particle in cj and the last pj that interacts with any
 * particle in ci.
269
 *
James Willis's avatar
James Willis committed
270
271
272
273
274
275
 * @param ci #cell pointer to ci
 * @param cj #cell pointer to cj
 * @param sort_i #entry array for particle distance in ci
 * @param sort_j #entry array for particle distance in cj
 * @param dx_max maximum particle movement allowed in cell
 * @param rshift cutoff shift
276
277
278
279
 * @param hi_max Maximal smoothing length in cell ci
 * @param hj_max Maximal smoothing length in cell cj
 * @param di_max Maximal position on the axis that can interact in cell ci
 * @param dj_min Minimal position on the axis that can interact in cell ci
James Willis's avatar
James Willis committed
280
281
282
283
 * @param max_di array to hold the maximum distances of pi particles into cell
 * cj
 * @param max_dj array to hold the maximum distances of pj particles into cell
 * cj
James Willis's avatar
James Willis committed
284
285
 * @param init_pi first pi to interact with a pj particle
 * @param init_pj last pj to interact with a pi particle
286
 * @param e The #engine.
James Willis's avatar
James Willis committed
287
 */
James Willis's avatar
James Willis committed
288
289
290
__attribute__((always_inline)) INLINE static void populate_max_d_no_cache(
    const struct cell *ci, const struct cell *cj,
    const struct entry *restrict sort_i, const struct entry *restrict sort_j,
291
292
293
294
    const float dx_max, const float rshift, const double hi_max,
    const double hj_max, const double di_max, const double dj_min,
    float *max_di, float *max_dj, int *init_pi, int *init_pj,
    const struct engine *e) {
295

296
297
  const struct part *restrict parts_i = ci->parts;
  const struct part *restrict parts_j = cj->parts;
James Willis's avatar
James Willis committed
298

299
300
  int first_pi = 0, last_pj = cj->count - 1;

Matthieu Schaller's avatar
Matthieu Schaller committed
301
302
  /* Find the first active particle in ci to interact with any particle in cj.
   */
303
304
305
  /* Populate max_di with distances. */
  int active_id = ci->count - 1;
  for (int k = ci->count - 1; k >= 0; k--) {
306
307
    const struct part *pi = &parts_i[sort_i[k].i];
    const float d = sort_i[k].d + dx_max;
James Willis's avatar
James Willis committed
308

309
    // max_di[k] = d + h * kernel_gamma - rshift;
310
    max_di[k] = d + hi_max;
311

Matthieu Schaller's avatar
Matthieu Schaller committed
312
    /* If the particle is out of range set the index to
313
     * the last active particle within range. */
314
    if (d + hi_max < dj_min) {
315
316
      first_pi = active_id;
      break;
Matthieu Schaller's avatar
Matthieu Schaller committed
317
    } else {
318
      if (part_is_active(pi, e)) active_id = k;
319
320
321
    }
  }

322
  /* Find the maximum distance of pi particles into cj.*/
323
  for (int k = first_pi + 1; k < ci->count; k++) {
Matthieu Schaller's avatar
Matthieu Schaller committed
324
    max_di[k] = fmaxf(max_di[k - 1], max_di[k]);
325
  }
James Willis's avatar
James Willis committed
326

327
  /* Find the last particle in cj to interact with any particle in ci. */
328
329
330
  /* Populate max_dj with distances. */
  active_id = 0;
  for (int k = 0; k < cj->count; k++) {
331
332
    const struct part *pj = &parts_j[sort_j[k].i];
    const float d = sort_j[k].d - dx_max;
Matthieu Schaller's avatar
Matthieu Schaller committed
333

334
    /*TODO: don't think rshift should be taken off here, waiting on Pedro. */
335
    // max_dj[k] = d - h * kernel_gamma - rshift;
336
    max_dj[k] = d - hj_max;
Matthieu Schaller's avatar
Matthieu Schaller committed
337
338

    /* If the particle is out of range set the index to
339
     * the last active particle within range. */
340
    if (d - hj_max > di_max) {
341
      last_pj = active_id;
342
      break;
Matthieu Schaller's avatar
Matthieu Schaller committed
343
    } else {
344
      if (part_is_active(pj, e)) active_id = k;
345
346
347
348
349
350
    }
  }

  /* Find the maximum distance of pj particles into ci.*/
  for (int k = 1; k <= last_pj; k++) {
    max_dj[k] = fmaxf(max_dj[k - 1], max_dj[k]);
351
352
  }

James Willis's avatar
James Willis committed
353
354
  *init_pi = first_pi;
  *init_pj = last_pj;
355
}
James Willis's avatar
James Willis committed
356
#endif /* WITH_VECTORIZATION */
357
358

/**
James Willis's avatar
James Willis committed
359
360
 * @brief Compute the cell self-interaction (non-symmetric) using vector
 * intrinsics with one particle pi at a time.
361
362
363
364
 *
 * @param r The #runner.
 * @param c The #cell.
 */
James Willis's avatar
James Willis committed
365
366
__attribute__((always_inline)) INLINE void runner_doself1_density_vec(
    struct runner *r, struct cell *restrict c) {
367
368

#ifdef WITH_VECTORIZATION
369
  const struct engine *e = r->e;
370
371
372
373
374
375
376
  int doi_mask;
  struct part *restrict pi;
  int count_align;
  int num_vec_proc = NUM_VEC_PROC;

  struct part *restrict parts = c->parts;
  const int count = c->count;
James Willis's avatar
James Willis committed
377

378
379
  vector v_hi, v_vix, v_viy, v_viz, v_hig2, v_r2;

James Willis's avatar
James Willis committed
380
  TIMER_TIC
381

382
383
  if (!cell_is_active(c, e)) return;

384
  if (!cell_are_part_drifted(c, e)) error("Interacting undrifted cell.");
385

James Willis's avatar
James Willis committed
386
  /* Get the particle cache from the runner and re-allocate
387
   * the cache if it is not big enough for the cell. */
388
  struct cache *restrict cell_cache = &r->ci_cache;
James Willis's avatar
James Willis committed
389
390
391

  if (cell_cache->count < count) {
    cache_init(cell_cache, count);
392
393
  }

James Willis's avatar
James Willis committed
394
  /* Read the particles from the cell and store them locally in the cache. */
James Willis's avatar
James Willis committed
395
  cache_read_particles(c, cell_cache);
396
397
398
399

  /* Create secondary cache to store particle interactions. */
  struct c2_cache int_cache;
  int icount = 0, icount_align = 0;
400
401
402
403
404
405
406
407

  /* Loop over the particles in the cell. */
  for (int pid = 0; pid < count; pid++) {

    /* Get a pointer to the ith particle. */
    pi = &parts[pid];

    /* Is the ith particle active? */
408
    if (!part_is_active(pi, e)) continue;
409
410
411
412
413

    vector pix, piy, piz;

    const float hi = cell_cache->h[pid];

James Willis's avatar
James Willis committed
414
    /* Fill particle pi vectors. */
415
416
417
418
419
420
421
422
423
424
425
    pix.v = vec_set1(cell_cache->x[pid]);
    piy.v = vec_set1(cell_cache->y[pid]);
    piz.v = vec_set1(cell_cache->z[pid]);
    v_hi.v = vec_set1(hi);
    v_vix.v = vec_set1(cell_cache->vx[pid]);
    v_viy.v = vec_set1(cell_cache->vy[pid]);
    v_viz.v = vec_set1(cell_cache->vz[pid]);

    const float hig2 = hi * hi * kernel_gamma2;
    v_hig2.v = vec_set1(hig2);

James Willis's avatar
James Willis committed
426
    /* Reset cumulative sums of update vectors. */
James Willis's avatar
James Willis committed
427
428
429
    vector rhoSum, rho_dhSum, wcountSum, wcount_dhSum, div_vSum, curlvxSum,
        curlvySum, curlvzSum;

James Willis's avatar
James Willis committed
430
    /* Get the inverse of hi. */
431
    vector v_hi_inv;
James Willis's avatar
James Willis committed
432

433
    v_hi_inv = vec_reciprocal(v_hi);
James Willis's avatar
James Willis committed
434

435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
    rhoSum.v = vec_setzero();
    rho_dhSum.v = vec_setzero();
    wcountSum.v = vec_setzero();
    wcount_dhSum.v = vec_setzero();
    div_vSum.v = vec_setzero();
    curlvxSum.v = vec_setzero();
    curlvySum.v = vec_setzero();
    curlvzSum.v = vec_setzero();

    /* Pad cache if there is a serial remainder. */
    count_align = count;
    int rem = count % (num_vec_proc * VEC_SIZE);
    if (rem != 0) {
      int pad = (num_vec_proc * VEC_SIZE) - rem;

      count_align += pad;
451
452
453
454
455
456
457
458

      /* Set positions to the same as particle pi so when the r2 > 0 mask is
       * applied these extra contributions are masked out.*/
      for (int i = count; i < count_align; i++) {
        cell_cache->x[i] = pix.f[0];
        cell_cache->y[i] = piy.f[0];
        cell_cache->z[i] = piz.f[0];
      }
459
460
461
462
463
464
465
    }

    vector pjx, pjy, pjz;
    vector pjvx, pjvy, pjvz, mj;
    vector pjx2, pjy2, pjz2;
    vector pjvx2, pjvy2, pjvz2, mj2;

James Willis's avatar
James Willis committed
466
467
    /* Find all of particle pi's interacions and store needed values in the
     * secondary cache.*/
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
    for (int pjd = 0; pjd < count_align; pjd += (num_vec_proc * VEC_SIZE)) {

      /* Load 2 sets of vectors from the particle cache. */
      pjx.v = vec_load(&cell_cache->x[pjd]);
      pjy.v = vec_load(&cell_cache->y[pjd]);
      pjz.v = vec_load(&cell_cache->z[pjd]);
      pjvx.v = vec_load(&cell_cache->vx[pjd]);
      pjvy.v = vec_load(&cell_cache->vy[pjd]);
      pjvz.v = vec_load(&cell_cache->vz[pjd]);
      mj.v = vec_load(&cell_cache->m[pjd]);

      pjx2.v = vec_load(&cell_cache->x[pjd + VEC_SIZE]);
      pjy2.v = vec_load(&cell_cache->y[pjd + VEC_SIZE]);
      pjz2.v = vec_load(&cell_cache->z[pjd + VEC_SIZE]);
      pjvx2.v = vec_load(&cell_cache->vx[pjd + VEC_SIZE]);
      pjvy2.v = vec_load(&cell_cache->vy[pjd + VEC_SIZE]);
      pjvz2.v = vec_load(&cell_cache->vz[pjd + VEC_SIZE]);
485
      mj2.v = vec_load(&cell_cache->m[pjd + VEC_SIZE]);
486
487
488
489
490

      /* Compute the pairwise distance. */
      vector v_dx_tmp, v_dy_tmp, v_dz_tmp;
      vector v_dx_tmp2, v_dy_tmp2, v_dz_tmp2, v_r2_2;

James Willis's avatar
James Willis committed
491
492
      v_dx_tmp.v = vec_sub(pix.v, pjx.v);
      v_dx_tmp2.v = vec_sub(pix.v, pjx2.v);
493
      v_dy_tmp.v = vec_sub(piy.v, pjy.v);
James Willis's avatar
James Willis committed
494
      v_dy_tmp2.v = vec_sub(piy.v, pjy2.v);
495
      v_dz_tmp.v = vec_sub(piz.v, pjz.v);
James Willis's avatar
James Willis committed
496
497
498
499
      v_dz_tmp2.v = vec_sub(piz.v, pjz2.v);

      v_r2.v = vec_mul(v_dx_tmp.v, v_dx_tmp.v);
      v_r2_2.v = vec_mul(v_dx_tmp2.v, v_dx_tmp2.v);
500
      v_r2.v = vec_fma(v_dy_tmp.v, v_dy_tmp.v, v_r2.v);
James Willis's avatar
James Willis committed
501
      v_r2_2.v = vec_fma(v_dy_tmp2.v, v_dy_tmp2.v, v_r2_2.v);
502
      v_r2.v = vec_fma(v_dz_tmp.v, v_dz_tmp.v, v_r2.v);
James Willis's avatar
James Willis committed
503
504
505
      v_r2_2.v = vec_fma(v_dz_tmp2.v, v_dz_tmp2.v, v_r2_2.v);

/* Form a mask from r2 < hig2 and r2 > 0.*/
506
#ifdef HAVE_AVX512_F
James Willis's avatar
James Willis committed
507
      // KNL_MASK_16 doi_mask, doi_mask_check, doi_mask2, doi_mask2_check;
508
509
      KNL_MASK_16 doi_mask_check, doi_mask2, doi_mask2_check;

James Willis's avatar
James Willis committed
510
      doi_mask_check = vec_cmp_gt(v_r2.v, vec_setzero());
511
512
      doi_mask = vec_cmp_lt(v_r2.v, v_hig2.v);

James Willis's avatar
James Willis committed
513
      doi_mask2_check = vec_cmp_gt(v_r2_2.v, vec_setzero());
514
515
516
517
518
519
520
521
522
      doi_mask2 = vec_cmp_lt(v_r2_2.v, v_hig2.v);

      doi_mask = doi_mask & doi_mask_check;
      doi_mask2 = doi_mask2 & doi_mask2_check;

#else
      vector v_doi_mask, v_doi_mask_check, v_doi_mask2, v_doi_mask2_check;
      int doi_mask2;

James Willis's avatar
James Willis committed
523
      /* Form r2 > 0 mask and r2 < hig2 mask. */
James Willis's avatar
James Willis committed
524
      v_doi_mask_check.v = vec_cmp_gt(v_r2.v, vec_setzero());
525
526
      v_doi_mask.v = vec_cmp_lt(v_r2.v, v_hig2.v);

James Willis's avatar
James Willis committed
527
      /* Form r2 > 0 mask and r2 < hig2 mask. */
James Willis's avatar
James Willis committed
528
      v_doi_mask2_check.v = vec_cmp_gt(v_r2_2.v, vec_setzero());
529
530
      v_doi_mask2.v = vec_cmp_lt(v_r2_2.v, v_hig2.v);

James Willis's avatar
James Willis committed
531
      /* Combine two masks and form integer mask. */
532
533
      doi_mask = vec_cmp_result(vec_and(v_doi_mask.v, v_doi_mask_check.v));
      doi_mask2 = vec_cmp_result(vec_and(v_doi_mask2.v, v_doi_mask2_check.v));
534
#endif /* HAVE_AVX512_F */
535

James Willis's avatar
James Willis committed
536
537
      /* If there are any interactions left pack interaction values into c2
       * cache. */
538
      if (doi_mask) {
James Willis's avatar
James Willis committed
539
540
541
542
543
        storeInteractions(doi_mask, pjd, &v_r2, &v_dx_tmp, &v_dy_tmp, &v_dz_tmp,
                          &mj, &pjvx, &pjvy, &pjvz, cell_cache, &int_cache,
                          &icount, &rhoSum, &rho_dhSum, &wcountSum,
                          &wcount_dhSum, &div_vSum, &curlvxSum, &curlvySum,
                          &curlvzSum, v_hi_inv, v_vix, v_viy, v_viz);
544
545
      }
      if (doi_mask2) {
James Willis's avatar
James Willis committed
546
547
548
549
550
        storeInteractions(
            doi_mask2, pjd + VEC_SIZE, &v_r2_2, &v_dx_tmp2, &v_dy_tmp2,
            &v_dz_tmp2, &mj2, &pjvx2, &pjvy2, &pjvz2, cell_cache, &int_cache,
            &icount, &rhoSum, &rho_dhSum, &wcountSum, &wcount_dhSum, &div_vSum,
            &curlvxSum, &curlvySum, &curlvzSum, v_hi_inv, v_vix, v_viy, v_viz);
551
552
553
      }
    }

James Willis's avatar
James Willis committed
554
    /* Perform padded vector remainder interactions if any are present. */
Matthieu Schaller's avatar
Matthieu Schaller committed
555
556
557
    calcRemInteractions(&int_cache, icount, &rhoSum, &rho_dhSum, &wcountSum,
                        &wcount_dhSum, &div_vSum, &curlvxSum, &curlvySum,
                        &curlvzSum, v_hi_inv, v_vix, v_viy, v_viz,
James Willis's avatar
James Willis committed
558
559
560
561
                        &icount_align);

    /* Initialise masks to true in case remainder interactions have been
     * performed. */
562
563
564
565
566
567
568
569
570
571
572
573
    vector int_mask, int_mask2;
#ifdef HAVE_AVX512_F
    KNL_MASK_16 knl_mask = 0xFFFF;
    KNL_MASK_16 knl_mask2 = 0xFFFF;
    int_mask.m = vec_setint1(0xFFFFFFFF);
    int_mask2.m = vec_setint1(0xFFFFFFFF);
#else
    int_mask.m = vec_setint1(0xFFFFFFFF);
    int_mask2.m = vec_setint1(0xFFFFFFFF);
#endif

    /* Perform interaction with 2 vectors. */
James Willis's avatar
James Willis committed
574
575
576
577
578
579
580
    for (int pjd = 0; pjd < icount_align; pjd += (num_vec_proc * VEC_SIZE)) {
      runner_iact_nonsym_2_vec_density(
          &int_cache.r2q[pjd], &int_cache.dxq[pjd], &int_cache.dyq[pjd],
          &int_cache.dzq[pjd], v_hi_inv, v_vix, v_viy, v_viz,
          &int_cache.vxq[pjd], &int_cache.vyq[pjd], &int_cache.vzq[pjd],
          &int_cache.mq[pjd], &rhoSum, &rho_dhSum, &wcountSum, &wcount_dhSum,
          &div_vSum, &curlvxSum, &curlvySum, &curlvzSum, int_mask, int_mask2,
581
#ifdef HAVE_AVX512_F
James Willis's avatar
James Willis committed
582
          knl_mask, knl_mask2);
583
#else
James Willis's avatar
James Willis committed
584
          0, 0);
585
586
587
#endif
    }

James Willis's avatar
James Willis committed
588
589
590
591
592
593
594
595
596
597
    /* Perform horizontal adds on vector sums and store result in particle pi.
     */
    VEC_HADD(rhoSum, pi->rho);
    VEC_HADD(rho_dhSum, pi->density.rho_dh);
    VEC_HADD(wcountSum, pi->density.wcount);
    VEC_HADD(wcount_dhSum, pi->density.wcount_dh);
    VEC_HADD(div_vSum, pi->density.div_v);
    VEC_HADD(curlvxSum, pi->density.rot_v[0]);
    VEC_HADD(curlvySum, pi->density.rot_v[1]);
    VEC_HADD(curlvzSum, pi->density.rot_v[2]);
598
599
600
601
602

    /* Reset interaction count. */
    icount = 0;
  } /* loop over all particles. */

James Willis's avatar
James Willis committed
603
  TIMER_TOC(timer_doself_density);
604
#endif /* WITH_VECTORIZATION */
605
606
}

607
/**
James Willis's avatar
James Willis committed
608
609
 * @brief Compute the density interactions between a cell pair (non-symmetric)
 * using vector intrinsics.
610
611
612
613
 *
 * @param r The #runner.
 * @param ci The first #cell.
 * @param cj The second #cell.
614
615
 * @param sid The direction of the pair
 * @param shift The shift vector to apply to the particles in ci.
616
 */
James Willis's avatar
James Willis committed
617
void runner_dopair1_density_vec(struct runner *r, struct cell *ci,
618
619
                                struct cell *cj, const int sid,
                                const double *shift) {
620
621
622
623

#ifdef WITH_VECTORIZATION
  const struct engine *restrict e = r->e;

James Willis's avatar
James Willis committed
624
  vector v_hi, v_vix, v_viy, v_viz, v_hig2;
625
626
627

  TIMER_TIC;

628
629
630
631
632
633
634
635
  /* Get the cutoff shift. */
  double rshift = 0.0;
  for (int k = 0; k < 3; k++) rshift += shift[k] * runner_shift[sid][k];

  /* Pick-out the sorted lists. */
  const struct entry *restrict sort_i = &ci->sort[sid * (ci->count + 1)];
  const struct entry *restrict sort_j = &cj->sort[sid * (cj->count + 1)];

636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
#ifdef SWIFT_DEBUG_CHECKS
  /* Check that the dx_max_sort values in the cell are indeed an upper
     bound on particle movement. */
  for (int pid = 0; pid < ci->count; pid++) {
    const struct part *p = &ci->parts[sort_i[pid].i];
    const float d = p->x[0] * runner_shift[sid][0] +
                    p->x[1] * runner_shift[sid][1] +
                    p->x[2] * runner_shift[sid][2];
    if (fabsf(d - sort_i[pid].d) - ci->dx_max_sort >
        1.0e-6 * max(fabsf(d), ci->dx_max_sort))
      error("particle shift diff exceeds dx_max_sort.");
  }
  for (int pjd = 0; pjd < cj->count; pjd++) {
    const struct part *p = &cj->parts[sort_j[pjd].i];
    const float d = p->x[0] * runner_shift[sid][0] +
                    p->x[1] * runner_shift[sid][1] +
                    p->x[2] * runner_shift[sid][2];
    if (fabsf(d - sort_j[pjd].d) - cj->dx_max_sort >
        1.0e-6 * max(fabsf(d), cj->dx_max_sort))
      error("particle shift diff exceeds dx_max_sort.");
  }
#endif /* SWIFT_DEBUG_CHECKS */

659
660
661
662
663
664
665
666
667
  /* Get some other useful values. */
  const int count_i = ci->count;
  const int count_j = cj->count;
  const double hi_max = ci->h_max * kernel_gamma - rshift;
  const double hj_max = cj->h_max * kernel_gamma;
  struct part *restrict parts_i = ci->parts;
  struct part *restrict parts_j = cj->parts;
  const double di_max = sort_i[count_i - 1].d - rshift;
  const double dj_min = sort_j[0].d;
668
  const float dx_max = (ci->dx_max_sort + cj->dx_max_sort);
669
670

  /* Check if any particles are active and return if there are not. */
Matthieu Schaller's avatar
Matthieu Schaller committed
671
672
673
  int numActive = 0;
  for (int pid = count_i - 1;
       pid >= 0 && sort_i[pid].d + hi_max + dx_max > dj_min; pid--) {
674
675
676
677
    struct part *restrict pi = &parts_i[sort_i[pid].i];
    if (part_is_active(pi, e)) {
      numActive++;
      break;
Matthieu Schaller's avatar
Matthieu Schaller committed
678
    }
679
  }
680

Matthieu Schaller's avatar
Matthieu Schaller committed
681
  if (!numActive) {
682
    for (int pjd = 0; pjd < count_j && sort_j[pjd].d - hj_max - dx_max < di_max;
Matthieu Schaller's avatar
Matthieu Schaller committed
683
         pjd++) {
684
685
      struct part *restrict pj = &parts_j[sort_j[pjd].i];
      if (part_is_active(pj, e)) {
686
687
        numActive++;
        break;
Matthieu Schaller's avatar
Matthieu Schaller committed
688
689
      }
    }
690
  }
691

Matthieu Schaller's avatar
Matthieu Schaller committed
692
  if (numActive == 0) return;
693

694
695
696
697
  /* Get both particle caches from the runner and re-allocate
   * them if they are not big enough for the cells. */
  struct cache *restrict ci_cache = &r->ci_cache;
  struct cache *restrict cj_cache = &r->cj_cache;
698

699
700
701
702
703
704
  if (ci_cache->count < count_i) {
    cache_init(ci_cache, count_i);
  }
  if (cj_cache->count < count_j) {
    cache_init(cj_cache, count_j);
  }
705

706
707
708
  int first_pi, last_pj;
  float *max_di __attribute__((aligned(sizeof(float) * VEC_SIZE)));
  float *max_dj __attribute__((aligned(sizeof(float) * VEC_SIZE)));
709

710
711
  max_di = r->ci_cache.max_d;
  max_dj = r->cj_cache.max_d;
712

713
714
715
  /* Find particles maximum distance into cj, max_di[] and ci, max_dj[]. */
  /* Also find the first pi that interacts with any particle in cj and the last
   * pj that interacts with any particle in ci. */
716
717
718
  populate_max_d_no_cache(ci, cj, sort_i, sort_j, dx_max, rshift, hi_max,
                          hj_max, di_max, dj_min, max_di, max_dj, &first_pi,
                          &last_pj, e);
719

720
721
722
723
724
  /* Find the maximum index into cj that is required by a particle in ci. */
  /* Find the maximum index into ci that is required by a particle in cj. */
  float di, dj;
  int max_ind_j = count_j - 1;
  int max_ind_i = 0;
725

726
727
728
  dj = sort_j[max_ind_j].d;
  while (max_ind_j > 0 && max_di[count_i - 1] < dj) {
    max_ind_j--;
729
730

    dj = sort_j[max_ind_j].d;
731
  }
732

733
734
735
  di = sort_i[max_ind_i].d;
  while (max_ind_i < count_i - 1 && max_dj[0] > di) {
    max_ind_i++;
736
737

    di = sort_i[max_ind_i].d;
738
  }
739

740
741
742
743
  /* Limits of the outer loops. */
  int first_pi_loop = first_pi;
  int last_pj_loop = last_pj;

744
745
746
747
  /* Take the max/min of both values calculated to work out how many particles
   * to read into the cache. */
  last_pj = max(last_pj, max_ind_j);
  first_pi = min(first_pi, max_ind_i);
748

749
750
751
752
  /* Read the needed particles into the two caches. */
  int first_pi_align = first_pi;
  int last_pj_align = last_pj;
  cache_read_two_partial_cells_sorted(ci, cj, ci_cache, cj_cache, sort_i,
Matthieu Schaller's avatar
Matthieu Schaller committed
753
754
                                      sort_j, shift, &first_pi_align,
                                      &last_pj_align, 1);
755

756
757
  /* Get the number of particles read into the ci cache. */
  int ci_cache_count = count_i - first_pi_align;
758

759
  if (cell_is_active(ci, e)) {
760

James Willis's avatar
James Willis committed
761
    /* Loop over the parts in ci until nothing is within range in cj. */
762
    for (int pid = count_i - 1; pid >= first_pi_loop && max_ind_j >= 0; pid--) {
763

764
765
766
      /* Get a hold of the ith part in ci. */
      struct part *restrict pi = &parts_i[sort_i[pid].i];
      if (!part_is_active(pi, e)) continue;
767

768
769
770
      /* Set the cache index. */
      int ci_cache_idx = pid - first_pi_align;

James Willis's avatar
James Willis committed
771
      /* Skip this particle if no particle in cj is within range of it. */
772
      const float hi = ci_cache->h[ci_cache_idx];
773
774
      const double di_test =
          sort_i[pid].d + hi * kernel_gamma + dx_max - rshift;
775
776
      if (di_test < dj_min) continue;

777
778
779
780
      /* Determine the exit iteration of the interaction loop. */
      dj = sort_j[max_ind_j].d;
      while (max_ind_j > 0 && max_di[pid] < dj) {
        max_ind_j--;
781

782
783
784
        dj = sort_j[max_ind_j].d;
      }
      int exit_iteration = max_ind_j + 1;
785

786
      const float hig2 = hi * hi * kernel_gamma2;
787

788
      vector pix, piy, piz;
789

790
791
792
793
794
795
796
797
      /* Fill particle pi vectors. */
      pix.v = vec_set1(ci_cache->x[ci_cache_idx]);
      piy.v = vec_set1(ci_cache->y[ci_cache_idx]);
      piz.v = vec_set1(ci_cache->z[ci_cache_idx]);
      v_hi.v = vec_set1(hi);
      v_vix.v = vec_set1(ci_cache->vx[ci_cache_idx]);
      v_viy.v = vec_set1(ci_cache->vy[ci_cache_idx]);
      v_viz.v = vec_set1(ci_cache->vz[ci_cache_idx]);
798

799
      v_hig2.v = vec_set1(hig2);
800

801
802
      /* Reset cumulative sums of update vectors. */
      vector rhoSum, rho_dhSum, wcountSum, wcount_dhSum, div_vSum, curlvxSum,
Matthieu Schaller's avatar
Matthieu Schaller committed
803
          curlvySum, curlvzSum;
804

805
806
      /* Get the inverse of hi. */
      vector v_hi_inv;
807

808
      v_hi_inv = vec_reciprocal(v_hi);
809

810
811
812
813
814
815
816
817
      rhoSum.v = vec_setzero();
      rho_dhSum.v = vec_setzero();
      wcountSum.v = vec_setzero();
      wcount_dhSum.v = vec_setzero();
      div_vSum.v = vec_setzero();
      curlvxSum.v = vec_setzero();
      curlvySum.v = vec_setzero();
      curlvzSum.v = vec_setzero();
818

819
820
821
822
823
      /* Pad the exit iteration if there is a serial remainder. */
      int exit_iteration_align = exit_iteration;
      int rem = exit_iteration % VEC_SIZE;
      if (rem != 0) {
        int pad = VEC_SIZE - rem;
824

825
826
827
        if (exit_iteration_align + pad <= last_pj_align + 1)
          exit_iteration_align += pad;
      }
828

829
      vector pjx, pjy, pjz;
830

831
832
      /* Loop over the parts in cj. */
      for (int pjd = 0; pjd < exit_iteration_align; pjd += VEC_SIZE) {
833

834
835
        /* Get the cache index to the jth particle. */
        int cj_cache_idx = pjd;
836

837
        vector v_dx, v_dy, v_dz, v_r2;
838

839
#ifdef SWIFT_DEBUG_CHECKS
Matthieu Schaller's avatar
Matthieu Schaller committed
840
841
        if (cj_cache_idx % VEC_SIZE != 0 || cj_cache_idx < 0) {
          error("Unaligned read!!! cj_cache_idx=%d", cj_cache_idx);
842
843
        }
#endif
844

845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
        /* Load 2 sets of vectors from the particle cache. */
        pjx.v = vec_load(&cj_cache->x[cj_cache_idx]);
        pjy.v = vec_load(&cj_cache->y[cj_cache_idx]);
        pjz.v = vec_load(&cj_cache->z[cj_cache_idx]);

        /* Compute the pairwise distance. */
        v_dx.v = vec_sub(pix.v, pjx.v);
        v_dy.v = vec_sub(piy.v, pjy.v);
        v_dz.v = vec_sub(piz.v, pjz.v);

        v_r2.v = vec_mul(v_dx.v, v_dx.v);
        v_r2.v = vec_fma(v_dy.v, v_dy.v, v_r2.v);
        v_r2.v = vec_fma(v_dz.v, v_dz.v, v_r2.v);

        vector v_doi_mask;
        int doi_mask;

        /* Form r2 < hig2 mask. */
        v_doi_mask.v = vec_cmp_lt(v_r2.v, v_hig2.v);

        /* Form integer mask. */
        doi_mask = vec_cmp_result(v_doi_mask.v);

        /* If there are any interactions perform them. */
        if (doi_mask)
          runner_iact_nonsym_1_vec_density(
              &v_r2, &v_dx, &v_dy, &v_dz, v_hi_inv, v_vix, v_viy, v_viz,
              &cj_cache->vx[cj_cache_idx], &cj_cache->vy[cj_cache_idx],
              &cj_cache->vz[cj_cache_idx], &cj_cache->m[cj_cache_idx], &rhoSum,
              &rho_dhSum, &wcountSum, &wcount_dhSum, &div_vSum, &curlvxSum,
              &curlvySum, &curlvzSum, v_doi_mask,
876
#ifdef HAVE_AVX512_F
877
              knl_mask);
878
#else
Matthieu Schaller's avatar
Matthieu Schaller committed
879
              0);
880
#endif
James Willis's avatar
James Willis committed
881

882
      } /* loop over the parts in cj. */
883

884
885
886
887
888
889
890
891
892
893
894
895
896
      /* Perform horizontal adds on vector sums and store result in particle pi.
      */
      VEC_HADD(rhoSum, pi->rho);
      VEC_HADD(rho_dhSum, pi->density.rho_dh);
      VEC_HADD(wcountSum, pi->density.wcount);
      VEC_HADD(wcount_dhSum, pi->density.wcount_dh);
      VEC_HADD(div_vSum, pi->density.div_v);
      VEC_HADD(curlvxSum, pi->density.rot_v[0]);
      VEC_HADD(curlvySum, pi->density.rot_v[1]);
      VEC_HADD(curlvzSum, pi->density.rot_v[2]);

    } /* loop over the parts in ci. */
  }
897

898
  if (cell_is_active(cj, e)) {
899

James Willis's avatar
James Willis committed
900
    /* Loop over the parts in cj until nothing is within range in ci. */
901
    for (int pjd = 0; pjd <= last_pj_loop && max_ind_i < count_i; pjd++) {
902

903
904
905
      /* Get a hold of the jth part in cj. */
      struct part *restrict pj = &parts_j[sort_j[pjd].i];
      if (!part_is_active(pj, e)) continue;
906

907
908
909
910
      /* Set the cache index. */
      int cj_cache_idx = pjd;

      /*TODO: rshift term. */
James Willis's avatar
James Willis committed
911
      /* Skip this particle if no particle in ci is within range of it. */
912
      const float hj = cj_cache->h[cj_cache_idx];
913
914
      const double dj_test =
          sort_j[pjd].d - hj * kernel_gamma - dx_max - rshift;
915
      if (dj_test > di_max) continue;
916

917
918
919
920
      /* Determine the exit iteration of the interaction loop. */
      di = sort_i[max_ind_i].d;
      while (max_ind_i < count_i - 1 && max_dj[pjd] > di) {
        max_ind_i++;
James Willis's avatar
James Willis committed
921

922
        di = sort_i[max_ind_i].d;
923
924
      }
      int exit_iteration = max_ind_i;
925

926
      const float hjg2 = hj * hj * kernel_gamma2;
927

928
929
      vector pjx, pjy, pjz;
      vector v_hj, v_vjx, v_vjy, v_vjz, v_hjg2;
930

931
932
933
934
935
936
937
938
      /* Fill particle pi vectors. */
      pjx.v = vec_set1(cj_cache->x[cj_cache_idx]);
      pjy.v = vec_set1(cj_cache->y[cj_cache_idx]);
      pjz.v = vec_set1(cj_cache->z[cj_cache_idx]);
      v_hj.v = vec_set1(hj);
      v_vjx.v = vec_set1(cj_cache->vx[cj_cache_idx]);
      v_vjy.v = vec_set1(cj_cache->vy[cj_cache_idx]);
      v_vjz.v = vec_set1(cj_cache->vz[cj_cache_idx]);
939

940
      v_hjg2.v = vec_set1(hjg2);
941

942
943
      /* Reset cumulative sums of update vectors. */
      vector rhoSum, rho_dhSum, wcountSum, wcount_dhSum, div_vSum, curlvxSum,
Matthieu Schaller's avatar
Matthieu Schaller committed
944
          curlvySum, curlvzSum;
945

946
947
      /* Get the inverse of hj. */
      vector v_hj_inv;
948

949
      v_hj_inv = vec_reciprocal(v_hj);
950

951
952
953
954
955
956
957
958
      rhoSum.v = vec_setzero();
      rho_dhSum.v = vec_setzero();
      wcountSum.v = vec_setzero();
      wcount_dhSum.v = vec_setzero();
      div_vSum.v = vec_setzero();
      curlvxSum.v = vec_setzero();
      curlvySum.v = vec_setzero();
      curlvzSum.v = vec_setzero();
959

960
      vector pix, piy, piz;
961

962
963
      /* Convert exit iteration to cache indices. */
      int exit_iteration_align = exit_iteration - first_pi_align;
James Willis's avatar
James Willis committed
964

965
966
      /* Pad the exit iteration align so cache reads are aligned. */
      int rem = exit_iteration_align % VEC_SIZE;
Matthieu Schaller's avatar
Matthieu Schaller committed
967
      if (exit_iteration_align < VEC_SIZE) {
968
        exit_iteration_align = 0;
Matthieu Schaller's avatar
Matthieu Schaller committed
969
970
      } else
        exit_iteration_align -= rem;
James Willis's avatar
James Willis committed
971

972
      /* Loop over the parts in ci. */
Matthieu Schaller's avatar
Matthieu Schaller committed
973
974
      for (int ci_cache_idx = exit_iteration_align;
           ci_cache_idx < ci_cache_count; ci_cache_idx += VEC_SIZE) {
James Willis's avatar
James Willis committed
975

976
#ifdef SWIFT_DEBUG_CHECKS
Matthieu Schaller's avatar
Matthieu Schaller committed
977
978
        if (ci_cache_idx % VEC_SIZE != 0 || ci_cache_idx < 0) {
          error("Unaligned read!!! ci_cache_idx=%d", ci_cache_idx);
979
980
        }
#endif
James Willis's avatar
James Willis committed
981

982
        vector v_dx, v_dy, v_dz, v_r2;
James Willis's avatar
James Willis committed
983

984
985
986
987
        /* Load 2 sets of vectors from the particle cache. */
        pix.v = vec_load(&ci_cache->x[ci_cache_idx]);
        piy.v = vec_load(&ci_cache->y[ci_cache_idx]);
        piz.v = vec_load(&ci_cache->z[ci_cache_idx]);
James Willis's avatar
James Willis committed
988

989
990
991
992
        /* Compute the pairwise distance. */
        v_dx.v = vec_sub(pjx.v, pix.v);
        v_dy.v = vec_sub(pjy.v, piy.v);
        v_dz.v = vec_sub(pjz.v, piz.v);
993

994
995
996
        v_r2.v = vec_mul(v_dx.v, v_dx.v);
        v_r2.v = vec_fma(v_dy.v, v_dy.v, v_r2.v);
        v_r2.v = vec_fma(v_dz.v, v_dz.v, v_r2.v);
997

998
999
        vector v_doj_mask;
        int doj_mask;
1000

1001
1002
        /* Form r2 < hig2 mask. */
        v_doj_mask.v = vec_cmp_lt(v_r2.v, v_hjg2.v);
1003

1004
1005
        /* Form integer mask. */
        doj_mask = vec_cmp_result(v_doj_mask.v);
1006

1007
1008
1009
1010
1011
1012
1013
1014
        /* If there are any interactions perform them. */
        if (doj_mask)
          runner_iact_nonsym_1_vec_density(
              &v_r2, &v_dx, &v_dy, &v_dz, v_hj_inv, v_vjx, v_vjy, v_vjz,
              &ci_cache->vx[ci_cache_idx], &ci_cache->vy[ci_cache_idx],
              &ci_cache->vz[ci_cache_idx], &ci_cache->m[ci_cache_idx], &rhoSum,
              &rho_dhSum, &wcountSum, &wcount_dhSum, &div_vSum, &curlvxSum,
              &curlvySum, &curlvzSum, v_doj_mask,
James Willis's avatar
James Willis committed
1015
#ifdef HAVE_AVX512_F
1016
              knl_mask);
James Willis's avatar
James Willis committed
1017
#else
Matthieu Schaller's avatar
Matthieu Schaller committed
1018
              0);