include/gmx_x86_avx_128_fma.h

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2012, by the GROMACS development team, led by
   5  * David van der Spoel, Berk Hess, Erik Lindahl, and including many
   6  * others, as listed in the AUTHORS file in the top-level source
   7  * directory and at http://www.gromacs.org.
   8  *
   9  * GROMACS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 2.1
  12  * of the License, or (at your option) any later version.
  13  *
  14  * GROMACS is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with GROMACS; if not, see
  21  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  23  *
  24  * If you want to redistribute modifications to GROMACS, please
  25  * consider that scientific software is very special. Version
  26  * control is crucial - bugs must be traceable. We will be happy to
  27  * consider code for inclusion in the official distribution, but
  28  * derived work must not be called official GROMACS. Details are found
  29  * in the README & COPYING files - if they are missing, get the
  30  * official version at http://www.gromacs.org.
  31  *
  32  * To help us fund GROMACS development, we humbly ask that you cite
  33  * the research papers on the package. Check out http://www.gromacs.org.
  34  */
  35 #ifndef _gmx_x86_avx_128_fma_h_
  36 #define _gmx_x86_avx_128_fma_h_
  37
  38
  39 #include <immintrin.h>
  40 #ifdef HAVE_X86INTRIN_H
  41 #include <x86intrin.h> /* FMA */
  42 #endif
  43
  44 #include <stdio.h>
  45
  46 #include "types/simple.h"
  47
  48
  49 #define gmx_mm_extract_epi32(x, imm) _mm_cvtsi128_si32(_mm_srli_si128((x), 4 * (imm)))
  50
  51 #define _GMX_MM_BLEND(b3,b2,b1,b0) (((b3) << 3) | ((b2) << 2) | ((b1) << 1) | ((b0)))
  52
  53 #define _GMX_MM_PERMUTE128D(fp1,fp0)         (((fp1) << 1) | ((fp0)))
  54
  55
  56 #define GMX_MM_TRANSPOSE2_PD(row0, row1) {           \
  57     __m128d __gmx_t1 = row0;                         \
  58     row0           = _mm_unpacklo_pd(row0,row1);     \
  59     row1           = _mm_unpackhi_pd(__gmx_t1,row1); \
  60 }
  61
  62
  63 #if (defined (_MSC_VER) || defined(__INTEL_COMPILER))
  64 #  define gmx_mm_castsi128_ps(a) _mm_castsi128_ps(a)
  65 #  define gmx_mm_castps_si128(a) _mm_castps_si128(a)
  66 #  define gmx_mm_castps_ps128(a) (a)
  67 #  define gmx_mm_castsi128_pd(a) _mm_castsi128_pd(a)
  68 #  define gmx_mm_castpd_si128(a) _mm_castpd_si128(a)
  69 #elif defined(__GNUC__)
  70 #  define gmx_mm_castsi128_ps(a) ((__m128)(a))
  71 #  define gmx_mm_castps_si128(a) ((__m128i)(a))
  72 #  define gmx_mm_castps_ps128(a) ((__m128)(a))
  73 #  define gmx_mm_castsi128_pd(a) ((__m128d)(a))
  74 #  define gmx_mm_castpd_si128(a) ((__m128i)(a))
  75 #else
  76 static __m128  gmx_mm_castsi128_ps(__m128i a)
  77 {
  78     return *(__m128 *) &a;
  79 }
  80 static __m128i gmx_mm_castps_si128(__m128 a)
  81 {
  82     return *(__m128i *) &a;
  83 }
  84 static __m128  gmx_mm_castps_ps128(__m128 a)
  85 {
  86     return *(__m128 *) &a;
  87 }
  88 static __m128d gmx_mm_castsi128_pd(__m128i a)
  89 {
  90     return *(__m128d *) &a;
  91 }
  92 static __m128i gmx_mm_castpd_si128(__m128d a)
  93 {
  94     return *(__m128i *) &a;
  95 }
  96 #endif
  97
  98 #if GMX_EMULATE_AMD_FMA
  99 /* Wrapper routines so we can do test builds on non-FMA or non-AMD hardware */
 100 static __m128
 101 _mm_macc_ps(__m128 a, __m128 b, __m128 c)
 102 {
 103     return _mm_add_ps(c,_mm_mul_ps(a,b));
 104 }
 105
 106 static __m128
 107 _mm_nmacc_ps(__m128 a, __m128 b, __m128 c)
 108 {
 109     return _mm_sub_ps(c,_mm_mul_ps(a,b));
 110 }
 111
 112 static __m128
 113 _mm_msub_ps(__m128 a, __m128 b, __m128 c)
 114 {
 115     return _mm_sub_ps(_mm_mul_ps(a,b),c);
 116 }
 117
 118 static __m128d
 119 _mm_macc_pd(__m128d a, __m128d b, __m128d c)
 120 {
 121     return _mm_add_pd(c,_mm_mul_pd(a,b));
 122 }
 123
 124 static __m128d
 125 _mm_nmacc_pd(__m128d a, __m128d b, __m128d c)
 126 {
 127     return _mm_sub_pd(c,_mm_mul_pd(a,b));
 128 }
 129
 130 static __m128d
 131 _mm_msub_pd(__m128d a, __m128d b, __m128d c)
 132 {
 133     return _mm_sub_pd(_mm_mul_pd(a,b),c);
 134 }
 135 #endif /* AMD FMA emulation support */
 136
 137 static void
 138 gmx_mm_printxmm_ps(const char *s,__m128 xmm)
 139 {
 140     float f[4];
 141
 142     _mm_storeu_ps(f,xmm);
 143     printf("%s: %15.10e %15.10e %15.10e %15.10e\n",s,f[0],f[1],f[2],f[3]);
 144 }
 145
 146
 147 static void
 148 gmx_mm_printxmmsum_ps(const char *s,__m128 xmm)
 149 {
 150     float f[4];
 151
 152     _mm_storeu_ps(f,xmm);
 153     printf("%s (sum): %15.10g\n",s,f[0]+f[1]+f[2]+f[3]);
 154 }
 155
 156
 157 static void
 158 gmx_mm_printxmm_pd(const char *s,__m128d xmm)
 159 {
 160     double f[2];
 161
 162     _mm_storeu_pd(f,xmm);
 163     printf("%s: %30.20e %30.20e\n",s,f[0],f[1]);
 164 }
 165
 166 static void
 167 gmx_mm_printxmmsum_pd(const char *s,__m128d xmm)
 168 {
 169     double f[2];
 170
 171     _mm_storeu_pd(f,xmm);
 172     printf("%s (sum): %15.10g\n",s,f[0]+f[1]);
 173 }
 174
 175
 176 static void
 177 gmx_mm_printxmm_epi32(const char *s,__m128i xmmi)
 178 {
 179     int i[4];
 180
 181     _mm_storeu_si128((__m128i *)i,xmmi);
 182     printf("%10s: %2d %2d %2d %2d\n",s,i[0],i[1],i[2],i[3]);
 183 }
 184
 185
 186
 187 static int gmx_mm_check_and_reset_overflow(void)
 188 {
 189     int MXCSR;
 190     int sse_overflow;
 191
 192     MXCSR = _mm_getcsr();
 193     /* The overflow flag is bit 3 in the register */
 194     if (MXCSR & 0x0008)
 195     {
 196         sse_overflow = 1;
 197         /* Set the overflow flag to zero */
 198         MXCSR = MXCSR & 0xFFF7;
 199         _mm_setcsr(MXCSR);
 200     }
 201     else
 202     {
 203         sse_overflow = 0;
 204     }
 205
 206     return sse_overflow;
 207 }
 208
 209
 210
 211 #endif /* _gmx_x86_avx_128_fma_h_ */