// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32test\bench\t_asmbm.cpp

 // 

 //

 #include "t_asmbm.h"

 #include <hal.h>

 #include <e32test.h>

 extern RTest test;

 const TReal KDefaultRunLength = 1.0;

 const TInt KInitIterations = 3000;

 // Length of time to run benchmark for in seconds

 TReal RunLength = KDefaultRunLength;

 TInt FastCounterFrequency;

 TBool FastCounterCountsUp;

 /**

  * Calculate the time in seconds corresponding to a fast counter delta value.

  */

 TReal TimeDelta(TInt aDelta)

 	{

 	if (!FastCounterCountsUp)

 		aDelta = -aDelta;

 	return ((TReal) aDelta + 1) / FastCounterFrequency;

 	}

 /**

  * Run a benchmark for the specifiec number of iterations and return the total

  * time taken in seconds.

  */

 TReal TimeBenchmarkL(MBenchmarkList& aBenchmarks, TInt aIndex, const TBmParams& aParams)

 	{

 	TInt delta = 0;

 	User::LeaveIfError(aBenchmarks.Run(aIndex, aParams, delta));

 	User::After(20 * 1000); // hack: wait for kernel thread to exit

 	return TimeDelta(delta);

 	}

 void RunGeneralBenchmarkL(MBenchmarkList& aBenchmarks, TInt aIndex, const TBmInfo& aInfo)

     {

 	// Run the benchmark with a small number of iterations and from this result

 	// work out how many iterations we need to run it for RunLength seconds.

 	// Loop till we get it right.

 	TBmParams params;

 	params.iSourceAlign = 0;

 	params.iDestAlign = 0;

 	TInt iterations = KInitIterations;

 	TReal time;

 	for (;;)

 		{

 		params.iIts = iterations / 10;

 		time = TimeBenchmarkL(aBenchmarks, aIndex, params);

 		if (time >= RunLength)

 			break;

 		iterations = (TInt) ((RunLength * 1.2) / (time/(TReal)iterations));

 		}

 	TBuf<64> nameBuf;

 	nameBuf.Copy(aInfo.iName);

     test.Printf(_L("%i\t%e\t%S\n"), aIndex, time/iterations * 1000000.0, &nameBuf);

     }

 void RunMemoryBenchmarkL(MBenchmarkList& aBenchmarks, TInt aIndex, const TBmInfo& aInfo)

     {

 	// Run the benchmark with a small number of iterations and from this result

 	// work out how many iterations we need to run it for RunLength seconds.

 	// Loop till we get it right.

 	TBmParams params;

 	params.iSourceAlign = 0;

 	params.iDestAlign = 0;

 	TInt iterations = KInitIterations;

 	TReal time;

 	for (;;)

 		{

 		params.iIts = iterations / 10;

 		time = TimeBenchmarkL(aBenchmarks, aIndex, params);

 		if (time >= RunLength)

 			break;

 		iterations = (TInt) ((RunLength * 1.2) / (time/(TReal)iterations));

 		}

 	TBuf<64> nameBuf;

 	nameBuf.Copy(aInfo.iName);

 	test.Printf(_L("%i\t%S\talignment step == %d\n"), aIndex, &nameBuf, aInfo.iAlignStep);

 	for (TInt sourceAlign = 0 ; sourceAlign < 32 ; sourceAlign += aInfo.iAlignStep)

 		{

 		for (TInt destAlign = 0 ; destAlign < 32 ; destAlign += aInfo.iAlignStep)

 			{

 			params.iSourceAlign = sourceAlign;

 			params.iDestAlign = destAlign;

 			time = TimeBenchmarkL(aBenchmarks, aIndex, params);

 			test.Printf(_L("%e\t"), time/iterations * 1000000.0);

 			}

 		test.Printf(_L("\n"));

 		}

     }

 void RunBenchmarkL(MBenchmarkList& aBenchmarks, TInt aIndex, TUint aCategories)

 	{

 	TBmInfo info;

 	User::LeaveIfError(aBenchmarks.Info(aIndex, info));

 	if (!(info.iCategories & aCategories))

 		return;

 	if (info.iCategories & aCategories & KCategoryMemory)

 		RunMemoryBenchmarkL(aBenchmarks, aIndex, info);

 	else

 		RunGeneralBenchmarkL(aBenchmarks, aIndex, info);

 	}

 void BadUsage()

 	{

 	test.Printf(_L("usage: [ OPTIONS ] [ INDEX... ]\n"));

 	test.Printf(_L("Options are:\n"));

 	test.Printf(_L("  -r TIME  Set the length of time in seconds to run each benchmark for\n"));

 	test.Printf(_L("  -m       Run memory alignment benchmarks only\n"));

 	test.Printf(_L("  -x       Run extra benchmarks as well as normal ones\n"));

 	}

 void RunBenchmarkTestsL(MBenchmarkList& aBenchmarks)

 	{

 	InitDataL();

 	User::LeaveIfError(HAL::Get(HALData::EFastCounterFrequency, FastCounterFrequency));

 	User::LeaveIfError(HAL::Get(HALData::EFastCounterCountsUp, FastCounterCountsUp));

 	TInt count = aBenchmarks.Count();

 	TBool ok = ETrue;

 	TUint categories = KCategoryGeneral;

 	RArray<TInt> testsToRun;

 	CleanupClosePushL(testsToRun);

 	HBufC* buf = HBufC::NewLC(User::CommandLineLength());

 	TPtr ptr = buf->Des();

 	User::CommandLine(ptr);

 	if (ptr != KNullDesC)

 		{

 		TLex lex(ptr);

 		TPtrC16 token;

 		while (ok && (token.Set(lex.NextToken()), token != KNullDesC))

 			{

 			if (token == _L("-r"))

 				{

 				token.Set(lex.NextToken());

 				if (token == KNullDesC ||

 					TLex(token).Val(RunLength) != KErrNone ||

 					RunLength < 0.0)

 					{

 					BadUsage();

 					ok = EFalse;

 					}

 				}

 			else if (token == _L("-m"))

 				{

 				categories = KCategoryMemory;

 				}

 			else if (token == _L("-x"))

 				{

 				categories = KCategoryGeneral | KCategoryExtra;

 				}

 			else

 				{

 				TInt index;

 				if (TLex(token).Val(index) != KErrNone)

 					{

 					BadUsage();

 					ok = EFalse;

 					}

 				else if (index < 0 || index >= count)

 					{

 					test.Printf(_L("Index out of range: %d\n"), index);

 					ok = EFalse;

 					}

 				else

 					{

 					testsToRun.AppendL(index);

 					}

 				}

 			}

 		}

 	CleanupStack::PopAndDestroy(buf);

 	if (ok)

 		{

 		test.Printf(_L("Note that these benchmarks are intended to guide optimisation, and not to\n"));

 		test.Printf(_L("provide a meaningful indication of the speed of specific functions\n"));

 		test.Printf(_L("\n"));

 		if (testsToRun.Count() == 0)

 			{

 			for (TInt i = 0 ; i < count ; ++i)

 				{				

 				RunBenchmarkL(aBenchmarks, i, categories);

 				}

 			}

 		else

 			{

 			for (TInt i = 0 ; i < testsToRun.Count() ; ++i)

 				{

 				RunBenchmarkL(aBenchmarks, testsToRun[i], categories);

 				}

 			}

 		}

 	CleanupStack::PopAndDestroy(&testsToRun);

 	}