src/gromacs/simd/tests/bootstrap_loadstore.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   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.
   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 #include "gmxpre.h"
  36
  37 /*! \internal \file
  38  * \brief
  39  * Separate test of SIMD load/store, before we use them in the SIMD test classes.
  40  *
  41  * Simple tests without using any classes/utilities, so we can use load/store
  42  * functions inside our test utilities after this has passed.
  43  *
  44  * This file tests:
  45  *
  46  * - gmx_simd_align_r(),gmx_simd_align_i(),gmx_simd4_align_r(),
  47  * - gmx_simd_load_r(),gmx_simd_store_r(),gmx_simd_loadu_r(),gmx_simd_storeu_r()
  48  * - gmx_simd_load_i(),gmx_simd_store_i(), gmx_simd_loadu_i(),gmx_simd_storeu_i()
  49  * - gmx_simd4_load_r(),gmx_simd4_store_r(), gmx_simd4_loadu_r(),gmx_simd4_storeu_r()
  50  *
  51  * \author Erik Lindahl <erik.lindahl@scilifelab.se>
  52  * \ingroup module_simd
  53  */
  54
  55 #include <gtest/gtest.h>
  56
  57 #include "gromacs/simd/simd.h"
  58 #include "gromacs/utility/real.h"
  59
  60 namespace
  61 {
  62
  63 /*! \cond internal */
  64 /*! \addtogroup module_simd */
  65 /*! \{ */
  66
  67 TEST(SimdBootstrapTest, gmxSimdAlign)
  68 {
  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++)
  72     {
  73         EXPECT_EQ(((size_t)gmx_simd_align_r(&rdata[i]) & (GMX_SIMD_REAL_WIDTH*sizeof(real)-1)), (size_t)0);
  74     }
  75 #endif
  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++)
  79     {
  80         EXPECT_EQ(((size_t)gmx_simd_align_i(&idata[i]) & (GMX_SIMD_INT32_WIDTH*sizeof(int)-1)), (size_t)0);
  81     }
  82 #endif
  83 }
  84
  85 /*! \brief Generic routine to test load & store of SIMD, and check for side effects.
  86  *
  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.
  92  */
  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)
  97 {
  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!
 103      */
 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;
 109     int              i;
 110
 111     for (i = 0; i < simdWidth*5; i++)
 112     {
 113         src[i] =  1+i;
 114         dst[i] = -1-i;
 115     }
 116
 117     simdStoreFn(pCopyDst, simdLoadFn(pCopySrc));
 118
 119     for (i = 0; i < simdWidth; i++)
 120     {
 121         EXPECT_EQ(pCopySrc[i], pCopyDst[i]) << "SIMD load or store not moving data correctly for element " << i;
 122     }
 123
 124     for (i = 0; i < simdWidth*5; i++)
 125     {
 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)
 128         {
 129             EXPECT_EQ(dst[i], (T)(-1-i)) << "Side effect on destination memory, i = " << i;
 130         }
 131     }
 132 }
 133
 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)
 137 {
 138     return gmx_simd_load_r(m);
 139 }
 140 //! Wrapper for SIMD macro to store to aligned floating-point data.
 141 void            wrapperSimdStoreR(real *m, gmx_simd_real_t s)
 142 {
 143     gmx_simd_store_r(m, s);
 144 }
 145
 146 TEST(SimdBootstrapTest, gmxSimdLoadStoreR)
 147 {
 148     simdLoadStoreTester(wrapperSimdLoadR, wrapperSimdStoreR, gmx_simd_align_r, 0, 0, GMX_SIMD_REAL_WIDTH);
 149 }
 150
 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)
 154 {
 155     return gmx_simd_loadu_r(m);
 156 }
 157
 158 TEST(SimdBootstrapTest, gmxSimdLoadUR)
 159 {
 160     for (int i = 0; i < GMX_SIMD_REAL_WIDTH; i++)
 161     {
 162         simdLoadStoreTester(WrapperSimdLoadUR, wrapperSimdStoreR, gmx_simd_align_r, i, 0, GMX_SIMD_REAL_WIDTH);
 163     }
 164 }
 165 #    endif
 166
 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)
 170 {
 171     gmx_simd_storeu_r(m, s);
 172 }
 173
 174 TEST(SimdBootstrapTest, gmxSimdStoreUR)
 175 {
 176     for (int i = 0; i < GMX_SIMD_REAL_WIDTH; i++)
 177     {
 178         simdLoadStoreTester(wrapperSimdLoadR, WrapperSimdStoreUR, gmx_simd_align_r, 0, i, GMX_SIMD_REAL_WIDTH);
 179     }
 180 }
 181 #    endif
 182 #endif
 183
 184 #ifdef GMX_SIMD_HAVE_INT32
 185 // Tests for gmx_simd_int32_t load & store operations
 186
 187 //! Wrapper for SIMD macro to load aligned integer data.
 188 gmx_simd_int32_t wrapperSimdLoadI(int *m)
 189 {
 190     return gmx_simd_load_i(m);
 191 }
 192 //! Wrapper for SIMD macro to store to aligned integer data.
 193 void             wrapperSimdStoreI(int *m, gmx_simd_int32_t s)
 194 {
 195     gmx_simd_store_i(m, s);
 196 }
 197
 198 TEST(SimdBootstrapTest, gmxSimdLoadStoreI)
 199 {
 200     simdLoadStoreTester(wrapperSimdLoadI, wrapperSimdStoreI, gmx_simd_align_i, 0, 0, GMX_SIMD_INT32_WIDTH);
 201 }
 202
 203 #    ifdef GMX_SIMD_HAVE_LOADU
 204 //! Wrapper for SIMD macro to load unaligned integer data.
 205 gmx_simd_int32_t wrapperSimdLoadUI(int *m)
 206 {
 207     return gmx_simd_loadu_i(m);
 208 }
 209
 210 TEST(SimdBootstrapTest, gmxSimdLoadUI)
 211 {
 212     for (int i = 0; i < GMX_SIMD_INT32_WIDTH; i++)
 213     {
 214         simdLoadStoreTester(wrapperSimdLoadUI, wrapperSimdStoreI, gmx_simd_align_i, i, 0, GMX_SIMD_INT32_WIDTH);
 215     }
 216 }
 217 #    endif
 218
 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)
 222 {
 223     gmx_simd_storeu_i(m, s);
 224 }
 225
 226 TEST(SimdBootstrapTest, gmxSimdStoreUI)
 227 {
 228     for (int i = 0; i < GMX_SIMD_INT32_WIDTH; i++)
 229     {
 230         simdLoadStoreTester(wrapperSimdLoadI, wrapperSimdStoreUI, gmx_simd_align_i, 0, i, GMX_SIMD_INT32_WIDTH);
 231     }
 232 }
 233 #    endif
 234 #endif
 235
 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.
 239  */
 240
 241 /*! \brief Separate load/store tester function for SIMD4.
 242  *
 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).
 248  */
 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)
 253 {
 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!
 259      */
 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;
 265     int       i;
 266
 267     for (i = 0; i < GMX_SIMD4_WIDTH*5; i++)
 268     {
 269         src[i] =  1+i;
 270         dst[i] = -1-i;
 271     }
 272
 273     simd4StoreFn(pCopyDst, simd4LoadFn(pCopySrc));
 274
 275     for (i = 0; i < GMX_SIMD4_WIDTH; i++)
 276     {
 277         EXPECT_EQ(pCopySrc[i], pCopyDst[i]) << "SIMD4 load or store not moving data correctly for element " << i;
 278     }
 279
 280     for (i = 0; i < GMX_SIMD4_WIDTH*5; i++)
 281     {
 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)
 284         {
 285             EXPECT_EQ(dst[i], (T)(-1-i)) << "Side effect on destination memory, i = " << i;
 286         }
 287     }
 288 }
 289
 290 //! Wrapper for SIMD4 macro to load aligned floating-point data.
 291 gmx_simd4_real_t wrapperSimd4LoadR(real *m)
 292 {
 293     return gmx_simd4_load_r(m);
 294 }
 295 //! Wrapper for SIMD4 macro to store to aligned floating-point data.
 296 void             wrapperSimd4StoreR(real *m, gmx_simd4_real_t s)
 297 {
 298     gmx_simd4_store_r(m, s);
 299 }
 300
 301 TEST(SimdBootstrapTest, gmxSimd4LoadStoreR)
 302 {
 303     simd4LoadStoreTester(wrapperSimd4LoadR, wrapperSimd4StoreR, gmx_simd4_align_r, 0, 0);
 304 }
 305
 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)
 309 {
 310     return gmx_simd4_loadu_r(m);
 311 }
 312
 313 TEST(SimdBootstrapTest, gmxSimd4LoadUR)
 314 {
 315     for (int i = 0; i < GMX_SIMD4_WIDTH; i++)
 316     {
 317         simd4LoadStoreTester(WrapperSimd4LoadUR, wrapperSimd4StoreR, gmx_simd4_align_r, i, 0);
 318     }
 319 }
 320 #    endif
 321
 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)
 325 {
 326     gmx_simd4_storeu_r(m, s);
 327 }
 328
 329 TEST(SimdBootstrapTest, gmxSimd4StoreUR)
 330 {
 331     for (int i = 0; i < GMX_SIMD4_WIDTH; i++)
 332     {
 333         simd4LoadStoreTester(wrapperSimd4LoadR, WrapperSimd4StoreUR, gmx_simd4_align_r, 0, i);
 334     }
 335 }
 336 #    endif
 337 #endif
 338
 339 /*! \} */
 340 /*! \endcond */
 341
 342 } // namespace