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>
58 #include "gromacs/simd/simd.h"
64 /*! \addtogroup module_simd */
67 TEST(SimdBootstrapTest, gmxSimdAlign)
69 #ifdef GMX_SIMD_HAVE_REAL
70 real rdata[GMX_SIMD_REAL_WIDTH*2];
71 for (int i = 0; i < GMX_SIMD_REAL_WIDTH; i++)
73 EXPECT_EQ(((size_t)gmx_simd_align_r(&rdata[i]) & (GMX_SIMD_REAL_WIDTH*sizeof(real)-1)), (size_t)0);
76 #ifdef GMX_SIMD_HAVE_INT32
77 int idata[GMX_SIMD_INT32_WIDTH*2];
78 for (int i = 0; i < GMX_SIMD_INT32_WIDTH; i++)
80 EXPECT_EQ(((size_t)gmx_simd_align_i(&idata[i]) & (GMX_SIMD_INT32_WIDTH*sizeof(int)-1)), (size_t)0);
85 /*! \brief Generic routine to test load & store of SIMD, and check for side effects.
87 * The tests for load, store, unaligned load and unaligned store both for
88 * real and int are pretty much similar, so we use a template function with
89 * additional function pointers for the actual load/store calls. This would
90 * be more hacking to turn into a class, since the SIMD functionality uses
91 * macros rather than functions that can be overloaded.
93 template <typename T, typename TSimd> void
94 simdLoadStoreTester(TSimd simdLoadFn(T* mem), void simdStoreFn(T* mem, TSimd),
95 T * simdAlignFn(T *mem),
96 const int loadOffset, const int storeOffset, const int simdWidth)
98 /* We want simdWidth elements before the data to check we are not polluting
99 * memory. Then we need 2*simdWidth storage to be able to extract an aligned
100 * pointer, another simdWidth elements so we can create (deliberately)
101 * offset un-aligned pointers, and finally simdWidth elements at the end
102 * to test we are not polluting memory there either. Sum=5*simdWidth!
104 std::vector<T> src(simdWidth*5);
105 std::vector<T> dst(simdWidth*5);
106 // Make sure we have memory to check both before and after the test pointers
107 T * pCopySrc = simdAlignFn(&src[0]) + simdWidth + loadOffset;
108 T * pCopyDst = simdAlignFn(&dst[0]) + simdWidth + storeOffset;
111 for (i = 0; i < simdWidth*5; i++)
117 simdStoreFn(pCopyDst, simdLoadFn(pCopySrc));
119 for (i = 0; i < simdWidth; i++)
121 EXPECT_EQ(pCopySrc[i], pCopyDst[i]) << "SIMD load or store not moving data correctly for element " << i;
124 for (i = 0; i < simdWidth*5; i++)
126 EXPECT_EQ(src[i], (T)(1+i)) << "Side effect on source memory, i = " << i;
127 if (&dst[0]+i < pCopyDst || &dst[0]+i >= pCopyDst+simdWidth)
129 EXPECT_EQ(dst[i], (T)(-1-i)) << "Side effect on destination memory, i = " << i;
134 #ifdef GMX_SIMD_HAVE_REAL
135 //! Wrapper for SIMD macro to load aligned floating-point data.
136 gmx_simd_real_t wrapperSimdLoadR(real *m)
138 return gmx_simd_load_r(m);
140 //! Wrapper for SIMD macro to store to aligned floating-point data.
141 void wrapperSimdStoreR(real *m, gmx_simd_real_t s)
143 gmx_simd_store_r(m, s);
146 TEST(SimdBootstrapTest, gmxSimdLoadStoreR)
148 simdLoadStoreTester(wrapperSimdLoadR, wrapperSimdStoreR, gmx_simd_align_r, 0, 0, GMX_SIMD_REAL_WIDTH);
151 # ifdef GMX_SIMD_HAVE_LOADU
152 //! Wrapper for SIMD macro to load unaligned floating-point data.
153 gmx_simd_real_t WrapperSimdLoadUR(real *m)
155 return gmx_simd_loadu_r(m);
158 TEST(SimdBootstrapTest, gmxSimdLoadUR)
160 for (int i = 0; i < GMX_SIMD_REAL_WIDTH; i++)
162 simdLoadStoreTester(WrapperSimdLoadUR, wrapperSimdStoreR, gmx_simd_align_r, i, 0, GMX_SIMD_REAL_WIDTH);
167 # ifdef GMX_SIMD_HAVE_STOREU
168 //! Wrapper for SIMD macro to store to unaligned floating-point data.
169 void WrapperSimdStoreUR(real *m, gmx_simd_real_t s)
171 gmx_simd_storeu_r(m, s);
174 TEST(SimdBootstrapTest, gmxSimdStoreUR)
176 for (int i = 0; i < GMX_SIMD_REAL_WIDTH; i++)
178 simdLoadStoreTester(wrapperSimdLoadR, WrapperSimdStoreUR, gmx_simd_align_r, 0, i, GMX_SIMD_REAL_WIDTH);
184 #ifdef GMX_SIMD_HAVE_INT32
185 // Tests for gmx_simd_int32_t load & store operations
187 //! Wrapper for SIMD macro to load aligned integer data.
188 gmx_simd_int32_t wrapperSimdLoadI(int *m)
190 return gmx_simd_load_i(m);
192 //! Wrapper for SIMD macro to store to aligned integer data.
193 void wrapperSimdStoreI(int *m, gmx_simd_int32_t s)
195 gmx_simd_store_i(m, s);
198 TEST(SimdBootstrapTest, gmxSimdLoadStoreI)
200 simdLoadStoreTester(wrapperSimdLoadI, wrapperSimdStoreI, gmx_simd_align_i, 0, 0, GMX_SIMD_INT32_WIDTH);
203 # ifdef GMX_SIMD_HAVE_LOADU
204 //! Wrapper for SIMD macro to load unaligned integer data.
205 gmx_simd_int32_t wrapperSimdLoadUI(int *m)
207 return gmx_simd_loadu_i(m);
210 TEST(SimdBootstrapTest, gmxSimdLoadUI)
212 for (int i = 0; i < GMX_SIMD_INT32_WIDTH; i++)
214 simdLoadStoreTester(wrapperSimdLoadUI, wrapperSimdStoreI, gmx_simd_align_i, i, 0, GMX_SIMD_INT32_WIDTH);
219 # ifdef GMX_SIMD_HAVE_STOREU
220 //! Wrapper for SIMD macro to store to unaligned integer data.
221 void wrapperSimdStoreUI(int *m, gmx_simd_int32_t s)
223 gmx_simd_storeu_i(m, s);
226 TEST(SimdBootstrapTest, gmxSimdStoreUI)
228 for (int i = 0; i < GMX_SIMD_INT32_WIDTH; i++)
230 simdLoadStoreTester(wrapperSimdLoadI, wrapperSimdStoreUI, gmx_simd_align_i, 0, i, GMX_SIMD_INT32_WIDTH);
236 #ifdef GMX_SIMD4_HAVE_REAL
237 /* Tests for gmx_simd4_real_t load & store operations. Define wrapper functions
238 * for the SIMD instructions that are typically implemented as macros.
241 /*! \brief Separate load/store tester function for SIMD4.
243 * Due to the way SIMD variables
244 * are implemented as deep internal data, some compilers treat them as
245 * float/double with special prefixes. Unfortunately, this means that some C++
246 * compilers think an 8-wide normal real SIMD and a 4-wide SIMD4 real type
247 * cannot be overloaded (e.g. with gcc using 256-bit AVX single precision).
249 template <typename T, typename TSimd> void
250 simd4LoadStoreTester(TSimd simd4LoadFn(T* mem), void simd4StoreFn(T* mem, TSimd),
251 T * simd4AlignFn(T *mem),
252 const int loadOffset, const int storeOffset)
254 /* We want simdWidth elements before the data to check we are not polluting
255 * memory. Then we need 2*simdWidth storage to be able to extract an aligned
256 * pointer, another simdWidth elements so we can create (deliberately)
257 * offset un-aligned pointers, and finally simdWidth elements at the end
258 * to test we are not polluting memory there either. Sum=5*simdWidth!
260 T src[GMX_SIMD4_WIDTH*5];
261 T dst[GMX_SIMD4_WIDTH*5];
262 // Make sure we have memory to check both before and after the test pointers
263 T * pCopySrc = simd4AlignFn(src) + GMX_SIMD4_WIDTH + loadOffset;
264 T * pCopyDst = simd4AlignFn(dst) + GMX_SIMD4_WIDTH + storeOffset;
267 for (i = 0; i < GMX_SIMD4_WIDTH*5; i++)
273 simd4StoreFn(pCopyDst, simd4LoadFn(pCopySrc));
275 for (i = 0; i < GMX_SIMD4_WIDTH; i++)
277 EXPECT_EQ(pCopySrc[i], pCopyDst[i]) << "SIMD4 load or store not moving data correctly for element " << i;
280 for (i = 0; i < GMX_SIMD4_WIDTH*5; i++)
282 EXPECT_EQ(src[i], (T)(1+i)) << "Side effect on source memory, i = " << i;
283 if (dst+i < pCopyDst || dst+i >= pCopyDst+GMX_SIMD4_WIDTH)
285 EXPECT_EQ(dst[i], (T)(-1-i)) << "Side effect on destination memory, i = " << i;
290 //! Wrapper for SIMD4 macro to load aligned floating-point data.
291 gmx_simd4_real_t wrapperSimd4LoadR(real *m)
293 return gmx_simd4_load_r(m);
295 //! Wrapper for SIMD4 macro to store to aligned floating-point data.
296 void wrapperSimd4StoreR(real *m, gmx_simd4_real_t s)
298 gmx_simd4_store_r(m, s);
301 TEST(SimdBootstrapTest, gmxSimd4LoadStoreR)
303 simd4LoadStoreTester(wrapperSimd4LoadR, wrapperSimd4StoreR, gmx_simd4_align_r, 0, 0);
306 # ifdef GMX_SIMD_HAVE_LOADU
307 //! Wrapper for SIMD4 macro to load unaligned floating-point data.
308 gmx_simd4_real_t WrapperSimd4LoadUR(real *m)
310 return gmx_simd4_loadu_r(m);
313 TEST(SimdBootstrapTest, gmxSimd4LoadUR)
315 for (int i = 0; i < GMX_SIMD4_WIDTH; i++)
317 simd4LoadStoreTester(WrapperSimd4LoadUR, wrapperSimd4StoreR, gmx_simd4_align_r, i, 0);
322 # ifdef GMX_SIMD_HAVE_STOREU
323 //! Wrapper for SIMD4 macro to store to unaligned floating-point data.
324 void WrapperSimd4StoreUR(real *m, gmx_simd4_real_t s)
326 gmx_simd4_storeu_r(m, s);
329 TEST(SimdBootstrapTest, gmxSimd4StoreUR)
331 for (int i = 0; i < GMX_SIMD4_WIDTH; i++)
333 simd4LoadStoreTester(wrapperSimd4LoadR, WrapperSimd4StoreUR, gmx_simd4_align_r, 0, i);