Test/Source/Tests/Test_v3interp.cpp

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