// 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