src/gmxlib/nonbonded/nb_kernel_avx_128_fma_double/nb_kernel_ElecCSTab_VdwNone_GeomW3W3_avx_128_fma_double.c

   1 /*
   2  * Note: this file was generated by the Gromacs avx_128_fma_double kernel generator.
   3  *
   4  *                This source code is part of
   5  *
   6  *                 G   R   O   M   A   C   S
   7  *
   8  * Copyright (c) 2001-2012, The GROMACS Development Team
   9  *
  10  * Gromacs is a library for molecular simulation and trajectory analysis,
  11  * written by Erik Lindahl, David van der Spoel, Berk Hess, and others - for
  12  * a full list of developers and information, check out http://www.gromacs.org
  13  *
  14  * This program is free software; you can redistribute it and/or modify it under
  15  * the terms of the GNU Lesser General Public License as published by the Free
  16  * Software Foundation; either version 2 of the License, or (at your option) any
  17  * later version.
  18  *
  19  * To help fund GROMACS development, we humbly ask that you cite
  20  * the papers people have written on it - you can find them on the website.
  21  */
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <math.h>
  27
  28 #include "../nb_kernel.h"
  29 #include "types/simple.h"
  30 #include "vec.h"
  31 #include "nrnb.h"
  32
  33 #include "gmx_math_x86_avx_128_fma_double.h"
  34 #include "kernelutil_x86_avx_128_fma_double.h"
  35
  36 /*
  37  * Gromacs nonbonded kernel:   nb_kernel_ElecCSTab_VdwNone_GeomW3W3_VF_avx_128_fma_double
  38  * Electrostatics interaction: CubicSplineTable
  39  * VdW interaction:            None
  40  * Geometry:                   Water3-Water3
  41  * Calculate force/pot:        PotentialAndForce
  42  */
  43 void
  44 nb_kernel_ElecCSTab_VdwNone_GeomW3W3_VF_avx_128_fma_double
  45                     (t_nblist * gmx_restrict                nlist,
  46                      rvec * gmx_restrict                    xx,
  47                      rvec * gmx_restrict                    ff,
  48                      t_forcerec * gmx_restrict              fr,
  49                      t_mdatoms * gmx_restrict               mdatoms,
  50                      nb_kernel_data_t * gmx_restrict        kernel_data,
  51                      t_nrnb * gmx_restrict                  nrnb)
  52 {
  53     /* Suffixes 0,1,2,3 refer to particle indices for waters in the inner or outer loop, or
  54      * just 0 for non-waters.
  55      * Suffixes A,B refer to j loop unrolling done with SSE double precision, e.g. for the two different
  56      * jnr indices corresponding to data put in the four positions in the SIMD register.
  57      */
  58     int              i_shift_offset,i_coord_offset,outeriter,inneriter;
  59     int              j_index_start,j_index_end,jidx,nri,inr,ggid,iidx;
  60     int              jnrA,jnrB;
  61     int              j_coord_offsetA,j_coord_offsetB;
  62     int              *iinr,*jindex,*jjnr,*shiftidx,*gid;
  63     real             rcutoff_scalar;
  64     real             *shiftvec,*fshift,*x,*f;
  65     __m128d          tx,ty,tz,fscal,rcutoff,rcutoff2,jidxall;
  66     int              vdwioffset0;
  67     __m128d          ix0,iy0,iz0,fix0,fiy0,fiz0,iq0,isai0;
  68     int              vdwioffset1;
  69     __m128d          ix1,iy1,iz1,fix1,fiy1,fiz1,iq1,isai1;
  70     int              vdwioffset2;
  71     __m128d          ix2,iy2,iz2,fix2,fiy2,fiz2,iq2,isai2;
  72     int              vdwjidx0A,vdwjidx0B;
  73     __m128d          jx0,jy0,jz0,fjx0,fjy0,fjz0,jq0,isaj0;
  74     int              vdwjidx1A,vdwjidx1B;
  75     __m128d          jx1,jy1,jz1,fjx1,fjy1,fjz1,jq1,isaj1;
  76     int              vdwjidx2A,vdwjidx2B;
  77     __m128d          jx2,jy2,jz2,fjx2,fjy2,fjz2,jq2,isaj2;
  78     __m128d          dx00,dy00,dz00,rsq00,rinv00,rinvsq00,r00,qq00,c6_00,c12_00;
  79     __m128d          dx01,dy01,dz01,rsq01,rinv01,rinvsq01,r01,qq01,c6_01,c12_01;
  80     __m128d          dx02,dy02,dz02,rsq02,rinv02,rinvsq02,r02,qq02,c6_02,c12_02;
  81     __m128d          dx10,dy10,dz10,rsq10,rinv10,rinvsq10,r10,qq10,c6_10,c12_10;
  82     __m128d          dx11,dy11,dz11,rsq11,rinv11,rinvsq11,r11,qq11,c6_11,c12_11;
  83     __m128d          dx12,dy12,dz12,rsq12,rinv12,rinvsq12,r12,qq12,c6_12,c12_12;
  84     __m128d          dx20,dy20,dz20,rsq20,rinv20,rinvsq20,r20,qq20,c6_20,c12_20;
  85     __m128d          dx21,dy21,dz21,rsq21,rinv21,rinvsq21,r21,qq21,c6_21,c12_21;
  86     __m128d          dx22,dy22,dz22,rsq22,rinv22,rinvsq22,r22,qq22,c6_22,c12_22;
  87     __m128d          velec,felec,velecsum,facel,crf,krf,krf2;
  88     real             *charge;
  89     __m128i          vfitab;
  90     __m128i          ifour       = _mm_set1_epi32(4);
  91     __m128d          rt,vfeps,vftabscale,Y,F,G,H,Heps,Fp,VV,FF,twovfeps;
  92     real             *vftab;
  93     __m128d          dummy_mask,cutoff_mask;
  94     __m128d          signbit   = gmx_mm_castsi128_pd( _mm_set_epi32(0x80000000,0x00000000,0x80000000,0x00000000) );
  95     __m128d          one     = _mm_set1_pd(1.0);
  96     __m128d          two     = _mm_set1_pd(2.0);
  97     x                = xx[0];
  98     f                = ff[0];
  99
 100     nri              = nlist->nri;
 101     iinr             = nlist->iinr;
 102     jindex           = nlist->jindex;
 103     jjnr             = nlist->jjnr;
 104     shiftidx         = nlist->shift;
 105     gid              = nlist->gid;
 106     shiftvec         = fr->shift_vec[0];
 107     fshift           = fr->fshift[0];
 108     facel            = _mm_set1_pd(fr->epsfac);
 109     charge           = mdatoms->chargeA;
 110
 111     vftab            = kernel_data->table_elec->data;
 112     vftabscale       = _mm_set1_pd(kernel_data->table_elec->scale);
 113
 114     /* Setup water-specific parameters */
 115     inr              = nlist->iinr[0];
 116     iq0              = _mm_mul_pd(facel,_mm_set1_pd(charge[inr+0]));
 117     iq1              = _mm_mul_pd(facel,_mm_set1_pd(charge[inr+1]));
 118     iq2              = _mm_mul_pd(facel,_mm_set1_pd(charge[inr+2]));
 119
 120     jq0              = _mm_set1_pd(charge[inr+0]);
 121     jq1              = _mm_set1_pd(charge[inr+1]);
 122     jq2              = _mm_set1_pd(charge[inr+2]);
 123     qq00             = _mm_mul_pd(iq0,jq0);
 124     qq01             = _mm_mul_pd(iq0,jq1);
 125     qq02             = _mm_mul_pd(iq0,jq2);
 126     qq10             = _mm_mul_pd(iq1,jq0);
 127     qq11             = _mm_mul_pd(iq1,jq1);
 128     qq12             = _mm_mul_pd(iq1,jq2);
 129     qq20             = _mm_mul_pd(iq2,jq0);
 130     qq21             = _mm_mul_pd(iq2,jq1);
 131     qq22             = _mm_mul_pd(iq2,jq2);
 132
 133     /* Avoid stupid compiler warnings */
 134     jnrA = jnrB = 0;
 135     j_coord_offsetA = 0;
 136     j_coord_offsetB = 0;
 137
 138     outeriter        = 0;
 139     inneriter        = 0;
 140
 141     /* Start outer loop over neighborlists */
 142     for(iidx=0; iidx<nri; iidx++)
 143     {
 144         /* Load shift vector for this list */
 145         i_shift_offset   = DIM*shiftidx[iidx];
 146
 147         /* Load limits for loop over neighbors */
 148         j_index_start    = jindex[iidx];
 149         j_index_end      = jindex[iidx+1];
 150
 151         /* Get outer coordinate index */
 152         inr              = iinr[iidx];
 153         i_coord_offset   = DIM*inr;
 154
 155         /* Load i particle coords and add shift vector */
 156         gmx_mm_load_shift_and_3rvec_broadcast_pd(shiftvec+i_shift_offset,x+i_coord_offset,
 157                                                  &ix0,&iy0,&iz0,&ix1,&iy1,&iz1,&ix2,&iy2,&iz2);
 158
 159         fix0             = _mm_setzero_pd();
 160         fiy0             = _mm_setzero_pd();
 161         fiz0             = _mm_setzero_pd();
 162         fix1             = _mm_setzero_pd();
 163         fiy1             = _mm_setzero_pd();
 164         fiz1             = _mm_setzero_pd();
 165         fix2             = _mm_setzero_pd();
 166         fiy2             = _mm_setzero_pd();
 167         fiz2             = _mm_setzero_pd();
 168
 169         /* Reset potential sums */
 170         velecsum         = _mm_setzero_pd();
 171
 172         /* Start inner kernel loop */
 173         for(jidx=j_index_start; jidx<j_index_end-1; jidx+=2)
 174         {
 175
 176             /* Get j neighbor index, and coordinate index */
 177             jnrA             = jjnr[jidx];
 178             jnrB             = jjnr[jidx+1];
 179             j_coord_offsetA  = DIM*jnrA;
 180             j_coord_offsetB  = DIM*jnrB;
 181
 182             /* load j atom coordinates */
 183             gmx_mm_load_3rvec_2ptr_swizzle_pd(x+j_coord_offsetA,x+j_coord_offsetB,
 184                                               &jx0,&jy0,&jz0,&jx1,&jy1,&jz1,&jx2,&jy2,&jz2);
 185
 186             /* Calculate displacement vector */
 187             dx00             = _mm_sub_pd(ix0,jx0);
 188             dy00             = _mm_sub_pd(iy0,jy0);
 189             dz00             = _mm_sub_pd(iz0,jz0);
 190             dx01             = _mm_sub_pd(ix0,jx1);
 191             dy01             = _mm_sub_pd(iy0,jy1);
 192             dz01             = _mm_sub_pd(iz0,jz1);
 193             dx02             = _mm_sub_pd(ix0,jx2);
 194             dy02             = _mm_sub_pd(iy0,jy2);
 195             dz02             = _mm_sub_pd(iz0,jz2);
 196             dx10             = _mm_sub_pd(ix1,jx0);
 197             dy10             = _mm_sub_pd(iy1,jy0);
 198             dz10             = _mm_sub_pd(iz1,jz0);
 199             dx11             = _mm_sub_pd(ix1,jx1);
 200             dy11             = _mm_sub_pd(iy1,jy1);
 201             dz11             = _mm_sub_pd(iz1,jz1);
 202             dx12             = _mm_sub_pd(ix1,jx2);
 203             dy12             = _mm_sub_pd(iy1,jy2);
 204             dz12             = _mm_sub_pd(iz1,jz2);
 205             dx20             = _mm_sub_pd(ix2,jx0);
 206             dy20             = _mm_sub_pd(iy2,jy0);
 207             dz20             = _mm_sub_pd(iz2,jz0);
 208             dx21             = _mm_sub_pd(ix2,jx1);
 209             dy21             = _mm_sub_pd(iy2,jy1);
 210             dz21             = _mm_sub_pd(iz2,jz1);
 211             dx22             = _mm_sub_pd(ix2,jx2);
 212             dy22             = _mm_sub_pd(iy2,jy2);
 213             dz22             = _mm_sub_pd(iz2,jz2);
 214
 215             /* Calculate squared distance and things based on it */
 216             rsq00            = gmx_mm_calc_rsq_pd(dx00,dy00,dz00);
 217             rsq01            = gmx_mm_calc_rsq_pd(dx01,dy01,dz01);
 218             rsq02            = gmx_mm_calc_rsq_pd(dx02,dy02,dz02);
 219             rsq10            = gmx_mm_calc_rsq_pd(dx10,dy10,dz10);
 220             rsq11            = gmx_mm_calc_rsq_pd(dx11,dy11,dz11);
 221             rsq12            = gmx_mm_calc_rsq_pd(dx12,dy12,dz12);
 222             rsq20            = gmx_mm_calc_rsq_pd(dx20,dy20,dz20);
 223             rsq21            = gmx_mm_calc_rsq_pd(dx21,dy21,dz21);
 224             rsq22            = gmx_mm_calc_rsq_pd(dx22,dy22,dz22);
 225
 226             rinv00           = gmx_mm_invsqrt_pd(rsq00);
 227             rinv01           = gmx_mm_invsqrt_pd(rsq01);
 228             rinv02           = gmx_mm_invsqrt_pd(rsq02);
 229             rinv10           = gmx_mm_invsqrt_pd(rsq10);
 230             rinv11           = gmx_mm_invsqrt_pd(rsq11);
 231             rinv12           = gmx_mm_invsqrt_pd(rsq12);
 232             rinv20           = gmx_mm_invsqrt_pd(rsq20);
 233             rinv21           = gmx_mm_invsqrt_pd(rsq21);
 234             rinv22           = gmx_mm_invsqrt_pd(rsq22);
 235
 236             fjx0             = _mm_setzero_pd();
 237             fjy0             = _mm_setzero_pd();
 238             fjz0             = _mm_setzero_pd();
 239             fjx1             = _mm_setzero_pd();
 240             fjy1             = _mm_setzero_pd();
 241             fjz1             = _mm_setzero_pd();
 242             fjx2             = _mm_setzero_pd();
 243             fjy2             = _mm_setzero_pd();
 244             fjz2             = _mm_setzero_pd();
 245
 246             /**************************
 247              * CALCULATE INTERACTIONS *
 248              **************************/
 249
 250             r00              = _mm_mul_pd(rsq00,rinv00);
 251
 252             /* Calculate table index by multiplying r with table scale and truncate to integer */
 253             rt               = _mm_mul_pd(r00,vftabscale);
 254             vfitab           = _mm_cvttpd_epi32(rt);
 255 #ifdef __XOP__
 256             vfeps            = _mm_frcz_pd(rt);
 257 #else
 258             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 259 #endif
 260             twovfeps         = _mm_add_pd(vfeps,vfeps);
 261             vfitab           = _mm_slli_epi32(vfitab,2);
 262
 263             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 264             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 265             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 266             GMX_MM_TRANSPOSE2_PD(Y,F);
 267             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 268             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
 269             GMX_MM_TRANSPOSE2_PD(G,H);
 270             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 271             VV               = _mm_macc_pd(vfeps,Fp,Y);
 272             velec            = _mm_mul_pd(qq00,VV);
 273             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 274             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq00,FF),_mm_mul_pd(vftabscale,rinv00)));
 275
 276             /* Update potential sum for this i atom from the interaction with this j atom. */
 277             velecsum         = _mm_add_pd(velecsum,velec);
 278
 279             fscal            = felec;
 280
 281             /* Update vectorial force */
 282             fix0             = _mm_macc_pd(dx00,fscal,fix0);
 283             fiy0             = _mm_macc_pd(dy00,fscal,fiy0);
 284             fiz0             = _mm_macc_pd(dz00,fscal,fiz0);
 285
 286             fjx0             = _mm_macc_pd(dx00,fscal,fjx0);
 287             fjy0             = _mm_macc_pd(dy00,fscal,fjy0);
 288             fjz0             = _mm_macc_pd(dz00,fscal,fjz0);
 289
 290             /**************************
 291              * CALCULATE INTERACTIONS *
 292              **************************/
 293
 294             r01              = _mm_mul_pd(rsq01,rinv01);
 295
 296             /* Calculate table index by multiplying r with table scale and truncate to integer */
 297             rt               = _mm_mul_pd(r01,vftabscale);
 298             vfitab           = _mm_cvttpd_epi32(rt);
 299 #ifdef __XOP__
 300             vfeps            = _mm_frcz_pd(rt);
 301 #else
 302             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 303 #endif
 304             twovfeps         = _mm_add_pd(vfeps,vfeps);
 305             vfitab           = _mm_slli_epi32(vfitab,2);
 306
 307             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 308             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 309             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 310             GMX_MM_TRANSPOSE2_PD(Y,F);
 311             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 312             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
 313             GMX_MM_TRANSPOSE2_PD(G,H);
 314             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 315             VV               = _mm_macc_pd(vfeps,Fp,Y);
 316             velec            = _mm_mul_pd(qq01,VV);
 317             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 318             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq01,FF),_mm_mul_pd(vftabscale,rinv01)));
 319
 320             /* Update potential sum for this i atom from the interaction with this j atom. */
 321             velecsum         = _mm_add_pd(velecsum,velec);
 322
 323             fscal            = felec;
 324
 325             /* Update vectorial force */
 326             fix0             = _mm_macc_pd(dx01,fscal,fix0);
 327             fiy0             = _mm_macc_pd(dy01,fscal,fiy0);
 328             fiz0             = _mm_macc_pd(dz01,fscal,fiz0);
 329
 330             fjx1             = _mm_macc_pd(dx01,fscal,fjx1);
 331             fjy1             = _mm_macc_pd(dy01,fscal,fjy1);
 332             fjz1             = _mm_macc_pd(dz01,fscal,fjz1);
 333
 334             /**************************
 335              * CALCULATE INTERACTIONS *
 336              **************************/
 337
 338             r02              = _mm_mul_pd(rsq02,rinv02);
 339
 340             /* Calculate table index by multiplying r with table scale and truncate to integer */
 341             rt               = _mm_mul_pd(r02,vftabscale);
 342             vfitab           = _mm_cvttpd_epi32(rt);
 343 #ifdef __XOP__
 344             vfeps            = _mm_frcz_pd(rt);
 345 #else
 346             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 347 #endif
 348             twovfeps         = _mm_add_pd(vfeps,vfeps);
 349             vfitab           = _mm_slli_epi32(vfitab,2);
 350
 351             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 352             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 353             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 354             GMX_MM_TRANSPOSE2_PD(Y,F);
 355             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 356             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
 357             GMX_MM_TRANSPOSE2_PD(G,H);
 358             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 359             VV               = _mm_macc_pd(vfeps,Fp,Y);
 360             velec            = _mm_mul_pd(qq02,VV);
 361             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 362             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq02,FF),_mm_mul_pd(vftabscale,rinv02)));
 363
 364             /* Update potential sum for this i atom from the interaction with this j atom. */
 365             velecsum         = _mm_add_pd(velecsum,velec);
 366
 367             fscal            = felec;
 368
 369             /* Update vectorial force */
 370             fix0             = _mm_macc_pd(dx02,fscal,fix0);
 371             fiy0             = _mm_macc_pd(dy02,fscal,fiy0);
 372             fiz0             = _mm_macc_pd(dz02,fscal,fiz0);
 373
 374             fjx2             = _mm_macc_pd(dx02,fscal,fjx2);
 375             fjy2             = _mm_macc_pd(dy02,fscal,fjy2);
 376             fjz2             = _mm_macc_pd(dz02,fscal,fjz2);
 377
 378             /**************************
 379              * CALCULATE INTERACTIONS *
 380              **************************/
 381
 382             r10              = _mm_mul_pd(rsq10,rinv10);
 383
 384             /* Calculate table index by multiplying r with table scale and truncate to integer */
 385             rt               = _mm_mul_pd(r10,vftabscale);
 386             vfitab           = _mm_cvttpd_epi32(rt);
 387 #ifdef __XOP__
 388             vfeps            = _mm_frcz_pd(rt);
 389 #else
 390             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 391 #endif
 392             twovfeps         = _mm_add_pd(vfeps,vfeps);
 393             vfitab           = _mm_slli_epi32(vfitab,2);
 394
 395             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 396             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 397             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 398             GMX_MM_TRANSPOSE2_PD(Y,F);
 399             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 400             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
 401             GMX_MM_TRANSPOSE2_PD(G,H);
 402             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 403             VV               = _mm_macc_pd(vfeps,Fp,Y);
 404             velec            = _mm_mul_pd(qq10,VV);
 405             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 406             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq10,FF),_mm_mul_pd(vftabscale,rinv10)));
 407
 408             /* Update potential sum for this i atom from the interaction with this j atom. */
 409             velecsum         = _mm_add_pd(velecsum,velec);
 410
 411             fscal            = felec;
 412
 413             /* Update vectorial force */
 414             fix1             = _mm_macc_pd(dx10,fscal,fix1);
 415             fiy1             = _mm_macc_pd(dy10,fscal,fiy1);
 416             fiz1             = _mm_macc_pd(dz10,fscal,fiz1);
 417
 418             fjx0             = _mm_macc_pd(dx10,fscal,fjx0);
 419             fjy0             = _mm_macc_pd(dy10,fscal,fjy0);
 420             fjz0             = _mm_macc_pd(dz10,fscal,fjz0);
 421
 422             /**************************
 423              * CALCULATE INTERACTIONS *
 424              **************************/
 425
 426             r11              = _mm_mul_pd(rsq11,rinv11);
 427
 428             /* Calculate table index by multiplying r with table scale and truncate to integer */
 429             rt               = _mm_mul_pd(r11,vftabscale);
 430             vfitab           = _mm_cvttpd_epi32(rt);
 431 #ifdef __XOP__
 432             vfeps            = _mm_frcz_pd(rt);
 433 #else
 434             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 435 #endif
 436             twovfeps         = _mm_add_pd(vfeps,vfeps);
 437             vfitab           = _mm_slli_epi32(vfitab,2);
 438
 439             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 440             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 441             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 442             GMX_MM_TRANSPOSE2_PD(Y,F);
 443             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 444             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
 445             GMX_MM_TRANSPOSE2_PD(G,H);
 446             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 447             VV               = _mm_macc_pd(vfeps,Fp,Y);
 448             velec            = _mm_mul_pd(qq11,VV);
 449             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 450             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq11,FF),_mm_mul_pd(vftabscale,rinv11)));
 451
 452             /* Update potential sum for this i atom from the interaction with this j atom. */
 453             velecsum         = _mm_add_pd(velecsum,velec);
 454
 455             fscal            = felec;
 456
 457             /* Update vectorial force */
 458             fix1             = _mm_macc_pd(dx11,fscal,fix1);
 459             fiy1             = _mm_macc_pd(dy11,fscal,fiy1);
 460             fiz1             = _mm_macc_pd(dz11,fscal,fiz1);
 461
 462             fjx1             = _mm_macc_pd(dx11,fscal,fjx1);
 463             fjy1             = _mm_macc_pd(dy11,fscal,fjy1);
 464             fjz1             = _mm_macc_pd(dz11,fscal,fjz1);
 465
 466             /**************************
 467              * CALCULATE INTERACTIONS *
 468              **************************/
 469
 470             r12              = _mm_mul_pd(rsq12,rinv12);
 471
 472             /* Calculate table index by multiplying r with table scale and truncate to integer */
 473             rt               = _mm_mul_pd(r12,vftabscale);
 474             vfitab           = _mm_cvttpd_epi32(rt);
 475 #ifdef __XOP__
 476             vfeps            = _mm_frcz_pd(rt);
 477 #else
 478             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 479 #endif
 480             twovfeps         = _mm_add_pd(vfeps,vfeps);
 481             vfitab           = _mm_slli_epi32(vfitab,2);
 482
 483             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 484             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 485             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 486             GMX_MM_TRANSPOSE2_PD(Y,F);
 487             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 488             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
 489             GMX_MM_TRANSPOSE2_PD(G,H);
 490             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 491             VV               = _mm_macc_pd(vfeps,Fp,Y);
 492             velec            = _mm_mul_pd(qq12,VV);
 493             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 494             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq12,FF),_mm_mul_pd(vftabscale,rinv12)));
 495
 496             /* Update potential sum for this i atom from the interaction with this j atom. */
 497             velecsum         = _mm_add_pd(velecsum,velec);
 498
 499             fscal            = felec;
 500
 501             /* Update vectorial force */
 502             fix1             = _mm_macc_pd(dx12,fscal,fix1);
 503             fiy1             = _mm_macc_pd(dy12,fscal,fiy1);
 504             fiz1             = _mm_macc_pd(dz12,fscal,fiz1);
 505
 506             fjx2             = _mm_macc_pd(dx12,fscal,fjx2);
 507             fjy2             = _mm_macc_pd(dy12,fscal,fjy2);
 508             fjz2             = _mm_macc_pd(dz12,fscal,fjz2);
 509
 510             /**************************
 511              * CALCULATE INTERACTIONS *
 512              **************************/
 513
 514             r20              = _mm_mul_pd(rsq20,rinv20);
 515
 516             /* Calculate table index by multiplying r with table scale and truncate to integer */
 517             rt               = _mm_mul_pd(r20,vftabscale);
 518             vfitab           = _mm_cvttpd_epi32(rt);
 519 #ifdef __XOP__
 520             vfeps            = _mm_frcz_pd(rt);
 521 #else
 522             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 523 #endif
 524             twovfeps         = _mm_add_pd(vfeps,vfeps);
 525             vfitab           = _mm_slli_epi32(vfitab,2);
 526
 527             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 528             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 529             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 530             GMX_MM_TRANSPOSE2_PD(Y,F);
 531             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 532             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
 533             GMX_MM_TRANSPOSE2_PD(G,H);
 534             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 535             VV               = _mm_macc_pd(vfeps,Fp,Y);
 536             velec            = _mm_mul_pd(qq20,VV);
 537             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 538             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq20,FF),_mm_mul_pd(vftabscale,rinv20)));
 539
 540             /* Update potential sum for this i atom from the interaction with this j atom. */
 541             velecsum         = _mm_add_pd(velecsum,velec);
 542
 543             fscal            = felec;
 544
 545             /* Update vectorial force */
 546             fix2             = _mm_macc_pd(dx20,fscal,fix2);
 547             fiy2             = _mm_macc_pd(dy20,fscal,fiy2);
 548             fiz2             = _mm_macc_pd(dz20,fscal,fiz2);
 549
 550             fjx0             = _mm_macc_pd(dx20,fscal,fjx0);
 551             fjy0             = _mm_macc_pd(dy20,fscal,fjy0);
 552             fjz0             = _mm_macc_pd(dz20,fscal,fjz0);
 553
 554             /**************************
 555              * CALCULATE INTERACTIONS *
 556              **************************/
 557
 558             r21              = _mm_mul_pd(rsq21,rinv21);
 559
 560             /* Calculate table index by multiplying r with table scale and truncate to integer */
 561             rt               = _mm_mul_pd(r21,vftabscale);
 562             vfitab           = _mm_cvttpd_epi32(rt);
 563 #ifdef __XOP__
 564             vfeps            = _mm_frcz_pd(rt);
 565 #else
 566             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 567 #endif
 568             twovfeps         = _mm_add_pd(vfeps,vfeps);
 569             vfitab           = _mm_slli_epi32(vfitab,2);
 570
 571             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 572             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 573             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 574             GMX_MM_TRANSPOSE2_PD(Y,F);
 575             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 576             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
 577             GMX_MM_TRANSPOSE2_PD(G,H);
 578             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 579             VV               = _mm_macc_pd(vfeps,Fp,Y);
 580             velec            = _mm_mul_pd(qq21,VV);
 581             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 582             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq21,FF),_mm_mul_pd(vftabscale,rinv21)));
 583
 584             /* Update potential sum for this i atom from the interaction with this j atom. */
 585             velecsum         = _mm_add_pd(velecsum,velec);
 586
 587             fscal            = felec;
 588
 589             /* Update vectorial force */
 590             fix2             = _mm_macc_pd(dx21,fscal,fix2);
 591             fiy2             = _mm_macc_pd(dy21,fscal,fiy2);
 592             fiz2             = _mm_macc_pd(dz21,fscal,fiz2);
 593
 594             fjx1             = _mm_macc_pd(dx21,fscal,fjx1);
 595             fjy1             = _mm_macc_pd(dy21,fscal,fjy1);
 596             fjz1             = _mm_macc_pd(dz21,fscal,fjz1);
 597
 598             /**************************
 599              * CALCULATE INTERACTIONS *
 600              **************************/
 601
 602             r22              = _mm_mul_pd(rsq22,rinv22);
 603
 604             /* Calculate table index by multiplying r with table scale and truncate to integer */
 605             rt               = _mm_mul_pd(r22,vftabscale);
 606             vfitab           = _mm_cvttpd_epi32(rt);
 607 #ifdef __XOP__
 608             vfeps            = _mm_frcz_pd(rt);
 609 #else
 610             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 611 #endif
 612             twovfeps         = _mm_add_pd(vfeps,vfeps);
 613             vfitab           = _mm_slli_epi32(vfitab,2);
 614
 615             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 616             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 617             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
 618             GMX_MM_TRANSPOSE2_PD(Y,F);
 619             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 620             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
 621             GMX_MM_TRANSPOSE2_PD(G,H);
 622             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 623             VV               = _mm_macc_pd(vfeps,Fp,Y);
 624             velec            = _mm_mul_pd(qq22,VV);
 625             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 626             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq22,FF),_mm_mul_pd(vftabscale,rinv22)));
 627
 628             /* Update potential sum for this i atom from the interaction with this j atom. */
 629             velecsum         = _mm_add_pd(velecsum,velec);
 630
 631             fscal            = felec;
 632
 633             /* Update vectorial force */
 634             fix2             = _mm_macc_pd(dx22,fscal,fix2);
 635             fiy2             = _mm_macc_pd(dy22,fscal,fiy2);
 636             fiz2             = _mm_macc_pd(dz22,fscal,fiz2);
 637
 638             fjx2             = _mm_macc_pd(dx22,fscal,fjx2);
 639             fjy2             = _mm_macc_pd(dy22,fscal,fjy2);
 640             fjz2             = _mm_macc_pd(dz22,fscal,fjz2);
 641
 642             gmx_mm_decrement_3rvec_2ptr_swizzle_pd(f+j_coord_offsetA,f+j_coord_offsetB,fjx0,fjy0,fjz0,fjx1,fjy1,fjz1,fjx2,fjy2,fjz2);
 643
 644             /* Inner loop uses 414 flops */
 645         }
 646
 647         if(jidx<j_index_end)
 648         {
 649
 650             jnrA             = jjnr[jidx];
 651             j_coord_offsetA  = DIM*jnrA;
 652
 653             /* load j atom coordinates */
 654             gmx_mm_load_3rvec_1ptr_swizzle_pd(x+j_coord_offsetA,
 655                                               &jx0,&jy0,&jz0,&jx1,&jy1,&jz1,&jx2,&jy2,&jz2);
 656
 657             /* Calculate displacement vector */
 658             dx00             = _mm_sub_pd(ix0,jx0);
 659             dy00             = _mm_sub_pd(iy0,jy0);
 660             dz00             = _mm_sub_pd(iz0,jz0);
 661             dx01             = _mm_sub_pd(ix0,jx1);
 662             dy01             = _mm_sub_pd(iy0,jy1);
 663             dz01             = _mm_sub_pd(iz0,jz1);
 664             dx02             = _mm_sub_pd(ix0,jx2);
 665             dy02             = _mm_sub_pd(iy0,jy2);
 666             dz02             = _mm_sub_pd(iz0,jz2);
 667             dx10             = _mm_sub_pd(ix1,jx0);
 668             dy10             = _mm_sub_pd(iy1,jy0);
 669             dz10             = _mm_sub_pd(iz1,jz0);
 670             dx11             = _mm_sub_pd(ix1,jx1);
 671             dy11             = _mm_sub_pd(iy1,jy1);
 672             dz11             = _mm_sub_pd(iz1,jz1);
 673             dx12             = _mm_sub_pd(ix1,jx2);
 674             dy12             = _mm_sub_pd(iy1,jy2);
 675             dz12             = _mm_sub_pd(iz1,jz2);
 676             dx20             = _mm_sub_pd(ix2,jx0);
 677             dy20             = _mm_sub_pd(iy2,jy0);
 678             dz20             = _mm_sub_pd(iz2,jz0);
 679             dx21             = _mm_sub_pd(ix2,jx1);
 680             dy21             = _mm_sub_pd(iy2,jy1);
 681             dz21             = _mm_sub_pd(iz2,jz1);
 682             dx22             = _mm_sub_pd(ix2,jx2);
 683             dy22             = _mm_sub_pd(iy2,jy2);
 684             dz22             = _mm_sub_pd(iz2,jz2);
 685
 686             /* Calculate squared distance and things based on it */
 687             rsq00            = gmx_mm_calc_rsq_pd(dx00,dy00,dz00);
 688             rsq01            = gmx_mm_calc_rsq_pd(dx01,dy01,dz01);
 689             rsq02            = gmx_mm_calc_rsq_pd(dx02,dy02,dz02);
 690             rsq10            = gmx_mm_calc_rsq_pd(dx10,dy10,dz10);
 691             rsq11            = gmx_mm_calc_rsq_pd(dx11,dy11,dz11);
 692             rsq12            = gmx_mm_calc_rsq_pd(dx12,dy12,dz12);
 693             rsq20            = gmx_mm_calc_rsq_pd(dx20,dy20,dz20);
 694             rsq21            = gmx_mm_calc_rsq_pd(dx21,dy21,dz21);
 695             rsq22            = gmx_mm_calc_rsq_pd(dx22,dy22,dz22);
 696
 697             rinv00           = gmx_mm_invsqrt_pd(rsq00);
 698             rinv01           = gmx_mm_invsqrt_pd(rsq01);
 699             rinv02           = gmx_mm_invsqrt_pd(rsq02);
 700             rinv10           = gmx_mm_invsqrt_pd(rsq10);
 701             rinv11           = gmx_mm_invsqrt_pd(rsq11);
 702             rinv12           = gmx_mm_invsqrt_pd(rsq12);
 703             rinv20           = gmx_mm_invsqrt_pd(rsq20);
 704             rinv21           = gmx_mm_invsqrt_pd(rsq21);
 705             rinv22           = gmx_mm_invsqrt_pd(rsq22);
 706
 707             fjx0             = _mm_setzero_pd();
 708             fjy0             = _mm_setzero_pd();
 709             fjz0             = _mm_setzero_pd();
 710             fjx1             = _mm_setzero_pd();
 711             fjy1             = _mm_setzero_pd();
 712             fjz1             = _mm_setzero_pd();
 713             fjx2             = _mm_setzero_pd();
 714             fjy2             = _mm_setzero_pd();
 715             fjz2             = _mm_setzero_pd();
 716
 717             /**************************
 718              * CALCULATE INTERACTIONS *
 719              **************************/
 720
 721             r00              = _mm_mul_pd(rsq00,rinv00);
 722
 723             /* Calculate table index by multiplying r with table scale and truncate to integer */
 724             rt               = _mm_mul_pd(r00,vftabscale);
 725             vfitab           = _mm_cvttpd_epi32(rt);
 726 #ifdef __XOP__
 727             vfeps            = _mm_frcz_pd(rt);
 728 #else
 729             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 730 #endif
 731             twovfeps         = _mm_add_pd(vfeps,vfeps);
 732             vfitab           = _mm_slli_epi32(vfitab,2);
 733
 734             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 735             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 736             F                = _mm_setzero_pd();
 737             GMX_MM_TRANSPOSE2_PD(Y,F);
 738             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 739             H                = _mm_setzero_pd();
 740             GMX_MM_TRANSPOSE2_PD(G,H);
 741             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 742             VV               = _mm_macc_pd(vfeps,Fp,Y);
 743             velec            = _mm_mul_pd(qq00,VV);
 744             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 745             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq00,FF),_mm_mul_pd(vftabscale,rinv00)));
 746
 747             /* Update potential sum for this i atom from the interaction with this j atom. */
 748             velec            = _mm_unpacklo_pd(velec,_mm_setzero_pd());
 749             velecsum         = _mm_add_pd(velecsum,velec);
 750
 751             fscal            = felec;
 752
 753             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
 754
 755             /* Update vectorial force */
 756             fix0             = _mm_macc_pd(dx00,fscal,fix0);
 757             fiy0             = _mm_macc_pd(dy00,fscal,fiy0);
 758             fiz0             = _mm_macc_pd(dz00,fscal,fiz0);
 759
 760             fjx0             = _mm_macc_pd(dx00,fscal,fjx0);
 761             fjy0             = _mm_macc_pd(dy00,fscal,fjy0);
 762             fjz0             = _mm_macc_pd(dz00,fscal,fjz0);
 763
 764             /**************************
 765              * CALCULATE INTERACTIONS *
 766              **************************/
 767
 768             r01              = _mm_mul_pd(rsq01,rinv01);
 769
 770             /* Calculate table index by multiplying r with table scale and truncate to integer */
 771             rt               = _mm_mul_pd(r01,vftabscale);
 772             vfitab           = _mm_cvttpd_epi32(rt);
 773 #ifdef __XOP__
 774             vfeps            = _mm_frcz_pd(rt);
 775 #else
 776             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 777 #endif
 778             twovfeps         = _mm_add_pd(vfeps,vfeps);
 779             vfitab           = _mm_slli_epi32(vfitab,2);
 780
 781             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 782             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 783             F                = _mm_setzero_pd();
 784             GMX_MM_TRANSPOSE2_PD(Y,F);
 785             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 786             H                = _mm_setzero_pd();
 787             GMX_MM_TRANSPOSE2_PD(G,H);
 788             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 789             VV               = _mm_macc_pd(vfeps,Fp,Y);
 790             velec            = _mm_mul_pd(qq01,VV);
 791             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 792             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq01,FF),_mm_mul_pd(vftabscale,rinv01)));
 793
 794             /* Update potential sum for this i atom from the interaction with this j atom. */
 795             velec            = _mm_unpacklo_pd(velec,_mm_setzero_pd());
 796             velecsum         = _mm_add_pd(velecsum,velec);
 797
 798             fscal            = felec;
 799
 800             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
 801
 802             /* Update vectorial force */
 803             fix0             = _mm_macc_pd(dx01,fscal,fix0);
 804             fiy0             = _mm_macc_pd(dy01,fscal,fiy0);
 805             fiz0             = _mm_macc_pd(dz01,fscal,fiz0);
 806
 807             fjx1             = _mm_macc_pd(dx01,fscal,fjx1);
 808             fjy1             = _mm_macc_pd(dy01,fscal,fjy1);
 809             fjz1             = _mm_macc_pd(dz01,fscal,fjz1);
 810
 811             /**************************
 812              * CALCULATE INTERACTIONS *
 813              **************************/
 814
 815             r02              = _mm_mul_pd(rsq02,rinv02);
 816
 817             /* Calculate table index by multiplying r with table scale and truncate to integer */
 818             rt               = _mm_mul_pd(r02,vftabscale);
 819             vfitab           = _mm_cvttpd_epi32(rt);
 820 #ifdef __XOP__
 821             vfeps            = _mm_frcz_pd(rt);
 822 #else
 823             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 824 #endif
 825             twovfeps         = _mm_add_pd(vfeps,vfeps);
 826             vfitab           = _mm_slli_epi32(vfitab,2);
 827
 828             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 829             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 830             F                = _mm_setzero_pd();
 831             GMX_MM_TRANSPOSE2_PD(Y,F);
 832             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 833             H                = _mm_setzero_pd();
 834             GMX_MM_TRANSPOSE2_PD(G,H);
 835             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 836             VV               = _mm_macc_pd(vfeps,Fp,Y);
 837             velec            = _mm_mul_pd(qq02,VV);
 838             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 839             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq02,FF),_mm_mul_pd(vftabscale,rinv02)));
 840
 841             /* Update potential sum for this i atom from the interaction with this j atom. */
 842             velec            = _mm_unpacklo_pd(velec,_mm_setzero_pd());
 843             velecsum         = _mm_add_pd(velecsum,velec);
 844
 845             fscal            = felec;
 846
 847             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
 848
 849             /* Update vectorial force */
 850             fix0             = _mm_macc_pd(dx02,fscal,fix0);
 851             fiy0             = _mm_macc_pd(dy02,fscal,fiy0);
 852             fiz0             = _mm_macc_pd(dz02,fscal,fiz0);
 853
 854             fjx2             = _mm_macc_pd(dx02,fscal,fjx2);
 855             fjy2             = _mm_macc_pd(dy02,fscal,fjy2);
 856             fjz2             = _mm_macc_pd(dz02,fscal,fjz2);
 857
 858             /**************************
 859              * CALCULATE INTERACTIONS *
 860              **************************/
 861
 862             r10              = _mm_mul_pd(rsq10,rinv10);
 863
 864             /* Calculate table index by multiplying r with table scale and truncate to integer */
 865             rt               = _mm_mul_pd(r10,vftabscale);
 866             vfitab           = _mm_cvttpd_epi32(rt);
 867 #ifdef __XOP__
 868             vfeps            = _mm_frcz_pd(rt);
 869 #else
 870             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 871 #endif
 872             twovfeps         = _mm_add_pd(vfeps,vfeps);
 873             vfitab           = _mm_slli_epi32(vfitab,2);
 874
 875             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 876             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 877             F                = _mm_setzero_pd();
 878             GMX_MM_TRANSPOSE2_PD(Y,F);
 879             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 880             H                = _mm_setzero_pd();
 881             GMX_MM_TRANSPOSE2_PD(G,H);
 882             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 883             VV               = _mm_macc_pd(vfeps,Fp,Y);
 884             velec            = _mm_mul_pd(qq10,VV);
 885             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 886             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq10,FF),_mm_mul_pd(vftabscale,rinv10)));
 887
 888             /* Update potential sum for this i atom from the interaction with this j atom. */
 889             velec            = _mm_unpacklo_pd(velec,_mm_setzero_pd());
 890             velecsum         = _mm_add_pd(velecsum,velec);
 891
 892             fscal            = felec;
 893
 894             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
 895
 896             /* Update vectorial force */
 897             fix1             = _mm_macc_pd(dx10,fscal,fix1);
 898             fiy1             = _mm_macc_pd(dy10,fscal,fiy1);
 899             fiz1             = _mm_macc_pd(dz10,fscal,fiz1);
 900
 901             fjx0             = _mm_macc_pd(dx10,fscal,fjx0);
 902             fjy0             = _mm_macc_pd(dy10,fscal,fjy0);
 903             fjz0             = _mm_macc_pd(dz10,fscal,fjz0);
 904
 905             /**************************
 906              * CALCULATE INTERACTIONS *
 907              **************************/
 908
 909             r11              = _mm_mul_pd(rsq11,rinv11);
 910
 911             /* Calculate table index by multiplying r with table scale and truncate to integer */
 912             rt               = _mm_mul_pd(r11,vftabscale);
 913             vfitab           = _mm_cvttpd_epi32(rt);
 914 #ifdef __XOP__
 915             vfeps            = _mm_frcz_pd(rt);
 916 #else
 917             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 918 #endif
 919             twovfeps         = _mm_add_pd(vfeps,vfeps);
 920             vfitab           = _mm_slli_epi32(vfitab,2);
 921
 922             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 923             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 924             F                = _mm_setzero_pd();
 925             GMX_MM_TRANSPOSE2_PD(Y,F);
 926             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 927             H                = _mm_setzero_pd();
 928             GMX_MM_TRANSPOSE2_PD(G,H);
 929             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 930             VV               = _mm_macc_pd(vfeps,Fp,Y);
 931             velec            = _mm_mul_pd(qq11,VV);
 932             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 933             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq11,FF),_mm_mul_pd(vftabscale,rinv11)));
 934
 935             /* Update potential sum for this i atom from the interaction with this j atom. */
 936             velec            = _mm_unpacklo_pd(velec,_mm_setzero_pd());
 937             velecsum         = _mm_add_pd(velecsum,velec);
 938
 939             fscal            = felec;
 940
 941             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
 942
 943             /* Update vectorial force */
 944             fix1             = _mm_macc_pd(dx11,fscal,fix1);
 945             fiy1             = _mm_macc_pd(dy11,fscal,fiy1);
 946             fiz1             = _mm_macc_pd(dz11,fscal,fiz1);
 947
 948             fjx1             = _mm_macc_pd(dx11,fscal,fjx1);
 949             fjy1             = _mm_macc_pd(dy11,fscal,fjy1);
 950             fjz1             = _mm_macc_pd(dz11,fscal,fjz1);
 951
 952             /**************************
 953              * CALCULATE INTERACTIONS *
 954              **************************/
 955
 956             r12              = _mm_mul_pd(rsq12,rinv12);
 957
 958             /* Calculate table index by multiplying r with table scale and truncate to integer */
 959             rt               = _mm_mul_pd(r12,vftabscale);
 960             vfitab           = _mm_cvttpd_epi32(rt);
 961 #ifdef __XOP__
 962             vfeps            = _mm_frcz_pd(rt);
 963 #else
 964             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
 965 #endif
 966             twovfeps         = _mm_add_pd(vfeps,vfeps);
 967             vfitab           = _mm_slli_epi32(vfitab,2);
 968
 969             /* CUBIC SPLINE TABLE ELECTROSTATICS */
 970             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
 971             F                = _mm_setzero_pd();
 972             GMX_MM_TRANSPOSE2_PD(Y,F);
 973             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
 974             H                = _mm_setzero_pd();
 975             GMX_MM_TRANSPOSE2_PD(G,H);
 976             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
 977             VV               = _mm_macc_pd(vfeps,Fp,Y);
 978             velec            = _mm_mul_pd(qq12,VV);
 979             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
 980             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq12,FF),_mm_mul_pd(vftabscale,rinv12)));
 981
 982             /* Update potential sum for this i atom from the interaction with this j atom. */
 983             velec            = _mm_unpacklo_pd(velec,_mm_setzero_pd());
 984             velecsum         = _mm_add_pd(velecsum,velec);
 985
 986             fscal            = felec;
 987
 988             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
 989
 990             /* Update vectorial force */
 991             fix1             = _mm_macc_pd(dx12,fscal,fix1);
 992             fiy1             = _mm_macc_pd(dy12,fscal,fiy1);
 993             fiz1             = _mm_macc_pd(dz12,fscal,fiz1);
 994
 995             fjx2             = _mm_macc_pd(dx12,fscal,fjx2);
 996             fjy2             = _mm_macc_pd(dy12,fscal,fjy2);
 997             fjz2             = _mm_macc_pd(dz12,fscal,fjz2);
 998
 999             /**************************
1000              * CALCULATE INTERACTIONS *
1001              **************************/
1002
1003             r20              = _mm_mul_pd(rsq20,rinv20);
1004
1005             /* Calculate table index by multiplying r with table scale and truncate to integer */
1006             rt               = _mm_mul_pd(r20,vftabscale);
1007             vfitab           = _mm_cvttpd_epi32(rt);
1008 #ifdef __XOP__
1009             vfeps            = _mm_frcz_pd(rt);
1010 #else
1011             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1012 #endif
1013             twovfeps         = _mm_add_pd(vfeps,vfeps);
1014             vfitab           = _mm_slli_epi32(vfitab,2);
1015
1016             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1017             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1018             F                = _mm_setzero_pd();
1019             GMX_MM_TRANSPOSE2_PD(Y,F);
1020             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1021             H                = _mm_setzero_pd();
1022             GMX_MM_TRANSPOSE2_PD(G,H);
1023             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1024             VV               = _mm_macc_pd(vfeps,Fp,Y);
1025             velec            = _mm_mul_pd(qq20,VV);
1026             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1027             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq20,FF),_mm_mul_pd(vftabscale,rinv20)));
1028
1029             /* Update potential sum for this i atom from the interaction with this j atom. */
1030             velec            = _mm_unpacklo_pd(velec,_mm_setzero_pd());
1031             velecsum         = _mm_add_pd(velecsum,velec);
1032
1033             fscal            = felec;
1034
1035             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
1036
1037             /* Update vectorial force */
1038             fix2             = _mm_macc_pd(dx20,fscal,fix2);
1039             fiy2             = _mm_macc_pd(dy20,fscal,fiy2);
1040             fiz2             = _mm_macc_pd(dz20,fscal,fiz2);
1041
1042             fjx0             = _mm_macc_pd(dx20,fscal,fjx0);
1043             fjy0             = _mm_macc_pd(dy20,fscal,fjy0);
1044             fjz0             = _mm_macc_pd(dz20,fscal,fjz0);
1045
1046             /**************************
1047              * CALCULATE INTERACTIONS *
1048              **************************/
1049
1050             r21              = _mm_mul_pd(rsq21,rinv21);
1051
1052             /* Calculate table index by multiplying r with table scale and truncate to integer */
1053             rt               = _mm_mul_pd(r21,vftabscale);
1054             vfitab           = _mm_cvttpd_epi32(rt);
1055 #ifdef __XOP__
1056             vfeps            = _mm_frcz_pd(rt);
1057 #else
1058             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1059 #endif
1060             twovfeps         = _mm_add_pd(vfeps,vfeps);
1061             vfitab           = _mm_slli_epi32(vfitab,2);
1062
1063             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1064             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1065             F                = _mm_setzero_pd();
1066             GMX_MM_TRANSPOSE2_PD(Y,F);
1067             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1068             H                = _mm_setzero_pd();
1069             GMX_MM_TRANSPOSE2_PD(G,H);
1070             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1071             VV               = _mm_macc_pd(vfeps,Fp,Y);
1072             velec            = _mm_mul_pd(qq21,VV);
1073             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1074             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq21,FF),_mm_mul_pd(vftabscale,rinv21)));
1075
1076             /* Update potential sum for this i atom from the interaction with this j atom. */
1077             velec            = _mm_unpacklo_pd(velec,_mm_setzero_pd());
1078             velecsum         = _mm_add_pd(velecsum,velec);
1079
1080             fscal            = felec;
1081
1082             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
1083
1084             /* Update vectorial force */
1085             fix2             = _mm_macc_pd(dx21,fscal,fix2);
1086             fiy2             = _mm_macc_pd(dy21,fscal,fiy2);
1087             fiz2             = _mm_macc_pd(dz21,fscal,fiz2);
1088
1089             fjx1             = _mm_macc_pd(dx21,fscal,fjx1);
1090             fjy1             = _mm_macc_pd(dy21,fscal,fjy1);
1091             fjz1             = _mm_macc_pd(dz21,fscal,fjz1);
1092
1093             /**************************
1094              * CALCULATE INTERACTIONS *
1095              **************************/
1096
1097             r22              = _mm_mul_pd(rsq22,rinv22);
1098
1099             /* Calculate table index by multiplying r with table scale and truncate to integer */
1100             rt               = _mm_mul_pd(r22,vftabscale);
1101             vfitab           = _mm_cvttpd_epi32(rt);
1102 #ifdef __XOP__
1103             vfeps            = _mm_frcz_pd(rt);
1104 #else
1105             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1106 #endif
1107             twovfeps         = _mm_add_pd(vfeps,vfeps);
1108             vfitab           = _mm_slli_epi32(vfitab,2);
1109
1110             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1111             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1112             F                = _mm_setzero_pd();
1113             GMX_MM_TRANSPOSE2_PD(Y,F);
1114             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1115             H                = _mm_setzero_pd();
1116             GMX_MM_TRANSPOSE2_PD(G,H);
1117             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1118             VV               = _mm_macc_pd(vfeps,Fp,Y);
1119             velec            = _mm_mul_pd(qq22,VV);
1120             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1121             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq22,FF),_mm_mul_pd(vftabscale,rinv22)));
1122
1123             /* Update potential sum for this i atom from the interaction with this j atom. */
1124             velec            = _mm_unpacklo_pd(velec,_mm_setzero_pd());
1125             velecsum         = _mm_add_pd(velecsum,velec);
1126
1127             fscal            = felec;
1128
1129             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
1130
1131             /* Update vectorial force */
1132             fix2             = _mm_macc_pd(dx22,fscal,fix2);
1133             fiy2             = _mm_macc_pd(dy22,fscal,fiy2);
1134             fiz2             = _mm_macc_pd(dz22,fscal,fiz2);
1135
1136             fjx2             = _mm_macc_pd(dx22,fscal,fjx2);
1137             fjy2             = _mm_macc_pd(dy22,fscal,fjy2);
1138             fjz2             = _mm_macc_pd(dz22,fscal,fjz2);
1139
1140             gmx_mm_decrement_3rvec_1ptr_swizzle_pd(f+j_coord_offsetA,fjx0,fjy0,fjz0,fjx1,fjy1,fjz1,fjx2,fjy2,fjz2);
1141
1142             /* Inner loop uses 414 flops */
1143         }
1144
1145         /* End of innermost loop */
1146
1147         gmx_mm_update_iforce_3atom_swizzle_pd(fix0,fiy0,fiz0,fix1,fiy1,fiz1,fix2,fiy2,fiz2,
1148                                               f+i_coord_offset,fshift+i_shift_offset);
1149
1150         ggid                        = gid[iidx];
1151         /* Update potential energies */
1152         gmx_mm_update_1pot_pd(velecsum,kernel_data->energygrp_elec+ggid);
1153
1154         /* Increment number of inner iterations */
1155         inneriter                  += j_index_end - j_index_start;
1156
1157         /* Outer loop uses 19 flops */
1158     }
1159
1160     /* Increment number of outer iterations */
1161     outeriter        += nri;
1162
1163     /* Update outer/inner flops */
1164
1165     inc_nrnb(nrnb,eNR_NBKERNEL_ELEC_W3W3_VF,outeriter*19 + inneriter*414);
1166 }
1167 /*
1168  * Gromacs nonbonded kernel:   nb_kernel_ElecCSTab_VdwNone_GeomW3W3_F_avx_128_fma_double
1169  * Electrostatics interaction: CubicSplineTable
1170  * VdW interaction:            None
1171  * Geometry:                   Water3-Water3
1172  * Calculate force/pot:        Force
1173  */
1174 void
1175 nb_kernel_ElecCSTab_VdwNone_GeomW3W3_F_avx_128_fma_double
1176                     (t_nblist * gmx_restrict                nlist,
1177                      rvec * gmx_restrict                    xx,
1178                      rvec * gmx_restrict                    ff,
1179                      t_forcerec * gmx_restrict              fr,
1180                      t_mdatoms * gmx_restrict               mdatoms,
1181                      nb_kernel_data_t * gmx_restrict        kernel_data,
1182                      t_nrnb * gmx_restrict                  nrnb)
1183 {
1184     /* Suffixes 0,1,2,3 refer to particle indices for waters in the inner or outer loop, or
1185      * just 0 for non-waters.
1186      * Suffixes A,B refer to j loop unrolling done with SSE double precision, e.g. for the two different
1187      * jnr indices corresponding to data put in the four positions in the SIMD register.
1188      */
1189     int              i_shift_offset,i_coord_offset,outeriter,inneriter;
1190     int              j_index_start,j_index_end,jidx,nri,inr,ggid,iidx;
1191     int              jnrA,jnrB;
1192     int              j_coord_offsetA,j_coord_offsetB;
1193     int              *iinr,*jindex,*jjnr,*shiftidx,*gid;
1194     real             rcutoff_scalar;
1195     real             *shiftvec,*fshift,*x,*f;
1196     __m128d          tx,ty,tz,fscal,rcutoff,rcutoff2,jidxall;
1197     int              vdwioffset0;
1198     __m128d          ix0,iy0,iz0,fix0,fiy0,fiz0,iq0,isai0;
1199     int              vdwioffset1;
1200     __m128d          ix1,iy1,iz1,fix1,fiy1,fiz1,iq1,isai1;
1201     int              vdwioffset2;
1202     __m128d          ix2,iy2,iz2,fix2,fiy2,fiz2,iq2,isai2;
1203     int              vdwjidx0A,vdwjidx0B;
1204     __m128d          jx0,jy0,jz0,fjx0,fjy0,fjz0,jq0,isaj0;
1205     int              vdwjidx1A,vdwjidx1B;
1206     __m128d          jx1,jy1,jz1,fjx1,fjy1,fjz1,jq1,isaj1;
1207     int              vdwjidx2A,vdwjidx2B;
1208     __m128d          jx2,jy2,jz2,fjx2,fjy2,fjz2,jq2,isaj2;
1209     __m128d          dx00,dy00,dz00,rsq00,rinv00,rinvsq00,r00,qq00,c6_00,c12_00;
1210     __m128d          dx01,dy01,dz01,rsq01,rinv01,rinvsq01,r01,qq01,c6_01,c12_01;
1211     __m128d          dx02,dy02,dz02,rsq02,rinv02,rinvsq02,r02,qq02,c6_02,c12_02;
1212     __m128d          dx10,dy10,dz10,rsq10,rinv10,rinvsq10,r10,qq10,c6_10,c12_10;
1213     __m128d          dx11,dy11,dz11,rsq11,rinv11,rinvsq11,r11,qq11,c6_11,c12_11;
1214     __m128d          dx12,dy12,dz12,rsq12,rinv12,rinvsq12,r12,qq12,c6_12,c12_12;
1215     __m128d          dx20,dy20,dz20,rsq20,rinv20,rinvsq20,r20,qq20,c6_20,c12_20;
1216     __m128d          dx21,dy21,dz21,rsq21,rinv21,rinvsq21,r21,qq21,c6_21,c12_21;
1217     __m128d          dx22,dy22,dz22,rsq22,rinv22,rinvsq22,r22,qq22,c6_22,c12_22;
1218     __m128d          velec,felec,velecsum,facel,crf,krf,krf2;
1219     real             *charge;
1220     __m128i          vfitab;
1221     __m128i          ifour       = _mm_set1_epi32(4);
1222     __m128d          rt,vfeps,vftabscale,Y,F,G,H,Heps,Fp,VV,FF,twovfeps;
1223     real             *vftab;
1224     __m128d          dummy_mask,cutoff_mask;
1225     __m128d          signbit   = gmx_mm_castsi128_pd( _mm_set_epi32(0x80000000,0x00000000,0x80000000,0x00000000) );
1226     __m128d          one     = _mm_set1_pd(1.0);
1227     __m128d          two     = _mm_set1_pd(2.0);
1228     x                = xx[0];
1229     f                = ff[0];
1230
1231     nri              = nlist->nri;
1232     iinr             = nlist->iinr;
1233     jindex           = nlist->jindex;
1234     jjnr             = nlist->jjnr;
1235     shiftidx         = nlist->shift;
1236     gid              = nlist->gid;
1237     shiftvec         = fr->shift_vec[0];
1238     fshift           = fr->fshift[0];
1239     facel            = _mm_set1_pd(fr->epsfac);
1240     charge           = mdatoms->chargeA;
1241
1242     vftab            = kernel_data->table_elec->data;
1243     vftabscale       = _mm_set1_pd(kernel_data->table_elec->scale);
1244
1245     /* Setup water-specific parameters */
1246     inr              = nlist->iinr[0];
1247     iq0              = _mm_mul_pd(facel,_mm_set1_pd(charge[inr+0]));
1248     iq1              = _mm_mul_pd(facel,_mm_set1_pd(charge[inr+1]));
1249     iq2              = _mm_mul_pd(facel,_mm_set1_pd(charge[inr+2]));
1250
1251     jq0              = _mm_set1_pd(charge[inr+0]);
1252     jq1              = _mm_set1_pd(charge[inr+1]);
1253     jq2              = _mm_set1_pd(charge[inr+2]);
1254     qq00             = _mm_mul_pd(iq0,jq0);
1255     qq01             = _mm_mul_pd(iq0,jq1);
1256     qq02             = _mm_mul_pd(iq0,jq2);
1257     qq10             = _mm_mul_pd(iq1,jq0);
1258     qq11             = _mm_mul_pd(iq1,jq1);
1259     qq12             = _mm_mul_pd(iq1,jq2);
1260     qq20             = _mm_mul_pd(iq2,jq0);
1261     qq21             = _mm_mul_pd(iq2,jq1);
1262     qq22             = _mm_mul_pd(iq2,jq2);
1263
1264     /* Avoid stupid compiler warnings */
1265     jnrA = jnrB = 0;
1266     j_coord_offsetA = 0;
1267     j_coord_offsetB = 0;
1268
1269     outeriter        = 0;
1270     inneriter        = 0;
1271
1272     /* Start outer loop over neighborlists */
1273     for(iidx=0; iidx<nri; iidx++)
1274     {
1275         /* Load shift vector for this list */
1276         i_shift_offset   = DIM*shiftidx[iidx];
1277
1278         /* Load limits for loop over neighbors */
1279         j_index_start    = jindex[iidx];
1280         j_index_end      = jindex[iidx+1];
1281
1282         /* Get outer coordinate index */
1283         inr              = iinr[iidx];
1284         i_coord_offset   = DIM*inr;
1285
1286         /* Load i particle coords and add shift vector */
1287         gmx_mm_load_shift_and_3rvec_broadcast_pd(shiftvec+i_shift_offset,x+i_coord_offset,
1288                                                  &ix0,&iy0,&iz0,&ix1,&iy1,&iz1,&ix2,&iy2,&iz2);
1289
1290         fix0             = _mm_setzero_pd();
1291         fiy0             = _mm_setzero_pd();
1292         fiz0             = _mm_setzero_pd();
1293         fix1             = _mm_setzero_pd();
1294         fiy1             = _mm_setzero_pd();
1295         fiz1             = _mm_setzero_pd();
1296         fix2             = _mm_setzero_pd();
1297         fiy2             = _mm_setzero_pd();
1298         fiz2             = _mm_setzero_pd();
1299
1300         /* Start inner kernel loop */
1301         for(jidx=j_index_start; jidx<j_index_end-1; jidx+=2)
1302         {
1303
1304             /* Get j neighbor index, and coordinate index */
1305             jnrA             = jjnr[jidx];
1306             jnrB             = jjnr[jidx+1];
1307             j_coord_offsetA  = DIM*jnrA;
1308             j_coord_offsetB  = DIM*jnrB;
1309
1310             /* load j atom coordinates */
1311             gmx_mm_load_3rvec_2ptr_swizzle_pd(x+j_coord_offsetA,x+j_coord_offsetB,
1312                                               &jx0,&jy0,&jz0,&jx1,&jy1,&jz1,&jx2,&jy2,&jz2);
1313
1314             /* Calculate displacement vector */
1315             dx00             = _mm_sub_pd(ix0,jx0);
1316             dy00             = _mm_sub_pd(iy0,jy0);
1317             dz00             = _mm_sub_pd(iz0,jz0);
1318             dx01             = _mm_sub_pd(ix0,jx1);
1319             dy01             = _mm_sub_pd(iy0,jy1);
1320             dz01             = _mm_sub_pd(iz0,jz1);
1321             dx02             = _mm_sub_pd(ix0,jx2);
1322             dy02             = _mm_sub_pd(iy0,jy2);
1323             dz02             = _mm_sub_pd(iz0,jz2);
1324             dx10             = _mm_sub_pd(ix1,jx0);
1325             dy10             = _mm_sub_pd(iy1,jy0);
1326             dz10             = _mm_sub_pd(iz1,jz0);
1327             dx11             = _mm_sub_pd(ix1,jx1);
1328             dy11             = _mm_sub_pd(iy1,jy1);
1329             dz11             = _mm_sub_pd(iz1,jz1);
1330             dx12             = _mm_sub_pd(ix1,jx2);
1331             dy12             = _mm_sub_pd(iy1,jy2);
1332             dz12             = _mm_sub_pd(iz1,jz2);
1333             dx20             = _mm_sub_pd(ix2,jx0);
1334             dy20             = _mm_sub_pd(iy2,jy0);
1335             dz20             = _mm_sub_pd(iz2,jz0);
1336             dx21             = _mm_sub_pd(ix2,jx1);
1337             dy21             = _mm_sub_pd(iy2,jy1);
1338             dz21             = _mm_sub_pd(iz2,jz1);
1339             dx22             = _mm_sub_pd(ix2,jx2);
1340             dy22             = _mm_sub_pd(iy2,jy2);
1341             dz22             = _mm_sub_pd(iz2,jz2);
1342
1343             /* Calculate squared distance and things based on it */
1344             rsq00            = gmx_mm_calc_rsq_pd(dx00,dy00,dz00);
1345             rsq01            = gmx_mm_calc_rsq_pd(dx01,dy01,dz01);
1346             rsq02            = gmx_mm_calc_rsq_pd(dx02,dy02,dz02);
1347             rsq10            = gmx_mm_calc_rsq_pd(dx10,dy10,dz10);
1348             rsq11            = gmx_mm_calc_rsq_pd(dx11,dy11,dz11);
1349             rsq12            = gmx_mm_calc_rsq_pd(dx12,dy12,dz12);
1350             rsq20            = gmx_mm_calc_rsq_pd(dx20,dy20,dz20);
1351             rsq21            = gmx_mm_calc_rsq_pd(dx21,dy21,dz21);
1352             rsq22            = gmx_mm_calc_rsq_pd(dx22,dy22,dz22);
1353
1354             rinv00           = gmx_mm_invsqrt_pd(rsq00);
1355             rinv01           = gmx_mm_invsqrt_pd(rsq01);
1356             rinv02           = gmx_mm_invsqrt_pd(rsq02);
1357             rinv10           = gmx_mm_invsqrt_pd(rsq10);
1358             rinv11           = gmx_mm_invsqrt_pd(rsq11);
1359             rinv12           = gmx_mm_invsqrt_pd(rsq12);
1360             rinv20           = gmx_mm_invsqrt_pd(rsq20);
1361             rinv21           = gmx_mm_invsqrt_pd(rsq21);
1362             rinv22           = gmx_mm_invsqrt_pd(rsq22);
1363
1364             fjx0             = _mm_setzero_pd();
1365             fjy0             = _mm_setzero_pd();
1366             fjz0             = _mm_setzero_pd();
1367             fjx1             = _mm_setzero_pd();
1368             fjy1             = _mm_setzero_pd();
1369             fjz1             = _mm_setzero_pd();
1370             fjx2             = _mm_setzero_pd();
1371             fjy2             = _mm_setzero_pd();
1372             fjz2             = _mm_setzero_pd();
1373
1374             /**************************
1375              * CALCULATE INTERACTIONS *
1376              **************************/
1377
1378             r00              = _mm_mul_pd(rsq00,rinv00);
1379
1380             /* Calculate table index by multiplying r with table scale and truncate to integer */
1381             rt               = _mm_mul_pd(r00,vftabscale);
1382             vfitab           = _mm_cvttpd_epi32(rt);
1383 #ifdef __XOP__
1384             vfeps            = _mm_frcz_pd(rt);
1385 #else
1386             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1387 #endif
1388             twovfeps         = _mm_add_pd(vfeps,vfeps);
1389             vfitab           = _mm_slli_epi32(vfitab,2);
1390
1391             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1392             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1393             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1394             GMX_MM_TRANSPOSE2_PD(Y,F);
1395             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1396             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
1397             GMX_MM_TRANSPOSE2_PD(G,H);
1398             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1399             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1400             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq00,FF),_mm_mul_pd(vftabscale,rinv00)));
1401
1402             fscal            = felec;
1403
1404             /* Update vectorial force */
1405             fix0             = _mm_macc_pd(dx00,fscal,fix0);
1406             fiy0             = _mm_macc_pd(dy00,fscal,fiy0);
1407             fiz0             = _mm_macc_pd(dz00,fscal,fiz0);
1408
1409             fjx0             = _mm_macc_pd(dx00,fscal,fjx0);
1410             fjy0             = _mm_macc_pd(dy00,fscal,fjy0);
1411             fjz0             = _mm_macc_pd(dz00,fscal,fjz0);
1412
1413             /**************************
1414              * CALCULATE INTERACTIONS *
1415              **************************/
1416
1417             r01              = _mm_mul_pd(rsq01,rinv01);
1418
1419             /* Calculate table index by multiplying r with table scale and truncate to integer */
1420             rt               = _mm_mul_pd(r01,vftabscale);
1421             vfitab           = _mm_cvttpd_epi32(rt);
1422 #ifdef __XOP__
1423             vfeps            = _mm_frcz_pd(rt);
1424 #else
1425             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1426 #endif
1427             twovfeps         = _mm_add_pd(vfeps,vfeps);
1428             vfitab           = _mm_slli_epi32(vfitab,2);
1429
1430             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1431             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1432             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1433             GMX_MM_TRANSPOSE2_PD(Y,F);
1434             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1435             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
1436             GMX_MM_TRANSPOSE2_PD(G,H);
1437             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1438             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1439             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq01,FF),_mm_mul_pd(vftabscale,rinv01)));
1440
1441             fscal            = felec;
1442
1443             /* Update vectorial force */
1444             fix0             = _mm_macc_pd(dx01,fscal,fix0);
1445             fiy0             = _mm_macc_pd(dy01,fscal,fiy0);
1446             fiz0             = _mm_macc_pd(dz01,fscal,fiz0);
1447
1448             fjx1             = _mm_macc_pd(dx01,fscal,fjx1);
1449             fjy1             = _mm_macc_pd(dy01,fscal,fjy1);
1450             fjz1             = _mm_macc_pd(dz01,fscal,fjz1);
1451
1452             /**************************
1453              * CALCULATE INTERACTIONS *
1454              **************************/
1455
1456             r02              = _mm_mul_pd(rsq02,rinv02);
1457
1458             /* Calculate table index by multiplying r with table scale and truncate to integer */
1459             rt               = _mm_mul_pd(r02,vftabscale);
1460             vfitab           = _mm_cvttpd_epi32(rt);
1461 #ifdef __XOP__
1462             vfeps            = _mm_frcz_pd(rt);
1463 #else
1464             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1465 #endif
1466             twovfeps         = _mm_add_pd(vfeps,vfeps);
1467             vfitab           = _mm_slli_epi32(vfitab,2);
1468
1469             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1470             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1471             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1472             GMX_MM_TRANSPOSE2_PD(Y,F);
1473             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1474             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
1475             GMX_MM_TRANSPOSE2_PD(G,H);
1476             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1477             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1478             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq02,FF),_mm_mul_pd(vftabscale,rinv02)));
1479
1480             fscal            = felec;
1481
1482             /* Update vectorial force */
1483             fix0             = _mm_macc_pd(dx02,fscal,fix0);
1484             fiy0             = _mm_macc_pd(dy02,fscal,fiy0);
1485             fiz0             = _mm_macc_pd(dz02,fscal,fiz0);
1486
1487             fjx2             = _mm_macc_pd(dx02,fscal,fjx2);
1488             fjy2             = _mm_macc_pd(dy02,fscal,fjy2);
1489             fjz2             = _mm_macc_pd(dz02,fscal,fjz2);
1490
1491             /**************************
1492              * CALCULATE INTERACTIONS *
1493              **************************/
1494
1495             r10              = _mm_mul_pd(rsq10,rinv10);
1496
1497             /* Calculate table index by multiplying r with table scale and truncate to integer */
1498             rt               = _mm_mul_pd(r10,vftabscale);
1499             vfitab           = _mm_cvttpd_epi32(rt);
1500 #ifdef __XOP__
1501             vfeps            = _mm_frcz_pd(rt);
1502 #else
1503             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1504 #endif
1505             twovfeps         = _mm_add_pd(vfeps,vfeps);
1506             vfitab           = _mm_slli_epi32(vfitab,2);
1507
1508             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1509             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1510             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1511             GMX_MM_TRANSPOSE2_PD(Y,F);
1512             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1513             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
1514             GMX_MM_TRANSPOSE2_PD(G,H);
1515             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1516             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1517             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq10,FF),_mm_mul_pd(vftabscale,rinv10)));
1518
1519             fscal            = felec;
1520
1521             /* Update vectorial force */
1522             fix1             = _mm_macc_pd(dx10,fscal,fix1);
1523             fiy1             = _mm_macc_pd(dy10,fscal,fiy1);
1524             fiz1             = _mm_macc_pd(dz10,fscal,fiz1);
1525
1526             fjx0             = _mm_macc_pd(dx10,fscal,fjx0);
1527             fjy0             = _mm_macc_pd(dy10,fscal,fjy0);
1528             fjz0             = _mm_macc_pd(dz10,fscal,fjz0);
1529
1530             /**************************
1531              * CALCULATE INTERACTIONS *
1532              **************************/
1533
1534             r11              = _mm_mul_pd(rsq11,rinv11);
1535
1536             /* Calculate table index by multiplying r with table scale and truncate to integer */
1537             rt               = _mm_mul_pd(r11,vftabscale);
1538             vfitab           = _mm_cvttpd_epi32(rt);
1539 #ifdef __XOP__
1540             vfeps            = _mm_frcz_pd(rt);
1541 #else
1542             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1543 #endif
1544             twovfeps         = _mm_add_pd(vfeps,vfeps);
1545             vfitab           = _mm_slli_epi32(vfitab,2);
1546
1547             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1548             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1549             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1550             GMX_MM_TRANSPOSE2_PD(Y,F);
1551             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1552             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
1553             GMX_MM_TRANSPOSE2_PD(G,H);
1554             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1555             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1556             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq11,FF),_mm_mul_pd(vftabscale,rinv11)));
1557
1558             fscal            = felec;
1559
1560             /* Update vectorial force */
1561             fix1             = _mm_macc_pd(dx11,fscal,fix1);
1562             fiy1             = _mm_macc_pd(dy11,fscal,fiy1);
1563             fiz1             = _mm_macc_pd(dz11,fscal,fiz1);
1564
1565             fjx1             = _mm_macc_pd(dx11,fscal,fjx1);
1566             fjy1             = _mm_macc_pd(dy11,fscal,fjy1);
1567             fjz1             = _mm_macc_pd(dz11,fscal,fjz1);
1568
1569             /**************************
1570              * CALCULATE INTERACTIONS *
1571              **************************/
1572
1573             r12              = _mm_mul_pd(rsq12,rinv12);
1574
1575             /* Calculate table index by multiplying r with table scale and truncate to integer */
1576             rt               = _mm_mul_pd(r12,vftabscale);
1577             vfitab           = _mm_cvttpd_epi32(rt);
1578 #ifdef __XOP__
1579             vfeps            = _mm_frcz_pd(rt);
1580 #else
1581             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1582 #endif
1583             twovfeps         = _mm_add_pd(vfeps,vfeps);
1584             vfitab           = _mm_slli_epi32(vfitab,2);
1585
1586             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1587             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1588             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1589             GMX_MM_TRANSPOSE2_PD(Y,F);
1590             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1591             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
1592             GMX_MM_TRANSPOSE2_PD(G,H);
1593             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1594             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1595             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq12,FF),_mm_mul_pd(vftabscale,rinv12)));
1596
1597             fscal            = felec;
1598
1599             /* Update vectorial force */
1600             fix1             = _mm_macc_pd(dx12,fscal,fix1);
1601             fiy1             = _mm_macc_pd(dy12,fscal,fiy1);
1602             fiz1             = _mm_macc_pd(dz12,fscal,fiz1);
1603
1604             fjx2             = _mm_macc_pd(dx12,fscal,fjx2);
1605             fjy2             = _mm_macc_pd(dy12,fscal,fjy2);
1606             fjz2             = _mm_macc_pd(dz12,fscal,fjz2);
1607
1608             /**************************
1609              * CALCULATE INTERACTIONS *
1610              **************************/
1611
1612             r20              = _mm_mul_pd(rsq20,rinv20);
1613
1614             /* Calculate table index by multiplying r with table scale and truncate to integer */
1615             rt               = _mm_mul_pd(r20,vftabscale);
1616             vfitab           = _mm_cvttpd_epi32(rt);
1617 #ifdef __XOP__
1618             vfeps            = _mm_frcz_pd(rt);
1619 #else
1620             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1621 #endif
1622             twovfeps         = _mm_add_pd(vfeps,vfeps);
1623             vfitab           = _mm_slli_epi32(vfitab,2);
1624
1625             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1626             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1627             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1628             GMX_MM_TRANSPOSE2_PD(Y,F);
1629             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1630             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
1631             GMX_MM_TRANSPOSE2_PD(G,H);
1632             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1633             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1634             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq20,FF),_mm_mul_pd(vftabscale,rinv20)));
1635
1636             fscal            = felec;
1637
1638             /* Update vectorial force */
1639             fix2             = _mm_macc_pd(dx20,fscal,fix2);
1640             fiy2             = _mm_macc_pd(dy20,fscal,fiy2);
1641             fiz2             = _mm_macc_pd(dz20,fscal,fiz2);
1642
1643             fjx0             = _mm_macc_pd(dx20,fscal,fjx0);
1644             fjy0             = _mm_macc_pd(dy20,fscal,fjy0);
1645             fjz0             = _mm_macc_pd(dz20,fscal,fjz0);
1646
1647             /**************************
1648              * CALCULATE INTERACTIONS *
1649              **************************/
1650
1651             r21              = _mm_mul_pd(rsq21,rinv21);
1652
1653             /* Calculate table index by multiplying r with table scale and truncate to integer */
1654             rt               = _mm_mul_pd(r21,vftabscale);
1655             vfitab           = _mm_cvttpd_epi32(rt);
1656 #ifdef __XOP__
1657             vfeps            = _mm_frcz_pd(rt);
1658 #else
1659             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1660 #endif
1661             twovfeps         = _mm_add_pd(vfeps,vfeps);
1662             vfitab           = _mm_slli_epi32(vfitab,2);
1663
1664             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1665             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1666             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1667             GMX_MM_TRANSPOSE2_PD(Y,F);
1668             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1669             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
1670             GMX_MM_TRANSPOSE2_PD(G,H);
1671             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1672             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1673             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq21,FF),_mm_mul_pd(vftabscale,rinv21)));
1674
1675             fscal            = felec;
1676
1677             /* Update vectorial force */
1678             fix2             = _mm_macc_pd(dx21,fscal,fix2);
1679             fiy2             = _mm_macc_pd(dy21,fscal,fiy2);
1680             fiz2             = _mm_macc_pd(dz21,fscal,fiz2);
1681
1682             fjx1             = _mm_macc_pd(dx21,fscal,fjx1);
1683             fjy1             = _mm_macc_pd(dy21,fscal,fjy1);
1684             fjz1             = _mm_macc_pd(dz21,fscal,fjz1);
1685
1686             /**************************
1687              * CALCULATE INTERACTIONS *
1688              **************************/
1689
1690             r22              = _mm_mul_pd(rsq22,rinv22);
1691
1692             /* Calculate table index by multiplying r with table scale and truncate to integer */
1693             rt               = _mm_mul_pd(r22,vftabscale);
1694             vfitab           = _mm_cvttpd_epi32(rt);
1695 #ifdef __XOP__
1696             vfeps            = _mm_frcz_pd(rt);
1697 #else
1698             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1699 #endif
1700             twovfeps         = _mm_add_pd(vfeps,vfeps);
1701             vfitab           = _mm_slli_epi32(vfitab,2);
1702
1703             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1704             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1705             F                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) );
1706             GMX_MM_TRANSPOSE2_PD(Y,F);
1707             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1708             H                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,1) +2);
1709             GMX_MM_TRANSPOSE2_PD(G,H);
1710             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1711             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1712             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq22,FF),_mm_mul_pd(vftabscale,rinv22)));
1713
1714             fscal            = felec;
1715
1716             /* Update vectorial force */
1717             fix2             = _mm_macc_pd(dx22,fscal,fix2);
1718             fiy2             = _mm_macc_pd(dy22,fscal,fiy2);
1719             fiz2             = _mm_macc_pd(dz22,fscal,fiz2);
1720
1721             fjx2             = _mm_macc_pd(dx22,fscal,fjx2);
1722             fjy2             = _mm_macc_pd(dy22,fscal,fjy2);
1723             fjz2             = _mm_macc_pd(dz22,fscal,fjz2);
1724
1725             gmx_mm_decrement_3rvec_2ptr_swizzle_pd(f+j_coord_offsetA,f+j_coord_offsetB,fjx0,fjy0,fjz0,fjx1,fjy1,fjz1,fjx2,fjy2,fjz2);
1726
1727             /* Inner loop uses 378 flops */
1728         }
1729
1730         if(jidx<j_index_end)
1731         {
1732
1733             jnrA             = jjnr[jidx];
1734             j_coord_offsetA  = DIM*jnrA;
1735
1736             /* load j atom coordinates */
1737             gmx_mm_load_3rvec_1ptr_swizzle_pd(x+j_coord_offsetA,
1738                                               &jx0,&jy0,&jz0,&jx1,&jy1,&jz1,&jx2,&jy2,&jz2);
1739
1740             /* Calculate displacement vector */
1741             dx00             = _mm_sub_pd(ix0,jx0);
1742             dy00             = _mm_sub_pd(iy0,jy0);
1743             dz00             = _mm_sub_pd(iz0,jz0);
1744             dx01             = _mm_sub_pd(ix0,jx1);
1745             dy01             = _mm_sub_pd(iy0,jy1);
1746             dz01             = _mm_sub_pd(iz0,jz1);
1747             dx02             = _mm_sub_pd(ix0,jx2);
1748             dy02             = _mm_sub_pd(iy0,jy2);
1749             dz02             = _mm_sub_pd(iz0,jz2);
1750             dx10             = _mm_sub_pd(ix1,jx0);
1751             dy10             = _mm_sub_pd(iy1,jy0);
1752             dz10             = _mm_sub_pd(iz1,jz0);
1753             dx11             = _mm_sub_pd(ix1,jx1);
1754             dy11             = _mm_sub_pd(iy1,jy1);
1755             dz11             = _mm_sub_pd(iz1,jz1);
1756             dx12             = _mm_sub_pd(ix1,jx2);
1757             dy12             = _mm_sub_pd(iy1,jy2);
1758             dz12             = _mm_sub_pd(iz1,jz2);
1759             dx20             = _mm_sub_pd(ix2,jx0);
1760             dy20             = _mm_sub_pd(iy2,jy0);
1761             dz20             = _mm_sub_pd(iz2,jz0);
1762             dx21             = _mm_sub_pd(ix2,jx1);
1763             dy21             = _mm_sub_pd(iy2,jy1);
1764             dz21             = _mm_sub_pd(iz2,jz1);
1765             dx22             = _mm_sub_pd(ix2,jx2);
1766             dy22             = _mm_sub_pd(iy2,jy2);
1767             dz22             = _mm_sub_pd(iz2,jz2);
1768
1769             /* Calculate squared distance and things based on it */
1770             rsq00            = gmx_mm_calc_rsq_pd(dx00,dy00,dz00);
1771             rsq01            = gmx_mm_calc_rsq_pd(dx01,dy01,dz01);
1772             rsq02            = gmx_mm_calc_rsq_pd(dx02,dy02,dz02);
1773             rsq10            = gmx_mm_calc_rsq_pd(dx10,dy10,dz10);
1774             rsq11            = gmx_mm_calc_rsq_pd(dx11,dy11,dz11);
1775             rsq12            = gmx_mm_calc_rsq_pd(dx12,dy12,dz12);
1776             rsq20            = gmx_mm_calc_rsq_pd(dx20,dy20,dz20);
1777             rsq21            = gmx_mm_calc_rsq_pd(dx21,dy21,dz21);
1778             rsq22            = gmx_mm_calc_rsq_pd(dx22,dy22,dz22);
1779
1780             rinv00           = gmx_mm_invsqrt_pd(rsq00);
1781             rinv01           = gmx_mm_invsqrt_pd(rsq01);
1782             rinv02           = gmx_mm_invsqrt_pd(rsq02);
1783             rinv10           = gmx_mm_invsqrt_pd(rsq10);
1784             rinv11           = gmx_mm_invsqrt_pd(rsq11);
1785             rinv12           = gmx_mm_invsqrt_pd(rsq12);
1786             rinv20           = gmx_mm_invsqrt_pd(rsq20);
1787             rinv21           = gmx_mm_invsqrt_pd(rsq21);
1788             rinv22           = gmx_mm_invsqrt_pd(rsq22);
1789
1790             fjx0             = _mm_setzero_pd();
1791             fjy0             = _mm_setzero_pd();
1792             fjz0             = _mm_setzero_pd();
1793             fjx1             = _mm_setzero_pd();
1794             fjy1             = _mm_setzero_pd();
1795             fjz1             = _mm_setzero_pd();
1796             fjx2             = _mm_setzero_pd();
1797             fjy2             = _mm_setzero_pd();
1798             fjz2             = _mm_setzero_pd();
1799
1800             /**************************
1801              * CALCULATE INTERACTIONS *
1802              **************************/
1803
1804             r00              = _mm_mul_pd(rsq00,rinv00);
1805
1806             /* Calculate table index by multiplying r with table scale and truncate to integer */
1807             rt               = _mm_mul_pd(r00,vftabscale);
1808             vfitab           = _mm_cvttpd_epi32(rt);
1809 #ifdef __XOP__
1810             vfeps            = _mm_frcz_pd(rt);
1811 #else
1812             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1813 #endif
1814             twovfeps         = _mm_add_pd(vfeps,vfeps);
1815             vfitab           = _mm_slli_epi32(vfitab,2);
1816
1817             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1818             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1819             F                = _mm_setzero_pd();
1820             GMX_MM_TRANSPOSE2_PD(Y,F);
1821             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1822             H                = _mm_setzero_pd();
1823             GMX_MM_TRANSPOSE2_PD(G,H);
1824             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1825             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1826             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq00,FF),_mm_mul_pd(vftabscale,rinv00)));
1827
1828             fscal            = felec;
1829
1830             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
1831
1832             /* Update vectorial force */
1833             fix0             = _mm_macc_pd(dx00,fscal,fix0);
1834             fiy0             = _mm_macc_pd(dy00,fscal,fiy0);
1835             fiz0             = _mm_macc_pd(dz00,fscal,fiz0);
1836
1837             fjx0             = _mm_macc_pd(dx00,fscal,fjx0);
1838             fjy0             = _mm_macc_pd(dy00,fscal,fjy0);
1839             fjz0             = _mm_macc_pd(dz00,fscal,fjz0);
1840
1841             /**************************
1842              * CALCULATE INTERACTIONS *
1843              **************************/
1844
1845             r01              = _mm_mul_pd(rsq01,rinv01);
1846
1847             /* Calculate table index by multiplying r with table scale and truncate to integer */
1848             rt               = _mm_mul_pd(r01,vftabscale);
1849             vfitab           = _mm_cvttpd_epi32(rt);
1850 #ifdef __XOP__
1851             vfeps            = _mm_frcz_pd(rt);
1852 #else
1853             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1854 #endif
1855             twovfeps         = _mm_add_pd(vfeps,vfeps);
1856             vfitab           = _mm_slli_epi32(vfitab,2);
1857
1858             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1859             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1860             F                = _mm_setzero_pd();
1861             GMX_MM_TRANSPOSE2_PD(Y,F);
1862             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1863             H                = _mm_setzero_pd();
1864             GMX_MM_TRANSPOSE2_PD(G,H);
1865             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1866             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1867             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq01,FF),_mm_mul_pd(vftabscale,rinv01)));
1868
1869             fscal            = felec;
1870
1871             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
1872
1873             /* Update vectorial force */
1874             fix0             = _mm_macc_pd(dx01,fscal,fix0);
1875             fiy0             = _mm_macc_pd(dy01,fscal,fiy0);
1876             fiz0             = _mm_macc_pd(dz01,fscal,fiz0);
1877
1878             fjx1             = _mm_macc_pd(dx01,fscal,fjx1);
1879             fjy1             = _mm_macc_pd(dy01,fscal,fjy1);
1880             fjz1             = _mm_macc_pd(dz01,fscal,fjz1);
1881
1882             /**************************
1883              * CALCULATE INTERACTIONS *
1884              **************************/
1885
1886             r02              = _mm_mul_pd(rsq02,rinv02);
1887
1888             /* Calculate table index by multiplying r with table scale and truncate to integer */
1889             rt               = _mm_mul_pd(r02,vftabscale);
1890             vfitab           = _mm_cvttpd_epi32(rt);
1891 #ifdef __XOP__
1892             vfeps            = _mm_frcz_pd(rt);
1893 #else
1894             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1895 #endif
1896             twovfeps         = _mm_add_pd(vfeps,vfeps);
1897             vfitab           = _mm_slli_epi32(vfitab,2);
1898
1899             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1900             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1901             F                = _mm_setzero_pd();
1902             GMX_MM_TRANSPOSE2_PD(Y,F);
1903             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1904             H                = _mm_setzero_pd();
1905             GMX_MM_TRANSPOSE2_PD(G,H);
1906             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1907             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1908             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq02,FF),_mm_mul_pd(vftabscale,rinv02)));
1909
1910             fscal            = felec;
1911
1912             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
1913
1914             /* Update vectorial force */
1915             fix0             = _mm_macc_pd(dx02,fscal,fix0);
1916             fiy0             = _mm_macc_pd(dy02,fscal,fiy0);
1917             fiz0             = _mm_macc_pd(dz02,fscal,fiz0);
1918
1919             fjx2             = _mm_macc_pd(dx02,fscal,fjx2);
1920             fjy2             = _mm_macc_pd(dy02,fscal,fjy2);
1921             fjz2             = _mm_macc_pd(dz02,fscal,fjz2);
1922
1923             /**************************
1924              * CALCULATE INTERACTIONS *
1925              **************************/
1926
1927             r10              = _mm_mul_pd(rsq10,rinv10);
1928
1929             /* Calculate table index by multiplying r with table scale and truncate to integer */
1930             rt               = _mm_mul_pd(r10,vftabscale);
1931             vfitab           = _mm_cvttpd_epi32(rt);
1932 #ifdef __XOP__
1933             vfeps            = _mm_frcz_pd(rt);
1934 #else
1935             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1936 #endif
1937             twovfeps         = _mm_add_pd(vfeps,vfeps);
1938             vfitab           = _mm_slli_epi32(vfitab,2);
1939
1940             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1941             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1942             F                = _mm_setzero_pd();
1943             GMX_MM_TRANSPOSE2_PD(Y,F);
1944             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1945             H                = _mm_setzero_pd();
1946             GMX_MM_TRANSPOSE2_PD(G,H);
1947             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1948             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1949             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq10,FF),_mm_mul_pd(vftabscale,rinv10)));
1950
1951             fscal            = felec;
1952
1953             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
1954
1955             /* Update vectorial force */
1956             fix1             = _mm_macc_pd(dx10,fscal,fix1);
1957             fiy1             = _mm_macc_pd(dy10,fscal,fiy1);
1958             fiz1             = _mm_macc_pd(dz10,fscal,fiz1);
1959
1960             fjx0             = _mm_macc_pd(dx10,fscal,fjx0);
1961             fjy0             = _mm_macc_pd(dy10,fscal,fjy0);
1962             fjz0             = _mm_macc_pd(dz10,fscal,fjz0);
1963
1964             /**************************
1965              * CALCULATE INTERACTIONS *
1966              **************************/
1967
1968             r11              = _mm_mul_pd(rsq11,rinv11);
1969
1970             /* Calculate table index by multiplying r with table scale and truncate to integer */
1971             rt               = _mm_mul_pd(r11,vftabscale);
1972             vfitab           = _mm_cvttpd_epi32(rt);
1973 #ifdef __XOP__
1974             vfeps            = _mm_frcz_pd(rt);
1975 #else
1976             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
1977 #endif
1978             twovfeps         = _mm_add_pd(vfeps,vfeps);
1979             vfitab           = _mm_slli_epi32(vfitab,2);
1980
1981             /* CUBIC SPLINE TABLE ELECTROSTATICS */
1982             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
1983             F                = _mm_setzero_pd();
1984             GMX_MM_TRANSPOSE2_PD(Y,F);
1985             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
1986             H                = _mm_setzero_pd();
1987             GMX_MM_TRANSPOSE2_PD(G,H);
1988             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
1989             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
1990             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq11,FF),_mm_mul_pd(vftabscale,rinv11)));
1991
1992             fscal            = felec;
1993
1994             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
1995
1996             /* Update vectorial force */
1997             fix1             = _mm_macc_pd(dx11,fscal,fix1);
1998             fiy1             = _mm_macc_pd(dy11,fscal,fiy1);
1999             fiz1             = _mm_macc_pd(dz11,fscal,fiz1);
2000
2001             fjx1             = _mm_macc_pd(dx11,fscal,fjx1);
2002             fjy1             = _mm_macc_pd(dy11,fscal,fjy1);
2003             fjz1             = _mm_macc_pd(dz11,fscal,fjz1);
2004
2005             /**************************
2006              * CALCULATE INTERACTIONS *
2007              **************************/
2008
2009             r12              = _mm_mul_pd(rsq12,rinv12);
2010
2011             /* Calculate table index by multiplying r with table scale and truncate to integer */
2012             rt               = _mm_mul_pd(r12,vftabscale);
2013             vfitab           = _mm_cvttpd_epi32(rt);
2014 #ifdef __XOP__
2015             vfeps            = _mm_frcz_pd(rt);
2016 #else
2017             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
2018 #endif
2019             twovfeps         = _mm_add_pd(vfeps,vfeps);
2020             vfitab           = _mm_slli_epi32(vfitab,2);
2021
2022             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2023             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2024             F                = _mm_setzero_pd();
2025             GMX_MM_TRANSPOSE2_PD(Y,F);
2026             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
2027             H                = _mm_setzero_pd();
2028             GMX_MM_TRANSPOSE2_PD(G,H);
2029             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
2030             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
2031             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq12,FF),_mm_mul_pd(vftabscale,rinv12)));
2032
2033             fscal            = felec;
2034
2035             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
2036
2037             /* Update vectorial force */
2038             fix1             = _mm_macc_pd(dx12,fscal,fix1);
2039             fiy1             = _mm_macc_pd(dy12,fscal,fiy1);
2040             fiz1             = _mm_macc_pd(dz12,fscal,fiz1);
2041
2042             fjx2             = _mm_macc_pd(dx12,fscal,fjx2);
2043             fjy2             = _mm_macc_pd(dy12,fscal,fjy2);
2044             fjz2             = _mm_macc_pd(dz12,fscal,fjz2);
2045
2046             /**************************
2047              * CALCULATE INTERACTIONS *
2048              **************************/
2049
2050             r20              = _mm_mul_pd(rsq20,rinv20);
2051
2052             /* Calculate table index by multiplying r with table scale and truncate to integer */
2053             rt               = _mm_mul_pd(r20,vftabscale);
2054             vfitab           = _mm_cvttpd_epi32(rt);
2055 #ifdef __XOP__
2056             vfeps            = _mm_frcz_pd(rt);
2057 #else
2058             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
2059 #endif
2060             twovfeps         = _mm_add_pd(vfeps,vfeps);
2061             vfitab           = _mm_slli_epi32(vfitab,2);
2062
2063             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2064             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2065             F                = _mm_setzero_pd();
2066             GMX_MM_TRANSPOSE2_PD(Y,F);
2067             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
2068             H                = _mm_setzero_pd();
2069             GMX_MM_TRANSPOSE2_PD(G,H);
2070             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
2071             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
2072             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq20,FF),_mm_mul_pd(vftabscale,rinv20)));
2073
2074             fscal            = felec;
2075
2076             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
2077
2078             /* Update vectorial force */
2079             fix2             = _mm_macc_pd(dx20,fscal,fix2);
2080             fiy2             = _mm_macc_pd(dy20,fscal,fiy2);
2081             fiz2             = _mm_macc_pd(dz20,fscal,fiz2);
2082
2083             fjx0             = _mm_macc_pd(dx20,fscal,fjx0);
2084             fjy0             = _mm_macc_pd(dy20,fscal,fjy0);
2085             fjz0             = _mm_macc_pd(dz20,fscal,fjz0);
2086
2087             /**************************
2088              * CALCULATE INTERACTIONS *
2089              **************************/
2090
2091             r21              = _mm_mul_pd(rsq21,rinv21);
2092
2093             /* Calculate table index by multiplying r with table scale and truncate to integer */
2094             rt               = _mm_mul_pd(r21,vftabscale);
2095             vfitab           = _mm_cvttpd_epi32(rt);
2096 #ifdef __XOP__
2097             vfeps            = _mm_frcz_pd(rt);
2098 #else
2099             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
2100 #endif
2101             twovfeps         = _mm_add_pd(vfeps,vfeps);
2102             vfitab           = _mm_slli_epi32(vfitab,2);
2103
2104             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2105             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2106             F                = _mm_setzero_pd();
2107             GMX_MM_TRANSPOSE2_PD(Y,F);
2108             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
2109             H                = _mm_setzero_pd();
2110             GMX_MM_TRANSPOSE2_PD(G,H);
2111             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
2112             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
2113             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq21,FF),_mm_mul_pd(vftabscale,rinv21)));
2114
2115             fscal            = felec;
2116
2117             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
2118
2119             /* Update vectorial force */
2120             fix2             = _mm_macc_pd(dx21,fscal,fix2);
2121             fiy2             = _mm_macc_pd(dy21,fscal,fiy2);
2122             fiz2             = _mm_macc_pd(dz21,fscal,fiz2);
2123
2124             fjx1             = _mm_macc_pd(dx21,fscal,fjx1);
2125             fjy1             = _mm_macc_pd(dy21,fscal,fjy1);
2126             fjz1             = _mm_macc_pd(dz21,fscal,fjz1);
2127
2128             /**************************
2129              * CALCULATE INTERACTIONS *
2130              **************************/
2131
2132             r22              = _mm_mul_pd(rsq22,rinv22);
2133
2134             /* Calculate table index by multiplying r with table scale and truncate to integer */
2135             rt               = _mm_mul_pd(r22,vftabscale);
2136             vfitab           = _mm_cvttpd_epi32(rt);
2137 #ifdef __XOP__
2138             vfeps            = _mm_frcz_pd(rt);
2139 #else
2140             vfeps            = _mm_sub_pd(rt,_mm_round_pd(rt, _MM_FROUND_FLOOR));
2141 #endif
2142             twovfeps         = _mm_add_pd(vfeps,vfeps);
2143             vfitab           = _mm_slli_epi32(vfitab,2);
2144
2145             /* CUBIC SPLINE TABLE ELECTROSTATICS */
2146             Y                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) );
2147             F                = _mm_setzero_pd();
2148             GMX_MM_TRANSPOSE2_PD(Y,F);
2149             G                = _mm_load_pd( vftab + _mm_extract_epi32(vfitab,0) +2);
2150             H                = _mm_setzero_pd();
2151             GMX_MM_TRANSPOSE2_PD(G,H);
2152             Fp               = _mm_macc_pd(vfeps,_mm_macc_pd(vfeps,H,G),F);
2153             FF               = _mm_macc_pd(_mm_macc_pd(twovfeps,H,G),vfeps,Fp);
2154             felec            = _mm_xor_pd(signbit,_mm_mul_pd(_mm_mul_pd(qq22,FF),_mm_mul_pd(vftabscale,rinv22)));
2155
2156             fscal            = felec;
2157
2158             fscal            = _mm_unpacklo_pd(fscal,_mm_setzero_pd());
2159
2160             /* Update vectorial force */
2161             fix2             = _mm_macc_pd(dx22,fscal,fix2);
2162             fiy2             = _mm_macc_pd(dy22,fscal,fiy2);
2163             fiz2             = _mm_macc_pd(dz22,fscal,fiz2);
2164
2165             fjx2             = _mm_macc_pd(dx22,fscal,fjx2);
2166             fjy2             = _mm_macc_pd(dy22,fscal,fjy2);
2167             fjz2             = _mm_macc_pd(dz22,fscal,fjz2);
2168
2169             gmx_mm_decrement_3rvec_1ptr_swizzle_pd(f+j_coord_offsetA,fjx0,fjy0,fjz0,fjx1,fjy1,fjz1,fjx2,fjy2,fjz2);
2170
2171             /* Inner loop uses 378 flops */
2172         }
2173
2174         /* End of innermost loop */
2175
2176         gmx_mm_update_iforce_3atom_swizzle_pd(fix0,fiy0,fiz0,fix1,fiy1,fiz1,fix2,fiy2,fiz2,
2177                                               f+i_coord_offset,fshift+i_shift_offset);
2178
2179         /* Increment number of inner iterations */
2180         inneriter                  += j_index_end - j_index_start;
2181
2182         /* Outer loop uses 18 flops */
2183     }
2184
2185     /* Increment number of outer iterations */
2186     outeriter        += nri;
2187
2188     /* Update outer/inner flops */
2189
2190     inc_nrnb(nrnb,eNR_NBKERNEL_ELEC_W3W3_F,outeriter*18 + inneriter*378);
2191 }