src/gromacs/gmxlib/nonbonded/nb_kernel_avx_128_fma_double/nb_kernel_ElecCSTab_VdwLJ_GeomW3W3_avx_128_fma_double.cpp

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