diff -r 000000000000 -r a41df078684a kerneltest/e32test/bench/d_kernbm.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/bench/d_kernbm.h	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,141 @@
+// 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