src/gromacs/simd/tests/scalar_util.cpp

   1 /*
   2  * This file is part of the GROMACS molecular simulation package.
   3  *
   4  * Copyright (c) 2014,2015,2016,2017,2018 by the GROMACS development team.
   5  * Copyright (c) 2019,2020, by the GROMACS development team, led by
   6  * Mark Abraham, David van der Spoel, Berk Hess, and Erik Lindahl,
   7  * and including many others, as listed in the AUTHORS file in the
   8  * top-level source directory and at http://www.gromacs.org.
   9  *
  10  * GROMACS is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public License
  12  * as published by the Free Software Foundation; either version 2.1
  13  * of the License, or (at your option) any later version.
  14  *
  15  * GROMACS is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with GROMACS; if not, see
  22  * http://www.gnu.org/licenses, or write to the Free Software Foundation,
  23  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA.
  24  *
  25  * If you want to redistribute modifications to GROMACS, please
  26  * consider that scientific software is very special. Version
  27  * control is crucial - bugs must be traceable. We will be happy to
  28  * consider code for inclusion in the official distribution, but
  29  * derived work must not be called official GROMACS. Details are found
  30  * in the README & COPYING files - if they are missing, get the
  31  * official version at http://www.gromacs.org.
  32  *
  33  * To help us fund GROMACS development, we humbly ask that you cite
  34  * the research papers on the package. Check out http://www.gromacs.org.
  35  */
  36 #include "gmxpre.h"
  37
  38 #include <cmath>
  39
  40 #include <gtest/gtest.h>
  41
  42 #include "gromacs/simd/simd.h"
  43 #include "gromacs/utility/basedefinitions.h"
  44
  45 #include "testutils/testasserts.h"
  46
  47 #include "data.h"
  48
  49 namespace gmx
  50 {
  51 namespace test
  52 {
  53
  54 namespace
  55 {
  56
  57 /*! \cond internal */
  58 /*! \addtogroup module_simd */
  59 /*! \{ */
  60
  61 TEST(SimdScalarUtilTest, gatherLoadTranspose)
  62 {
  63     real         data[8] = { c0, c1, c2, c3, c4, c5, c6, c7 };
  64     std::int32_t offset  = 1;
  65     real         v0, v1, v2, v3;
  66
  67     gatherLoadTranspose<4>(data, &offset, &v0, &v1, &v2, &v3);
  68
  69     EXPECT_EQ(data[4], v0);
  70     EXPECT_EQ(data[5], v1);
  71     EXPECT_EQ(data[6], v2);
  72     EXPECT_EQ(data[7], v3);
  73
  74     gatherLoadTranspose<2>(data, &offset, &v0, &v1);
  75
  76     EXPECT_EQ(data[2], v0);
  77     EXPECT_EQ(data[3], v1);
  78 }
  79
  80 TEST(SimdScalarUtilTest, gatherLoadUTranspose)
  81 {
  82     real         data[6] = { c0, c1, c2, c3, c4, c5 };
  83     std::int32_t offset  = 1;
  84     real         v0, v1, v2;
  85
  86     gatherLoadUTranspose<3>(data, &offset, &v0, &v1, &v2);
  87
  88     EXPECT_EQ(data[3], v0);
  89     EXPECT_EQ(data[4], v1);
  90     EXPECT_EQ(data[5], v2);
  91 }
  92
  93 TEST(SimdScalarUtilTest, transposeScatterStoreU)
  94 {
  95     real         data[9] = { 0, 0, 0, 0, 0, 0, 0, 0, 0 };
  96     std::int32_t offset  = 1;
  97     real         v0      = 1;
  98     real         v1      = 2;
  99     real         v2      = 3;
 100
 101     transposeScatterStoreU<3>(data, &offset, v0, v1, v2);
 102
 103     EXPECT_EQ(czero, data[0]);
 104     EXPECT_EQ(czero, data[1]);
 105     EXPECT_EQ(czero, data[2]);
 106     EXPECT_EQ(v0, data[3]);
 107     EXPECT_EQ(v1, data[4]);
 108     EXPECT_EQ(v2, data[5]);
 109     EXPECT_EQ(czero, data[6]);
 110     EXPECT_EQ(czero, data[7]);
 111     EXPECT_EQ(czero, data[8]);
 112 }
 113
 114 TEST(SimdScalarUtilTest, transposeScatterIncrU)
 115 {
 116     real         data[9] = { 10, 20, 30, 40, 50, 60, 70, 80, 90 };
 117     std::int32_t offset  = 1;
 118     real         v0      = c1;
 119     real         v1      = c2;
 120     real         v2      = c3;
 121
 122     transposeScatterIncrU<3>(data, &offset, v0, v1, v2);
 123
 124     EXPECT_EQ(real(10), data[0]);
 125     EXPECT_EQ(real(20), data[1]);
 126     EXPECT_EQ(real(30), data[2]);
 127     EXPECT_EQ(real(40 + c1), data[3]);
 128     EXPECT_EQ(real(50 + c2), data[4]);
 129     EXPECT_EQ(real(60 + c3), data[5]);
 130     EXPECT_EQ(real(70), data[6]);
 131     EXPECT_EQ(real(80), data[7]);
 132     EXPECT_EQ(real(90), data[8]);
 133 }
 134
 135 TEST(SimdScalarUtilTest, transposeScatterDecrU)
 136 {
 137     real         data[9] = { 10, 20, 30, 40, 50, 60, 70, 80, 90 };
 138     std::int32_t offset  = 1;
 139     real         v0      = c1;
 140     real         v1      = c2;
 141     real         v2      = c3;
 142
 143     transposeScatterDecrU<3>(data, &offset, v0, v1, v2);
 144
 145     EXPECT_EQ(real(10), data[0]);
 146     EXPECT_EQ(real(20), data[1]);
 147     EXPECT_EQ(real(30), data[2]);
 148     EXPECT_EQ(real(40 - c1), data[3]);
 149     EXPECT_EQ(real(50 - c2), data[4]);
 150     EXPECT_EQ(real(60 - c3), data[5]);
 151     EXPECT_EQ(real(70), data[6]);
 152     EXPECT_EQ(real(80), data[7]);
 153     EXPECT_EQ(real(90), data[8]);
 154 }
 155
 156
 157 TEST(SimdScalarTest, expandScalarsToTriplets)
 158 {
 159     real scalar = c1;
 160     real t0, t1, t2;
 161
 162     expandScalarsToTriplets(scalar, &t0, &t1, &t2);
 163
 164     EXPECT_EQ(scalar, t0);
 165     EXPECT_EQ(scalar, t1);
 166     EXPECT_EQ(scalar, t2);
 167 }
 168
 169 TEST(SimdScalarUtilTest, gatherLoadBySimdIntTranspose)
 170 {
 171     real         data[8] = { c0, c1, c2, c3, c4, c5, c6, c7 };
 172     std::int32_t offset  = 1;
 173     real         v0, v1, v2, v3;
 174
 175     gatherLoadBySimdIntTranspose<4>(data, offset, &v0, &v1, &v2, &v3);
 176
 177     EXPECT_EQ(data[4], v0);
 178     EXPECT_EQ(data[5], v1);
 179     EXPECT_EQ(data[6], v2);
 180     EXPECT_EQ(data[7], v3);
 181
 182     gatherLoadBySimdIntTranspose<2>(data, offset, &v0, &v1);
 183
 184     EXPECT_EQ(data[2], v0);
 185     EXPECT_EQ(data[3], v1);
 186 }
 187
 188 TEST(SimdScalarUtilTest, gatherLoadUBySimdIntTranspose)
 189 {
 190     real         data[8] = { c0, c1, c2, c3, c4, c5, c6, c7 };
 191     std::int32_t offset  = 1;
 192     real         v0, v1;
 193
 194     gatherLoadUBySimdIntTranspose<4>(data, offset, &v0, &v1);
 195
 196     EXPECT_EQ(data[4], v0);
 197     EXPECT_EQ(data[5], v1);
 198 }
 199
 200 TEST(SimdScalarUtilTest, reduceIncr4ReturnSum)
 201 {
 202     real data[6] = { 0, 0, 0, 0, 0, 0 };
 203     real v0      = c1;
 204     real v1      = c2;
 205     real v2      = c3;
 206     real v3      = c4;
 207     real sum;
 208
 209     sum = reduceIncr4ReturnSum(data + 1, v0, v1, v2, v3);
 210
 211     EXPECT_EQ(czero, data[0]);
 212     EXPECT_EQ(v0, data[1]);
 213     EXPECT_EQ(v1, data[2]);
 214     EXPECT_EQ(v2, data[3]);
 215     EXPECT_EQ(v3, data[4]);
 216     EXPECT_EQ(czero, data[5]);
 217
 218     EXPECT_REAL_EQ_TOL(real(v0 + v1 + v2 + v3), sum, defaultRealTolerance());
 219 }
 220
 221 /*! \} */
 222 /*! \endcond internal */
 223
 224 } // namespace
 225 } // namespace test
 226 } // namespace gmx