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

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