tf2/tf2_src/utils/simdtest/simdtest.cpp

//========= 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;
}