2 * This file is part of the GROMACS molecular simulation package.
4 * Copyright (c) 2014, by the GROMACS development team, led by
5 * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
6 * and including many others, as listed in the AUTHORS file in the
7 * top-level source directory and at http://www.gromacs.org.
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.
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.
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.
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.
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.
41 * Separate test of SIMD load/store, before we use them in the SIMD test classes.
43 * Simple tests without using any classes/utilities, so we can use load/store
44 * functions inside our test utilities after this has passed.
48 * - gmx_simd_align_r(),gmx_simd_align_i(),gmx_simd4_align_r(),
49 * - gmx_simd_load_r(),gmx_simd_store_r(),gmx_simd_loadu_r(),gmx_simd_storeu_r()
50 * - gmx_simd_load_i(),gmx_simd_store_i(), gmx_simd_loadu_i(),gmx_simd_storeu_i()
51 * - gmx_simd4_load_r(),gmx_simd4_store_r(), gmx_simd4_loadu_r(),gmx_simd4_storeu_r()
53 * \author Erik Lindahl <erik.lindahl@scilifelab.se>
54 * \ingroup module_simd
57 #include <gtest/gtest.h>
59 #include "gromacs/simd/simd.h"
60 #include "gromacs/utility/real.h"
66 /*! \addtogroup module_simd */
69 TEST(SimdBootstrapTest, gmxSimdAlign)
71 #ifdef GMX_SIMD_HAVE_REAL
72 real rdata[GMX_SIMD_REAL_WIDTH*2];
73 for (int i = 0; i < GMX_SIMD_REAL_WIDTH; i++)
75 EXPECT_EQ(((size_t)gmx_simd_align_r(&rdata[i]) & (GMX_SIMD_REAL_WIDTH*sizeof(real)-1)), (size_t)0);
78 #ifdef GMX_SIMD_HAVE_INT32
79 int idata[GMX_SIMD_INT32_WIDTH*2];
80 for (int i = 0; i < GMX_SIMD_INT32_WIDTH; i++)
82 EXPECT_EQ(((size_t)gmx_simd_align_i(&idata[i]) & (GMX_SIMD_INT32_WIDTH*sizeof(int)-1)), (size_t)0);
87 /*! \brief Generic routine to test load & store of SIMD, and check for side effects.
89 * The tests for load, store, unaligned load and unaligned store both for
90 * real and int are pretty much similar, so we use a template function with
91 * additional function pointers for the actual load/store calls. This would
92 * be more hacking to turn into a class, since the SIMD functionality uses
93 * macros rather than functions that can be overloaded.
95 template <typename T, typename TSimd> void
96 simdLoadStoreTester(TSimd simdLoadFn(T* mem), void simdStoreFn(T* mem, TSimd),
97 T * simdAlignFn(T *mem),
98 const int loadOffset, const int storeOffset, const int simdWidth)
100 /* We want simdWidth elements before the data to check we are not polluting
101 * memory. Then we need 2*simdWidth storage to be able to extract an aligned
102 * pointer, another simdWidth elements so we can create (deliberately)
103 * offset un-aligned pointers, and finally simdWidth elements at the end
104 * to test we are not polluting memory there either. Sum=5*simdWidth!
106 std::vector<T> src(simdWidth*5);
107 std::vector<T> dst(simdWidth*5);
108 // Make sure we have memory to check both before and after the test pointers
109 T * pCopySrc = simdAlignFn(&src[0]) + simdWidth + loadOffset;
110 T * pCopyDst = simdAlignFn(&dst[0]) + simdWidth + storeOffset;
113 for (i = 0; i < simdWidth*5; i++)
119 simdStoreFn(pCopyDst, simdLoadFn(pCopySrc));
121 for (i = 0; i < simdWidth; i++)
123 EXPECT_EQ(pCopySrc[i], pCopyDst[i]) << "SIMD load or store not moving data correctly for element " << i;
126 for (i = 0; i < simdWidth*5; i++)
128 EXPECT_EQ(src[i], (T)(1+i)) << "Side effect on source memory, i = " << i;
129 if (&dst[0]+i < pCopyDst || &dst[0]+i >= pCopyDst+simdWidth)
131 EXPECT_EQ(dst[i], (T)(-1-i)) << "Side effect on destination memory, i = " << i;
136 #ifdef GMX_SIMD_HAVE_REAL
137 //! Wrapper for SIMD macro to load aligned floating-point data.
138 gmx_simd_real_t wrapperSimdLoadR(real *m)
140 return gmx_simd_load_r(m);
142 //! Wrapper for SIMD macro to store to aligned floating-point data.
143 void wrapperSimdStoreR(real *m, gmx_simd_real_t s)
145 gmx_simd_store_r(m, s);
148 TEST(SimdBootstrapTest, gmxSimdLoadStoreR)
150 simdLoadStoreTester(wrapperSimdLoadR, wrapperSimdStoreR, gmx_simd_align_r, 0, 0, GMX_SIMD_REAL_WIDTH);
153 # ifdef GMX_SIMD_HAVE_LOADU
154 //! Wrapper for SIMD macro to load unaligned floating-point data.
155 gmx_simd_real_t WrapperSimdLoadUR(real *m)
157 return gmx_simd_loadu_r(m);
160 TEST(SimdBootstrapTest, gmxSimdLoadUR)
162 for (int i = 0; i < GMX_SIMD_REAL_WIDTH; i++)
164 simdLoadStoreTester(WrapperSimdLoadUR, wrapperSimdStoreR, gmx_simd_align_r, i, 0, GMX_SIMD_REAL_WIDTH);
169 # ifdef GMX_SIMD_HAVE_STOREU
170 //! Wrapper for SIMD macro to store to unaligned floating-point data.
171 void WrapperSimdStoreUR(real *m, gmx_simd_real_t s)
173 gmx_simd_storeu_r(m, s);
176 TEST(SimdBootstrapTest, gmxSimdStoreUR)
178 for (int i = 0; i < GMX_SIMD_REAL_WIDTH; i++)
180 simdLoadStoreTester(wrapperSimdLoadR, WrapperSimdStoreUR, gmx_simd_align_r, 0, i, GMX_SIMD_REAL_WIDTH);
186 #ifdef GMX_SIMD_HAVE_INT32
187 // Tests for gmx_simd_int32_t load & store operations
189 //! Wrapper for SIMD macro to load aligned integer data.
190 gmx_simd_int32_t wrapperSimdLoadI(int *m)
192 return gmx_simd_load_i(m);
194 //! Wrapper for SIMD macro to store to aligned integer data.
195 void wrapperSimdStoreI(int *m, gmx_simd_int32_t s)
197 gmx_simd_store_i(m, s);
200 TEST(SimdBootstrapTest, gmxSimdLoadStoreI)
202 simdLoadStoreTester(wrapperSimdLoadI, wrapperSimdStoreI, gmx_simd_align_i, 0, 0, GMX_SIMD_INT32_WIDTH);
205 # ifdef GMX_SIMD_HAVE_LOADU
206 //! Wrapper for SIMD macro to load unaligned integer data.
207 gmx_simd_int32_t wrapperSimdLoadUI(int *m)
209 return gmx_simd_loadu_i(m);
212 TEST(SimdBootstrapTest, gmxSimdLoadUI)
214 for (int i = 0; i < GMX_SIMD_INT32_WIDTH; i++)
216 simdLoadStoreTester(wrapperSimdLoadUI, wrapperSimdStoreI, gmx_simd_align_i, i, 0, GMX_SIMD_INT32_WIDTH);
221 # ifdef GMX_SIMD_HAVE_STOREU
222 //! Wrapper for SIMD macro to store to unaligned integer data.
223 void wrapperSimdStoreUI(int *m, gmx_simd_int32_t s)
225 gmx_simd_storeu_i(m, s);
228 TEST(SimdBootstrapTest, gmxSimdStoreUI)
230 for (int i = 0; i < GMX_SIMD_INT32_WIDTH; i++)
232 simdLoadStoreTester(wrapperSimdLoadI, wrapperSimdStoreUI, gmx_simd_align_i, 0, i, GMX_SIMD_INT32_WIDTH);
238 #ifdef GMX_SIMD4_HAVE_REAL
239 /* Tests for gmx_simd4_real_t load & store operations. Define wrapper functions
240 * for the SIMD instructions that are typically implemented as macros.
243 /*! \brief Separate load/store tester function for SIMD4.
245 * Due to the way SIMD variables
246 * are implemented as deep internal data, some compilers treat them as
247 * float/double with special prefixes. Unfortunately, this means that some C++
248 * compilers think an 8-wide normal real SIMD and a 4-wide SIMD4 real type
249 * cannot be overloaded (e.g. with gcc using 256-bit AVX single precision).
251 template <typename T, typename TSimd> void
252 simd4LoadStoreTester(TSimd simd4LoadFn(T* mem), void simd4StoreFn(T* mem, TSimd),
253 T * simd4AlignFn(T *mem),
254 const int loadOffset, const int storeOffset)
256 /* We want simdWidth elements before the data to check we are not polluting
257 * memory. Then we need 2*simdWidth storage to be able to extract an aligned
258 * pointer, another simdWidth elements so we can create (deliberately)
259 * offset un-aligned pointers, and finally simdWidth elements at the end
260 * to test we are not polluting memory there either. Sum=5*simdWidth!
262 T src[GMX_SIMD4_WIDTH*5];
263 T dst[GMX_SIMD4_WIDTH*5];
264 // Make sure we have memory to check both before and after the test pointers
265 T * pCopySrc = simd4AlignFn(src) + GMX_SIMD4_WIDTH + loadOffset;
266 T * pCopyDst = simd4AlignFn(dst) + GMX_SIMD4_WIDTH + storeOffset;
269 for (i = 0; i < GMX_SIMD4_WIDTH*5; i++)
275 simd4StoreFn(pCopyDst, simd4LoadFn(pCopySrc));
277 for (i = 0; i < GMX_SIMD4_WIDTH; i++)
279 EXPECT_EQ(pCopySrc[i], pCopyDst[i]) << "SIMD4 load or store not moving data correctly for element " << i;
282 for (i = 0; i < GMX_SIMD4_WIDTH*5; i++)
284 EXPECT_EQ(src[i], (T)(1+i)) << "Side effect on source memory, i = " << i;
285 if (dst+i < pCopyDst || dst+i >= pCopyDst+GMX_SIMD4_WIDTH)
287 EXPECT_EQ(dst[i], (T)(-1-i)) << "Side effect on destination memory, i = " << i;
292 //! Wrapper for SIMD4 macro to load aligned floating-point data.
293 gmx_simd4_real_t wrapperSimd4LoadR(real *m)
295 return gmx_simd4_load_r(m);
297 //! Wrapper for SIMD4 macro to store to aligned floating-point data.
298 void wrapperSimd4StoreR(real *m, gmx_simd4_real_t s)
300 gmx_simd4_store_r(m, s);
303 TEST(SimdBootstrapTest, gmxSimd4LoadStoreR)
305 simd4LoadStoreTester(wrapperSimd4LoadR, wrapperSimd4StoreR, gmx_simd4_align_r, 0, 0);
308 # ifdef GMX_SIMD_HAVE_LOADU
309 //! Wrapper for SIMD4 macro to load unaligned floating-point data.
310 gmx_simd4_real_t WrapperSimd4LoadUR(real *m)
312 return gmx_simd4_loadu_r(m);
315 TEST(SimdBootstrapTest, gmxSimd4LoadUR)
317 for (int i = 0; i < GMX_SIMD4_WIDTH; i++)
319 simd4LoadStoreTester(WrapperSimd4LoadUR, wrapperSimd4StoreR, gmx_simd4_align_r, i, 0);
324 # ifdef GMX_SIMD_HAVE_STOREU
325 //! Wrapper for SIMD4 macro to store to unaligned floating-point data.
326 void WrapperSimd4StoreUR(real *m, gmx_simd4_real_t s)
328 gmx_simd4_storeu_r(m, s);
331 TEST(SimdBootstrapTest, gmxSimd4StoreUR)
333 for (int i = 0; i < GMX_SIMD4_WIDTH; i++)
335 simd4LoadStoreTester(wrapperSimd4LoadR, WrapperSimd4StoreUR, gmx_simd4_align_r, 0, i);