// 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\d_kernbm.h

 // Kernel side header containg internal definitions for d_kernasmbm ldd

 // 

 //

 #ifndef __D_KERNBM_H__

 #define __D_KERNBM_H__

 #include "d_kernasmbm.h"

 /// Base class for kernel benchmarks

 class TKernelBenchmark

 	{

 public:

 	const TBmInfo& Info() const;

 	virtual TInt Run(const TBmParams& aParams, TInt& aResult);

 protected:

 	TKernelBenchmark(const TDesC8& aName);

 	TKernelBenchmark(const TDesC8& aName, TInt aAlignStep);

 private:

 	virtual void DoRun(const TBmParams& aParams) = 0;

 private:

 	TBmInfo iInfo;

 	};

 #define CALL_10_TIMES(x) x; x; x; x; x; x; x; x; x; x

 /// Macro to define a benchmark

 #define DEFINE_BENCHMARK(name, pre, test, post)                  \

 _LIT(KName_##name, #name);                                       \

 class TGeneralBenchmark_##name : public TKernelBenchmark         \

 	{                                                            \

 	public:                                                      \

 	TGeneralBenchmark_##name():TKernelBenchmark(KName_##name){}  \

 	virtual void DoRun(const TBmParams& aParams)                 \

 		{                                                        \

 		TInt its = aParams.iIts;                                 \

 		pre;                                                     \

 		for (TInt j = 0 ; j < its ; ++j)                         \

 			{                                                    \

 			CALL_10_TIMES(test);                                 \

 			}                                                    \

 		post;                                                    \

 		}                                                        \

 	} Instance_##name

 /// Macro to define a memory benchmark

 #define DEFINE_MEMORY_BENCHMARK(name, step, srcBase, destBase, pre, test, post) \

 _LIT(KName_##name, #name);                                       \

 class TMemoryBenchmark_##name : public TKernelBenchmark          \

 	{                                                            \

 public:                                                          \

 	TMemoryBenchmark_##name():                                   \

 		TKernelBenchmark(KName_##name, step){}                   \

 	virtual void DoRun(const TBmParams& aParams)                 \

 		{                                                        \

 		TInt its = aParams.iIts;                                 \

 		const TUint8* src = srcBase + aParams.iSourceAlign;      \

 		TUint8* dest = destBase + aParams.iDestAlign;            \

 		pre;                                                     \

 		for (TInt j = 0 ; j < its ; ++j)                         \

 			{                                                    \

 			CALL_10_TIMES(test);                                 \

 			}                                                    \

 		post;                                                    \

 		}                                                        \

 	} Instance_##name

 /// Base class for benchmarks using a second thread

 class TThreadedBenchmark : public TKernelBenchmark

 	{

 public:

 	virtual TInt Run(const TBmParams& aParams, TInt& aResult);

 protected:

 	TThreadedBenchmark(const TDesC8& aName, TInt aRelPri);

 private:

 	static TInt Thread2Func(TAny *aPtr);

 	virtual void DoRun2(TInt aIts) = 0;

 protected:

 	DThread* iThread1;

 	DThread* iThread2;

 private:

 	TInt iRelPri;

 	TInt iIts;

 	};

 /// Macro to define a thread benchmark easily

 #define DEFINE_THREADED_BENCHMARK(name, relPri, pre, test1, test2, post) \

 _LIT(KName_##name, #name);                                               \

 class TKernelBenchmark_##name : public TThreadedBenchmark                \

 	{                                                                    \

 public:                                                                  \

 	TKernelBenchmark_##name():TThreadedBenchmark(KName_##name, relPri){} \

 	virtual void DoRun(const TBmParams& aParams)                         \

 		{                                                                \

 		TInt its = aParams.iIts;                                         \

 		pre;                                                             \

 		for (TInt j = 0 ; j < its*10 ; ++j)                              \

 			{                                                            \

 			test1;                                                       \

 			}                                                            \

 		post;                                                            \

 		}                                                                \

 	virtual void DoRun2(TInt aIts)                                       \

 		{                                                                \

 		for (TInt j = 0 ; j < aIts*10 ; ++j)                             \

 			{                                                            \

 			test2;                                                       \

 			}                                                            \

 		}                                                                \

 	} Instance_##name

 /// Initialise data used by benchmarks

 TInt InitData();

 /// Clean up data used by benchmarks

 void CloseData();

 /// Pointer to user-side buffer, needed by some tests

 extern TUint8* UserPtr;

 /// List of defined benchmarks

 extern RPointerArray<TKernelBenchmark> KernelBenchmarks;

 /// Macro to 32-byte align addresses

 #define ALIGN_ADDR(a) ((TAny*)((((TInt)a) & ~0x1f) + 0x20))

 #endif