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

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