Test/Source/Tests/Test_v3sdiv.cpp

   1 //
   2 //  Test_v3sdiv.cpp
   3 //  BulletTest
   4 //
   5 //  Copyright (c) 2011 Apple Inc.
   6 //
   7
   8
   9
  10 #include "LinearMath/btScalar.h"
  11 #if defined (BT_USE_SSE_IN_API) || defined (BT_USE_NEON)
  12
  13
  14 #include "Test_v3sdiv.h"
  15 #include "vector.h"
  16 #include "Utils.h"
  17 #include "main.h"
  18 #include <math.h>
  19 #include <string.h>
  20
  21 #include <LinearMath/btVector3.h>
  22
  23 // reference code for testing purposes
  24 static inline
  25 btVector3& v3sdiv_ref(
  26     btVector3& v,
  27         const btScalar& s);
  28
  29 #define LOOPCOUNT 2048
  30 #define NUM_CYCLES 1000
  31
  32 int Test_v3sdiv(void)
  33 {
  34     btVector3 v1, v2;
  35         btScalar s;
  36
  37     float x,y,z,w;
  38
  39     // Init the data
  40     x = RANDF_01;
  41     y = RANDF_01;
  42     z = RANDF_01;
  43     w = BT_NAN;     // w channel NaN
  44     v1.setValue(x,y,z);
  45         v1.setW(w);
  46
  47     v2.setValue(x,y,z);
  48         v2.setW(w);
  49
  50     s = (float) RANDF_16;
  51
  52     btVector3 correct_res, test_res;
  53
  54     {
  55                 float vNaN = BT_NAN;
  56                 correct_res.setValue(vNaN, vNaN, vNaN);
  57                 test_res.setValue(vNaN, vNaN, vNaN);
  58                 correct_res = v3sdiv_ref(v1, s);
  59                 test_res = (v2 /= s);
  60
  61                 if( fabs(correct_res.m_floats[0] - test_res.m_floats[0]) +
  62                         fabs(correct_res.m_floats[1] - test_res.m_floats[1]) +
  63                         fabs(correct_res.m_floats[2] - test_res.m_floats[2]) > FLT_EPSILON * 4)
  64                 {
  65                         vlog( "Error - v3sdiv result error! "
  66                                         "\ncorrect = (%10.4f, %10.4f, %10.4f) "
  67                                         "\ntested  = (%10.4f, %10.4f, %10.4f) \n",
  68                                         correct_res.m_floats[0], correct_res.m_floats[1], correct_res.m_floats[2],
  69                                         test_res.m_floats[0], test_res.m_floats[1], test_res.m_floats[2]);
  70
  71                         return 1;
  72                 }
  73         }
  74
  75 #define DATA_SIZE LOOPCOUNT
  76
  77         btVector3 vec3_arr[DATA_SIZE];
  78     btScalar  s_arr[DATA_SIZE];
  79
  80     uint64_t scalarTime;
  81     uint64_t vectorTime;
  82     size_t j, k;
  83
  84         {
  85         uint64_t startTime, bestTime, currentTime;
  86
  87         bestTime = uint64_t(-1LL);
  88         scalarTime = 0;
  89         for (j = 0; j < NUM_CYCLES; j++)
  90                 {
  91                         for( k = 0; k < DATA_SIZE; k++ )
  92                         {
  93                 x = RANDF_01;
  94                 y = RANDF_01;
  95                 z = RANDF_01;
  96                                 vec3_arr[k].setValue(x,y,z);
  97                                 vec3_arr[k].setW(w);
  98
  99                                 s_arr[k] = RANDF_01;
 100                         }
 101
 102             startTime = ReadTicks();
 103             for( k = 0; k+4 <= LOOPCOUNT; k+=4 )
 104                         {
 105                 v3sdiv_ref( vec3_arr[k], s_arr[k]);
 106                 v3sdiv_ref( vec3_arr[k+1], s_arr[k+1]);
 107                 v3sdiv_ref( vec3_arr[k+2], s_arr[k+2]);
 108                 v3sdiv_ref( vec3_arr[k+3], s_arr[k+3]);
 109                         }
 110                         currentTime = ReadTicks() - startTime;
 111             scalarTime += currentTime;
 112             if( currentTime < bestTime )
 113                 bestTime = currentTime;
 114         }
 115         if( 0 == gReportAverageTimes )
 116             scalarTime = bestTime;
 117         else
 118             scalarTime /= NUM_CYCLES;
 119     }
 120
 121     {
 122         uint64_t startTime, bestTime, currentTime;
 123
 124         bestTime = -1LL;
 125         vectorTime = 0;
 126         for (j = 0; j < NUM_CYCLES; j++)
 127                 {
 128                         for( k = 0; k < DATA_SIZE; k++ )
 129                         {
 130                 x = RANDF_01;
 131                 y = RANDF_01;
 132                 z = RANDF_01;
 133                                 vec3_arr[k].setValue(x,y,z);
 134                                 vec3_arr[k].setW(w);
 135
 136                                 s_arr[k] = RANDF_01;
 137                         }
 138
 139             startTime = ReadTicks();
 140             for( k = 0; k+4 <= LOOPCOUNT; k+=4 )
 141                         {
 142                                 vec3_arr[k] /= s_arr[k];
 143                                 vec3_arr[k+1] /= s_arr[k+1];
 144                                 vec3_arr[k+2] /= s_arr[k+2];
 145                                 vec3_arr[k+3] /= s_arr[k+3];
 146                         }
 147                         currentTime = ReadTicks() - startTime;
 148             vectorTime += currentTime;
 149             if( currentTime < bestTime )
 150                 bestTime = currentTime;
 151         }
 152         if( 0 == gReportAverageTimes )
 153             vectorTime = bestTime;
 154         else
 155             vectorTime /= NUM_CYCLES;
 156     }
 157
 158     vlog( "Timing:\n" );
 159     vlog( "     \t    scalar\t    vector\n" );
 160     vlog( "    \t%10.4f\t%10.4f\n", TicksToCycles( scalarTime ) / LOOPCOUNT,
 161                                                                         TicksToCycles( vectorTime ) / LOOPCOUNT );
 162
 163     return 0;
 164 }
 165
 166 static inline
 167 btVector3&
 168 v3sdiv_ref(
 169     btVector3& v,
 170     const btScalar& s)
 171 {
 172         btScalar recip = btScalar(1.0) / s;
 173
 174         v.m_floats[0] *= recip;
 175         v.m_floats[1] *= recip;
 176         v.m_floats[2] *= recip;
 177
 178         return v;
 179 }
 180
 181 #endif //BT_USE_SSE