source-engine/utils/simdtest/simdtest.cpp

322 lines
10 KiB
C++
Raw Normal View History

2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#include "tier0/platform.h"
#include "tier0/progressbar.h"
#include "bitmap/float_bm.h"
#include "mathlib/mathlib.h"
#include "tier2/tier2.h"
#include "tier0/memdbgon.h"
#include "mathlib/ssemath.h"
#ifdef _X360
#include "xbox/xbox_console.h"
#endif
#define PROBLEM_SIZE 1000
#define N_ITERS 100000
//#define RECORD_OUTPUT
static FourVectors g_XYZ[PROBLEM_SIZE];
static fltx4 g_CreationTime[PROBLEM_SIZE];
bool SIMDTest()
{
const Vector StartPnt(0,0,0);
const Vector MidP(0,0,100);
const Vector EndPnt(100,0,50);
// This app doesn't go through regular engine init, so init FPU/VPU math behaviour here:
SetupFPUControlWord();
TestVPUFlags();
// Initialize g_XYZ[] and g_CreationTime[]
SeedRandSIMD(1987301);
for (int i = 0;i < PROBLEM_SIZE;i++)
{
float fourStartTimes[4];
Vector fourPoints[4];
Vector offset;
for (int j = 0;j < 4;j++)
{
float t = (j + 4 * i) / (4.0f * (PROBLEM_SIZE - 1));
fourStartTimes[j] = t;
fourPoints[j] = StartPnt + t*( EndPnt - StartPnt );
offset.Random( -10.0f, +10.0f );
fourPoints[j] += offset;
}
g_XYZ[i].LoadAndSwizzle( fourPoints[0], fourPoints[1], fourPoints[2], fourPoints[3] );
g_CreationTime[i] = LoadUnalignedSIMD( fourStartTimes );
}
#ifdef RECORD_OUTPUT
char outputBuffer[1024];
Q_snprintf( outputBuffer, sizeof( outputBuffer ), "float testOutput[%d][4][3] = {\n", N_ITERS );
Warning(outputBuffer);
#endif // RECORD_OUTPUT
double STime=Plat_FloatTime();
bool bChangedSomething = false;
for(int i=0;i<N_ITERS;i++)
{
float t=i*(1.0/N_ITERS);
FourVectors * __restrict pXYZ = g_XYZ;
fltx4 * __restrict pCreationTime = g_CreationTime;
fltx4 CurTime = ReplicateX4( t );
fltx4 TimeScale = ReplicateX4( 1.0/(max(0.001, 1.0 ) ) );
// calculate radius spline
bool bConstantRadius = true;
fltx4 Rad0=ReplicateX4(2.0);
fltx4 Radm=Rad0;
fltx4 Rad1=Rad0;
fltx4 RadmMinusRad0=SubSIMD( Radm, Rad0);
fltx4 Rad1MinusRadm=SubSIMD( Rad1, Radm);
fltx4 SIMDMinDist=ReplicateX4( 2.0 );
fltx4 SIMDMinDist2=ReplicateX4( 2.0*2.0 );
fltx4 SIMDMaxDist=MaxSIMD( Rad0, MaxSIMD( Radm, Rad1 ) );
fltx4 SIMDMaxDist2=MulSIMD( SIMDMaxDist, SIMDMaxDist);
FourVectors StartP;
StartP.DuplicateVector( StartPnt );
FourVectors MiddleP;
MiddleP.DuplicateVector( MidP );
// form delta terms needed for quadratic bezier
FourVectors Delta0;
Delta0.DuplicateVector( MidP-StartPnt );
FourVectors Delta1;
Delta1.DuplicateVector( EndPnt-MidP );
int nLoopCtr = PROBLEM_SIZE;
do
{
fltx4 TScale=MinSIMD(
Four_Ones,
MulSIMD( TimeScale, SubSIMD( CurTime, *pCreationTime ) ) );
// bezier(a,b,c,t)=lerp( lerp(a,b,t),lerp(b,c,t),t)
FourVectors L0 = Delta0;
L0 *= TScale;
L0 += StartP;
FourVectors L1= Delta1;
L1 *= TScale;
L1 += MiddleP;
FourVectors Center = L1;
Center -= L0;
Center *= TScale;
Center += L0;
FourVectors pts_original = *(pXYZ);
FourVectors pts = pts_original;
pts -= Center;
// calculate radius at the point. !!speed!! - use special case for constant radius
fltx4 dist_squared= pts * pts;
fltx4 TooFarMask = CmpGtSIMD( dist_squared, SIMDMaxDist2 );
if ( ( !bConstantRadius) && ( ! IsAnyNegative( TooFarMask ) ) )
{
// need to calculate and adjust for true radius =- we've only trivially rejected note
// voodoo here - we update simdmaxdist for true radius, but not max dist^2, since
// that's used only for the trivial reject case, which we've already done
fltx4 R0=AddSIMD( Rad0, MulSIMD( RadmMinusRad0, TScale ) );
fltx4 R1=AddSIMD( Radm, MulSIMD( Rad1MinusRadm, TScale ) );
SIMDMaxDist = AddSIMD( R0, MulSIMD( SubSIMD( R1, R0 ), TScale) );
// now that we know the true radius, update our mask
TooFarMask = CmpGtSIMD( dist_squared, MulSIMD( SIMDMaxDist, SIMDMaxDist ) );
}
fltx4 TooCloseMask = CmpLtSIMD( dist_squared, SIMDMinDist2 );
fltx4 NeedAdjust = OrSIMD( TooFarMask, TooCloseMask );
if ( IsAnyNegative( NeedAdjust ) ) // any out of bounds?
{
// change squared distance into approximate rsqr root
fltx4 guess=ReciprocalSqrtEstSIMD(dist_squared);
// newton iteration for 1/sqrt(x) : y(n+1)=1/2 (y(n)*(3-x*y(n)^2));
guess=MulSIMD(guess,SubSIMD(Four_Threes,MulSIMD(dist_squared,MulSIMD(guess,guess))));
guess=MulSIMD(Four_PointFives,guess);
pts *= guess;
FourVectors clamp_far=pts;
clamp_far *= SIMDMaxDist;
clamp_far += Center;
FourVectors clamp_near=pts;
clamp_near *= SIMDMinDist;
clamp_near += Center;
pts.x = MaskedAssign( TooCloseMask, clamp_near.x, MaskedAssign( TooFarMask, clamp_far.x, pts_original.x ));
pts.y = MaskedAssign( TooCloseMask, clamp_near.y, MaskedAssign( TooFarMask, clamp_far.y, pts_original.y ));
pts.z = MaskedAssign( TooCloseMask, clamp_near.z, MaskedAssign( TooFarMask, clamp_far.z, pts_original.z ));
*(pXYZ) = pts;
bChangedSomething = true;
}
#ifdef RECORD_OUTPUT
if (nLoopCtr == 257)
{
Q_snprintf( outputBuffer, sizeof( outputBuffer ), "/*%04d:*/ { {%+14e,%+14e,%+14e}, {%+14e,%+14e,%+14e}, {%+14e,%+14e,%+14e}, {%+14e,%+14e,%+14e} },\n", i,
pXYZ->X(0), pXYZ->Y(0), pXYZ->Z(0),
pXYZ->X(1), pXYZ->Y(1), pXYZ->Z(1),
pXYZ->X(2), pXYZ->Y(2), pXYZ->Z(2),
pXYZ->X(3), pXYZ->Y(3), pXYZ->Z(3));
Warning(outputBuffer);
}
#endif // RECORD_OUTPUT
++pXYZ;
++pCreationTime;
} while ( --nLoopCtr );
}
double ETime=Plat_FloatTime()-STime;
#ifdef RECORD_OUTPUT
Q_snprintf( outputBuffer, sizeof( outputBuffer ), " };\n" );
Warning(outputBuffer);
#endif // RECORD_OUTPUT
printf("elapsed time=%f p/s=%f\n",ETime, (4.0*PROBLEM_SIZE*N_ITERS)/ETime );
return bChangedSomething;
}
#ifdef _X360
__declspec(passinreg) struct float4
{
operator __vector4 () const { return vmx; }
__vector4 vmx;
};
void OctoberXDKCompilerIssueTestCode( const fltx4 & val, fltx4 * out )
{
// UNDONE: This code demonstrates serious 360 compiler issues. XBox Developer Support has been contacted.
// The assembly contains tons of useless instructions (vector stores and supporting integer math), even in the
// below code - no use of pointers or static constants, no wrapper layers on top of the vector intrinsics.
// If/when the compiler issue is resolved, other known issues are:
// - pass vector params by const reference
// - avoid putting __vector4 in a union or an array
// - avoid default constructors, return constructed objects directly ("return VecClass(__vector4Val);")
#define DECL_ASS( _var_, _val_ ) fltx4 _var_ = _val_
//#define DECL_ASS( _var_, _val_ ) float4 _var_; _var_.vmx = _val_
//#define DECL_ASS( _var_, _val_ ) float4 _var_( _val_ )
DECL_ASS( resultx, Four_Zeros ); DECL_ASS( resulty, Four_Zeros ); DECL_ASS( resultz, Four_Zeros );
DECL_ASS( CurTime, __vmulfp( val, Four_PointFives ) );
DECL_ASS( TimeScale, val );
//fltx4 *pCreationTime = g_CreationTime;
DECL_ASS( Delta0x, val ); DECL_ASS( Delta0y, val ); DECL_ASS( Delta0z, val );
DECL_ASS( Delta1x, __vaddfp(Delta0x, Delta0x) ); DECL_ASS( Delta1y, __vaddfp(Delta0y, Delta0y) ); DECL_ASS( Delta1z, __vaddfp(Delta0z, Delta0z) );
DECL_ASS( StartPx, __vaddfp(Delta0x, Delta0x) ); DECL_ASS( StartPy, __vaddfp(Delta0y, Delta0y) ); DECL_ASS( StartPz, __vaddfp(Delta0z, Delta0z) );
DECL_ASS( MiddlePx, __vaddfp(StartPx, StartPx) ); DECL_ASS( MiddlePy, __vaddfp(StartPy, StartPy) ); DECL_ASS( MiddlePz, __vaddfp(StartPz, StartPz) );
for (int i = 0;i < 1000;i++)
{
DECL_ASS( TScale, __vsubfp( CurTime, resultx ) );//*pCreationTime );
TScale = __vmulfp( TScale, TimeScale );
TScale = __vminfp( TScale, resulty );//Four_Ones );
//resultx = __vaddfp( resultx, TScale );
//resulty = __vaddfp( resulty, TScale );
//resultz = __vaddfp( resultz, TScale );
DECL_ASS( L0x, Delta0x ); DECL_ASS( L0y, Delta0y ); DECL_ASS( L0z, Delta0z );
L0x = __vmulfp(L0x,TScale); L0y = __vmulfp(L0y,TScale); L0z = __vmulfp(L0z,TScale);
L0x = __vaddfp(StartPx,L0x); L0y = __vaddfp(StartPy,L0y); L0z = __vaddfp(StartPz,L0z);
DECL_ASS( L1x, Delta1x ); DECL_ASS( L1y, Delta1y ); DECL_ASS( L1z, Delta1z );
L1x = __vmulfp(L1x,TScale); L1y = __vmulfp(L1y,TScale); L1z = __vmulfp(L1z,TScale);
L1x = __vaddfp(MiddlePx,L1x); L1y = __vaddfp(MiddlePy,L1y); L1z = __vaddfp(MiddlePz,L1z);
L0x = __vaddfp(L0x,L1x); L0y = __vaddfp(L0y,L1y); L0z = __vaddfp(L0z,L1z);
resultx = __vaddfp( resultx, L0x );
resulty = __vaddfp( resulty, L0y );
resultz = __vaddfp( resultz, L0z );
//pCreationTime++;
}
out[0] = resultx;
out[1] = resulty;
out[2] = resultz;
}
#else // _X360
void
SSEClassTest( const fltx4 & val, fltx4 & out )
{
fltx4 result = Four_Zeros;
for (int i = 0;i < N_ITERS;i++)
{
result = SubSIMD( val, result );
result = MulSIMD( val, result );
result = AddSIMD( val, result );
result = MinSIMD( val, result );
}
FourVectors result4; result4.x = result; result4.y = result; result4.z = result;
for (int i = 0;i < N_ITERS;i++)
{
result4 *= result4;
result4 += result4;
result4 *= result4;
result4 += result4;
}
result = result4*result4;
out = result;
}
#endif // !_X360
int main(int argc,char **argv)
{
#ifndef _X360
// UNDONE: InitCommandLineProgram needs fixing for 360 (if we want to make lots of new 360 executables)
InitCommandLineProgram( argc, argv );
// This function is useful for inspecting compiler output
fltx4 result;
SSEClassTest( Four_PointFives, result );
printf("(%f,%f,%f,%f)\n", SubFloat( result, 0 ), SubFloat( result, 1 ), SubFloat( result, 2 ), SubFloat( result, 3 ) );
#else // _X360
// Wait for VXConsole, so that all debug output goes there
XBX_InitConsoleMonitor(true);
// This function is useful for inspecting compiler output
FourVectors result;
OctoberXDKCompilerIssueTestCode( Four_PointFives, (fltx4 *)&result );
printf("(%f,%f,%f,%f)\n", result.X(0), result.X(1), result.X(2), result.X(3));
printf("(%f,%f,%f,%f)\n", result.Y(0), result.Y(1), result.Y(2), result.Y(3));
printf("(%f,%f,%f,%f)\n", result.Z(0), result.Z(1), result.Z(2), result.Z(3));
#endif // _X360
// Run the perf. test
SIMDTest();
return 0;
}