// Copyright (c) 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/mmu/t_shbuf_perf.cpp

 //

 //

 /**

  *  @file

  *

  *  Performance Testing of shared buffers.

  *

  *  Runs a number of tests using descriptors and RShBuf handles and compares

  *  the results to see the improvements in performance.

  */

 #define __E32TEST_EXTENSION__

 #include <e32def.h>

 #include <e32test.h>

 #include <e32debug.h>

 #include <e32msgqueue.h>

 #include <e32shbuf.h>

 #include <hal.h>

 #include <u32hal.h>

 #include <e32svr.h>

 #include "d_shbuf.h"

 #include "t_shbuf_perfclient.h"

 //

 // Test name (and process name!)...

 //

 _LIT(KTestProcessName, "T_SHBUF_PERF");

 /**

  *  Global test object (must be called 'test' to match some macros)...

  */

 RTest  test(KTestProcessName);

 //

 // Number of iterations to run for each test. The timings are worked out by

 // running the test X number of times and dividing the total time by X.

 //

 #ifdef _DEBUG

 /**

  *  Number of iterations to run for each test (WINS/WINSCW/Target Debug).

  */

 const TInt  KNumberOfIterations(50);      // Used for debuging and hence not measurement.

 #else

 #ifdef __WINS__

 /**

  *  Number of iterations to run for each test (WINS/WINSCW Release).

  */

 const TInt  KNumberOfIterations(5000);   // Proper emulator performance testing.

 #else

 /**

  *  Number of iterations to run for each test (Target Release).

  */

 const TInt  KNumberOfIterations(500);   // Proper target performance testing.

 #endif

 #endif

 TUint8  iClearCache[32768];

 /**

  *  RShBuf performance test types.

  */

 enum TRShBufPerfTest

 	{

 	/**

 	 *  Send buffer from the client to the driver directly and back.

 	 */

 	ERShBufPerfTestClientToDriverReturn,

 	/**

 	 *  Send buffer from the client to the driver directly one way.

 	 */

 	ERShBufPerfTestClientToDriverOneWay,

 	/**

 	 *  Send buffer from the client to a second process to the driver and back.

 	 */

 	ERShBufPerfTestClientToProcessToDriverReturn,

 	/**

 	 *  Send buffer from the client to a second process to the driver one way.

 	 */

 	ERShBufPerfTestClientToProcessToDriverOneWay,

 	/**

 	 *  Read buffer from the driver directly and send it back.

 	 */

 	ERShBufPerfTestDriverToClientReturn,

 	/**

 	 *  Read buffer from the driver directly one way.

 	 */

 	ERShBufPerfTestDriverToClientOneWay,

 	/**

 	 *  Read buffer from the driver via a second process and send it back.

 	 */

 	ERShBufPerfTestDriverToProcessToClientReturn,

 	/**

 	 *  Read buffer from the driver via a second process one way.

 	 */

 	ERShBufPerfTestDriverToProcessToClientOneWay

 	};

 void StartSecondProcessAndDriver(TRShBufPerfTest aTestType,

 								 RShBufTestChannel&  aLdd,

 								 RShBufTestServerSession& aTestServer,

 								 RThread& aTestServerThread,

 								 TInt aDriverNum)

 	{

 	//

 	// If a second process is needed start this process as a child...

 	//

 	if (aTestType == ERShBufPerfTestClientToProcessToDriverReturn  ||

 		aTestType == ERShBufPerfTestClientToProcessToDriverOneWay  ||

 		aTestType == ERShBufPerfTestDriverToProcessToClientReturn  ||

 		aTestType == ERShBufPerfTestDriverToProcessToClientOneWay)

 		{

 		test.Next(_L("Start slave server process..."));

 		test_KErrNone(aTestServer.Connect());

 		test.Next(_L("Find slave server thread..."));

 		test_KErrNone(aTestServerThread.Open(_L("t_shbuf_perf.exe[00000000]0001::!RShBufServer")));

 		}

 	//

 	// Open the driver (always open it as it is used to get buffers too!)...

 	//

 	TInt r = User::LoadLogicalDevice(_L("D_SHBUF_CLIENT.LDD"));

 	test(r == KErrNone || r == KErrAlreadyExists);

 	r = User::LoadLogicalDevice(_L("D_SHBUF_OWN.LDD"));

 	test(r == KErrNone || r == KErrAlreadyExists);

 	test_KErrNone(aLdd.Open(aDriverNum));

 	} // StartSecondProcessAndDriver

 void StopSecondProcessAndDriver(TRShBufPerfTest aTestType,

 								RShBufTestChannel&  aLdd,

 								RShBufTestServerSession& aTestServer,

 								RThread& aTestServerThread)

 	{

 	//

 	// Close the driver..

 	//

 	aLdd.Close();

 	if (aTestType == ERShBufPerfTestClientToProcessToDriverReturn  ||

 		aTestType == ERShBufPerfTestClientToProcessToDriverOneWay  ||

 		aTestType == ERShBufPerfTestDriverToProcessToClientReturn  ||

 		aTestType == ERShBufPerfTestDriverToProcessToClientOneWay)

 		{

 #ifdef CAN_TRANSFER_SHBUF_TO_ANOTHER_PROCESS

 		test.Next(_L("Stop slave server process..."));

 		test_KErrNone(aTestServer.ShutdownServer());

 #endif

 		aTestServerThread.Close();

 		aTestServer.Close();

 		}

 	} // StopSecondProcessAndDriver

 /**

  *  Print the TRShBufPerfTest enum.

  */

 void PrinTRShBufPerfTestType(const TDesC& aPrefix, TRShBufPerfTest aTestType)

 	{

 	switch (aTestType)

 		{

 		case ERShBufPerfTestClientToDriverReturn:

 			{

 			test.Printf(_L("%SaTestType=ERShBufPerfTestClientToDriverReturn (%d)"), &aPrefix, aTestType);

 			}

 			break;

 		case ERShBufPerfTestClientToDriverOneWay:

 			{

 			test.Printf(_L("%SaTestType=ERShBufPerfTestClientToDriverOneWay (%d)"), &aPrefix, aTestType);

 			}

 			break;

 		case ERShBufPerfTestClientToProcessToDriverReturn:

 			{

 			test.Printf(_L("%SaTestType=ERShBufPerfTestClientToProcessToDriverReturn (%d)"), &aPrefix, aTestType);

 			}

 			break;

 		case ERShBufPerfTestClientToProcessToDriverOneWay:

 			{

 			test.Printf(_L("%SaTestType=ERShBufPerfTestClientToProcessToDriverOneWay (%d)"), &aPrefix, aTestType);

 			}

 			break;

 		case ERShBufPerfTestDriverToClientReturn:

 			{

 			test.Printf(_L("%SaTestType=ERShBufPerfTestDriverToClientReturn (%d)"), &aPrefix, aTestType);

 			}

 			break;

 		case ERShBufPerfTestDriverToClientOneWay:

 			{

 			test.Printf(_L("%SaTestType=ERShBufPerfTestDriverToClientOneWay (%d)"), &aPrefix, aTestType);

 			}

 			break;

 		case ERShBufPerfTestDriverToProcessToClientReturn:

 			{

 			test.Printf(_L("%SaTestType=ERShBufPerfTestDriverToProcessToClientReturn (%d)"), &aPrefix, aTestType);

 			}

 			break;

 		case ERShBufPerfTestDriverToProcessToClientOneWay:

 			{

 			test.Printf(_L("%SaTestType=ERShBufPerfTestDriverToProcessToClientOneWay (%d)"), &aPrefix, aTestType);

 			}

 			break;

 		default:

 			{

 			test.Printf(_L("%SaTestType=<unknown> (%d)"), &aPrefix, aTestType);

 			}

 			break;

 		}

 	} // PrinTRShBufPerfTestType

 /**

  *  Print the TShPoolCreateInfo object.

  */

 void PrintTShPoolInfo(const TDesC& aPrefix, TShPoolInfo aShPoolInfo)

 	{

 	test.Printf(_L("%SaShPoolInfo.iBufSize=%d"), &aPrefix, aShPoolInfo.iBufSize);

 	test.Printf(_L("%SaShPoolInfo.iInitialBufs=%d"), &aPrefix, aShPoolInfo.iInitialBufs);

 	test.Printf(_L("%SaShPoolInfo.iMaxBufs=%d"), &aPrefix, aShPoolInfo.iMaxBufs);

 	test.Printf(_L("%SaShPoolInfo.iGrowTriggerRatio=%d"), &aPrefix, aShPoolInfo.iGrowTriggerRatio);

 	test.Printf(_L("%SaShPoolInfo.iGrowByRatio=%d"), &aPrefix, aShPoolInfo.iGrowByRatio);

 	test.Printf(_L("%SaShPoolInfo.iShrinkHysteresisRatio=%d"), &aPrefix, aShPoolInfo.iShrinkHysteresisRatio);

 	test.Printf(_L("%SaShPoolInfo.iAlignment=%d (0x%x)"), &aPrefix, aShPoolInfo.iAlignment,

 				2 << (aShPoolInfo.iAlignment - 1));

 	test.Printf(_L("%SaShPoolInfo.iFlags=0x%08x"), &aPrefix, aShPoolInfo.iFlags);

 	} // PrintTShPoolInfo

 void TestSharedBufferPerformanceL(TRShBufPerfTest aTestType,

 								  TInt aMinAllocSize, TInt aMaxAllocSize,

 								  TInt aBufferSizeSteps,  TInt aTotalIterations,

 								  TShPoolCreateFlags aFlags, TInt aDriverNum,

 								  TDes& aSummaryBuf)

 	{

 	TShPoolInfo  shPoolInfo;

     shPoolInfo.iBufSize               = aMaxAllocSize;

     shPoolInfo.iInitialBufs           = 5;

 	shPoolInfo.iMaxBufs               = 5;

 	shPoolInfo.iGrowTriggerRatio      = 0;

 	shPoolInfo.iGrowByRatio           = 0;

 	shPoolInfo.iShrinkHysteresisRatio = 0;

 	shPoolInfo.iAlignment             = 9;

 	shPoolInfo.iFlags                 = aFlags;

 	//

 	// Start test and print the parameters...

 	//

 	test.Printf(_L(" Test parameters:"));

 	PrinTRShBufPerfTestType(_L("  "), aTestType);

 	PrintTShPoolInfo(_L("  "), shPoolInfo);

 	test.Printf(_L("  aMinAllocSize=%d"), aMinAllocSize);

 	test.Printf(_L("  aMaxAllocSize=%d"), aMaxAllocSize);

 	test.Printf(_L("  aBufferSizeSteps=%d"), aBufferSizeSteps);

 	test.Printf(_L("  aTotalIterations=%d"), aTotalIterations);

 	test.Printf(_L("  aDriverNum=%d"), aDriverNum);

 	//

 	// Initialise second process and/or open the driver...

 	//

 	RShBufTestServerSession  testServer;

 	RShBufTestChannel  shBufLdd;

 	RThread  testServerThread;

 	StartSecondProcessAndDriver(aTestType, shBufLdd, testServer, testServerThread, aDriverNum);

 	CleanupClosePushL(testServer);

 	//

 	// Allocate a RShPool...

 	//

 	RShPool  shPool;

 	if (aFlags & EShPoolPageAlignedBuffer)

 		{

 		TShPoolCreateInfo  shPoolCreateInfo(TShPoolCreateInfo::EPageAlignedBuffer,

 		                                    shPoolInfo.iBufSize, shPoolInfo.iInitialBufs);

 		test_KErrNone(shPool.Create(shPoolCreateInfo, KDefaultPoolHandleFlags));

 		CleanupClosePushL(shPool);

 		test_KErrNone(shPool.SetBufferWindow(-1, ETrue));

 		shPoolInfo.iAlignment = 12;

 		}

 	else if (aFlags & EShPoolNonPageAlignedBuffer)

 		{

 		TShPoolCreateInfo  shPoolCreateInfo(TShPoolCreateInfo::ENonPageAlignedBuffer,

 		                                    shPoolInfo.iBufSize, shPoolInfo.iInitialBufs,

 				                            shPoolInfo.iAlignment);

 		test_KErrNone(shPool.Create(shPoolCreateInfo, KDefaultPoolHandleFlags));

 		CleanupClosePushL(shPool);

 		}

 	test(shPool.Handle() != 0);

 	if (aTestType == ERShBufPerfTestClientToProcessToDriverReturn  ||

 		aTestType == ERShBufPerfTestClientToProcessToDriverOneWay  ||

 		aTestType == ERShBufPerfTestDriverToProcessToClientReturn  ||

 		aTestType == ERShBufPerfTestDriverToProcessToClientOneWay)

 		{

 		test_KErrNone(testServer.OpenRShBufPool(shPool.Handle(), shPoolInfo));

 		}

 	else

 		{

 		test_KErrNone(shBufLdd.OpenUserPool(shPool.Handle(), shPoolInfo));

 		}

 	//

 	// Run the test iterations and time the result...

 	//

 	TInt fastTimerFreq;

 	HAL::Get(HALData::EFastCounterFrequency, fastTimerFreq);

 	TReal ticksPerMicroSec = 1.0E-6 * fastTimerFreq;

 	// Bind this thread to CPU 0. This is so that timer deltas don't drift from

 	// scheduling - else, it causes spurious failures.

     if (UserSvr::HalFunction(EHalGroupKernel, EKernelHalNumLogicalCpus, 0, 0) > 1)

 	   (void)UserSvr::HalFunction(EHalGroupKernel, EKernelHalLockThreadToCpu, (TAny *)0, 0);

 	TReal64  totalLengthOfDesTest(0);

 	TReal64  totalLengthOfShBufTest(0);

 	TInt  breakevenPoint = 0;

 	TInt  bufferStep;

 	test.Printf(_L("BufSize\tTotalTime(Des)\tAvTime(Des)\tTotalTime(ShBuf)\tAvTime(ShBuf)\tSpeedUp(%%)"));

 #ifndef __WINS__

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

 #endif

 	for (bufferStep = 0;  bufferStep < aBufferSizeSteps;  bufferStep++)

 		{

 		//

 		// Run a single buffer size through these tests...

 		//

 		TInt  bufferSize = aMinAllocSize +

 						   (((aMaxAllocSize - aMinAllocSize) * bufferStep) / (aBufferSizeSteps-1));

 		TUint32  startDesTest = 0;

 		TUint32 startShBufTest = 0;

 		TInt  iteration;

 		TUint32  lengthOfDesTest=0;

 		//

 		// Test normal descriptor methods first...

 		//

 		for (iteration = 0;  iteration < aTotalIterations;  iteration++)

 			{

 			//

 			// Allocate a local buffer for this test...

 			//

 			HBufC8*  singleBuf = HBufC8::NewLC(bufferSize);

 			startDesTest = User::FastCounter();

 			test(singleBuf != NULL);

 			TPtr8 singleBufPtr = singleBuf->Des();

 			singleBufPtr.SetLength(bufferSize);

 			//

 			// Are we sending or receiving?

 			//

 			if (aTestType == ERShBufPerfTestClientToDriverOneWay  ||

 				aTestType == ERShBufPerfTestClientToProcessToDriverOneWay)

 				{

 #ifdef _DEBUG // do not cache

 				TUint8* bufptr = const_cast<TUint8*>(singleBuf->Ptr());

 				// We are sending...

 				for (TInt pos = 0;  pos < bufferSize;  pos++)

 					{

 					bufptr[pos] = (TUint8)(pos%32);

 					}

 				// clear cache

 				memset(iClearCache, 0xFF, sizeof(iClearCache));

 #endif

 				}

 			//

 			// Either send to the driver or to the other process...

 			//

 			if (aTestType == ERShBufPerfTestClientToDriverReturn)

 				{

 				test_KErrNone(shBufLdd.FromTPtr8ProcessAndReturn(singleBufPtr, bufferSize));

 				test(singleBufPtr.Length() == bufferSize-2);

 				}

 			else if (aTestType == ERShBufPerfTestClientToDriverOneWay)

 				{

 				test_KErrNone(shBufLdd.FromTPtr8ProcessAndRelease(singleBufPtr));

 				}

 			else if (aTestType == ERShBufPerfTestClientToProcessToDriverReturn)

 				{

 				test_KErrNone(testServer.FromTPtr8ProcessAndReturn(singleBufPtr, bufferSize));

 				test(singleBufPtr.Length() == bufferSize-2);

 				}

 			else if (aTestType == ERShBufPerfTestClientToProcessToDriverOneWay)

 				{

 				test_KErrNone(testServer.FromTPtr8ProcessAndRelease(singleBufPtr));

 				}

 			lengthOfDesTest += (User::FastCounter() - startDesTest);

 			CleanupStack::PopAndDestroy(singleBuf);

 			}

 		TInt64  lengthOfShBufTest = 0;

 		//

 		// Test ShBuf methods...

 		//

 		for (iteration = 0;  iteration < aTotalIterations;  iteration++)

 			{

 			RShBuf  shBuf;

 			TInt*  lengthPtr;

 			//

 			// Are we sending or receiving?

 			//

 			startShBufTest = User::FastCounter();

 			if (aTestType == ERShBufPerfTestClientToDriverOneWay ||

 				aTestType == ERShBufPerfTestClientToProcessToDriverOneWay)

 				{

 				// We are sending...

 				//

 				// Allocate a buffer (using a pool)...

 				//

 				test_KErrNone(shBuf.Alloc(shPool));

 				TUint8*  shBufPtr = shBuf.Ptr();

 				lengthPtr = (TInt*)(&shBufPtr[0]); // First 32bit word is length!

 				*lengthPtr = bufferSize;

 #ifdef _DEBUG // do not cache

 				for (TInt pos = 4;  pos < bufferSize;  pos++)

 					{

 					shBufPtr[pos] = (TUint8)(pos%32);

 					}

 				// clear cache

 				memset(iClearCache, 0xFF, sizeof(iClearCache));

 #endif

 				}

 			//

 			// Either send to the driver or to the other process...

 			//

 			if (aTestType == ERShBufPerfTestClientToDriverReturn)

 				{

 				TInt retHandle;

 				retHandle = shBufLdd.FromRShBufProcessAndReturn(bufferSize);

 				test_Compare(retHandle, >, 0);

 				shBuf.SetReturnedHandle(retHandle);

 				TInt* retPtr = (TInt*)shBuf.Ptr();

 				test(*retPtr == bufferSize-2);

 				shBuf.Close();

 				}

 			else if (aTestType == ERShBufPerfTestClientToDriverOneWay)

 				{

 				test_KErrNone(shBufLdd.FromRShBufProcessAndRelease(shBuf.Handle()));

 				}

 			else if (aTestType == ERShBufPerfTestClientToProcessToDriverReturn)

 				{

 				test_KErrNone(testServer.FromRShBufProcessAndReturn(shBuf, bufferSize));

 				TInt* retPtr = (TInt*)shBuf.Ptr();

 				test(*retPtr == bufferSize-2);

 				shBuf.Close();

 				}

 			else if (aTestType == ERShBufPerfTestClientToProcessToDriverOneWay)

 				{

 				test_KErrNone(testServer.FromRShBufProcessAndRelease(shBuf));

 				}

 			lengthOfShBufTest +=  (User::FastCounter() - startShBufTest);

 			}

 		//

 		// Print results of this buffer size...

 		//

 		test.Printf(_L("%d\t%10.2lfusec\t%10.2lfusec\t%.2f%%"), bufferSize,

 					I64REAL(lengthOfDesTest) / (TReal(aTotalIterations) * ticksPerMicroSec),

 					I64REAL(lengthOfShBufTest) / (TReal(aTotalIterations) * ticksPerMicroSec),

 					((100.0 / I64REAL(lengthOfShBufTest)) * I64REAL(lengthOfDesTest)) - 100.0);

 #ifndef __WINS__

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

 #endif

 		totalLengthOfDesTest   += lengthOfDesTest;

 		totalLengthOfShBufTest += lengthOfShBufTest;

 		//

 		// Track the breakeven point (e.g. the buffer size at which RShBuf is

 		// quicker). This is normally when the number of bytes copied by the

 		// descriptor takes longer than the handling of the RShBuf.

 		//

 		if (lengthOfShBufTest >= lengthOfDesTest)

 			{

 			breakevenPoint = aMinAllocSize +

 						   (((aMaxAllocSize - aMinAllocSize) * (bufferStep + 1)) / (aBufferSizeSteps-1));

 			}

 		}

 	//

 	// Display timing information...

 	//

 	test.Printf(_L("Average\t%10.2lfusec\t%10.2lfusec\t%.2f%%"),

 				I64REAL(totalLengthOfDesTest) / (TReal(aTotalIterations * aBufferSizeSteps) * ticksPerMicroSec),

 				I64REAL(totalLengthOfShBufTest) / (TReal(aTotalIterations * aBufferSizeSteps) * ticksPerMicroSec),

 				((100.0 / I64REAL(totalLengthOfShBufTest)) * I64REAL(totalLengthOfDesTest)) - 100.0);

 #ifndef __WINS__

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

 #endif

 	//

 	// Record summary info for later use...

 	//

 	aSummaryBuf.Zero();

 	if (breakevenPoint <= aMaxAllocSize)

 		{

 		aSummaryBuf.AppendFormat(_L("%10.2lfusec\t%10.2lfusec\t%.2f%%%%\t%d"),

 								 I64REAL(totalLengthOfDesTest) / TReal(aTotalIterations * aBufferSizeSteps * ticksPerMicroSec),

 								 I64REAL(totalLengthOfShBufTest) / TReal(aTotalIterations * aBufferSizeSteps * ticksPerMicroSec),

 								 ((100.0 / I64REAL(totalLengthOfShBufTest)) * I64REAL(totalLengthOfDesTest)) - 100.0,

 								 breakevenPoint);

 		}

 	else

 		{

 		aSummaryBuf.AppendFormat(_L("%10.2lfusec\t%10.2lfusec\t%.2f%%%%\tFailed to breakeven"),

 								 I64REAL(totalLengthOfDesTest) / TReal(aTotalIterations * aBufferSizeSteps * ticksPerMicroSec),

 								 I64REAL(totalLengthOfShBufTest) / TReal(aTotalIterations * aBufferSizeSteps * ticksPerMicroSec),

 								 ((100.0 / I64REAL(totalLengthOfShBufTest)) * I64REAL(totalLengthOfDesTest)) - 100.0);

 		}

 	//

 	// Clean up...

 	//

 	TInt  shPoolHandle = shPool.Handle();

 	CleanupStack::PopAndDestroy(&shPool);

 	if (aTestType == ERShBufPerfTestClientToProcessToDriverReturn  ||

 		aTestType == ERShBufPerfTestClientToProcessToDriverOneWay  ||

 		aTestType == ERShBufPerfTestDriverToProcessToClientReturn  ||

 		aTestType == ERShBufPerfTestDriverToProcessToClientOneWay)

 		{

 		testServer.CloseRShBufPool(shPoolHandle);

 		}

 	else

 		{

 		test_KErrNone(shBufLdd.CloseUserPool());

 		}

 	//

 	// Shutdown the second process and/or close the driver.

 	//

 	CleanupStack::Pop(&testServer);

 	StopSecondProcessAndDriver(aTestType, shBufLdd, testServer, testServerThread);

 	} // TestSharedBufferPerformanceL

 /**

  *  Main test process which performs the testing.

  */

 void RunTestsL()

 	{

 	//

 	// Setup the test...

 	//

 	test.Title();

 	test.Start(_L("Check for Shared Buffers availability"));

 	TInt r;

 	RShPool pool;

 	TShPoolCreateInfo inf(TShPoolCreateInfo::EPageAlignedBuffer, 100, 10);

 	r = pool.Create(inf, KDefaultPoolHandleFlags);

 	if (r == KErrNotSupported)

 		{

 		test.Printf(_L("Not supported by this memory model.\n"));

 		}

 	else

 		{

 		test_KErrNone(r);

 		pool.Close();

 		test.Next(_L("Performance test shared buffers"));

 		//

 		// Create a summary buffer to hold the average speeds of different pools...

 		//

 		HBufC*  summaryBuf = HBufC::NewLC(16 * 128 * 2);

 		TPtr  summaryBufPtr = summaryBuf->Des();

 		TBuf<128>  testName, testSummary;

 		summaryBufPtr.Append(_L("Test Type\tAverage Time(Des)\tAverage Time(ShBuf)\tAverage SpeedUp(%%)\tBreakeven Buffer Size\n"));

 		//

 		// Run tests...

 		//

 		testName.Copy(_L("Client->Driver (non-aligned/client-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToDriverOneWay,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolNonPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EClientThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Driver (aligned/client-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToDriverOneWay,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EClientThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Driver (non-aligned/own-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToDriverOneWay,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolNonPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EOwnThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Driver (aligned/own-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToDriverOneWay,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EOwnThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Driver->Client (non-aligned/client-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			ERShBufPerfTestClientToDriverReturn,

 			/* Min Alloc size */	64,

 			/* Max Alloc size */	8192,

 			/* Buffer size steps */	128,

 			/* Total iterations */	KNumberOfIterations,

 			/* Buffer flags */      EShPoolNonPageAlignedBuffer,

 			/* Driver to use */     RShBufTestChannel::EClientThread,

 			/* Summary string */    testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Driver->Client (aligned/client-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToDriverReturn,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EClientThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Driver->Client (non-aligned/own-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToDriverReturn,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolNonPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EOwnThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Driver->Client (aligned/own-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToDriverReturn,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EOwnThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Process->Driver (non-aligned/client-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToProcessToDriverOneWay,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolNonPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EClientThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Process->Driver (aligned/client-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToProcessToDriverOneWay,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EClientThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Process->Driver (non-aligned/own-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToProcessToDriverOneWay,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolNonPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EOwnThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Process->Driver (aligned/own-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToProcessToDriverOneWay,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EOwnThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Process->Driver->Process->Client (non-aligned/client-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToProcessToDriverReturn,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolNonPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EClientThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Process->Driver->Process->Client (aligned/client-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToProcessToDriverReturn,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EClientThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Process->Driver->Process->Client (non-aligned/own-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			 ERShBufPerfTestClientToProcessToDriverReturn,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolNonPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EOwnThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		testName.Copy(_L("Client->Process->Driver->Process->Client (aligned/own-thread)"));

 		test.Next(testName);

 		TestSharedBufferPerformanceL(

 			/* Test type */			ERShBufPerfTestClientToProcessToDriverReturn,

 			/* Min Alloc size */	 64,

 			/* Max Alloc size */	 8192,

 			/* Buffer size steps */	 128,

 			/* Total iterations */	 KNumberOfIterations,

 			/* Buffer flags */       EShPoolPageAlignedBuffer,

 			/* Driver to use */      RShBufTestChannel::EOwnThread,

 			/* Summary string */     testSummary);

 		summaryBufPtr.AppendFormat(_L("%S\t%S\n"), &testName, &testSummary);

 		//

 		// Print the summary...

 		//

 		TInt  nextLineBreak = summaryBufPtr.Find(_L("\n"));

 		test.Next(_L("Results summary (average values for each test)"));

 		while (nextLineBreak != KErrNotFound)

 			{

 			test.Printf(summaryBufPtr.Left(nextLineBreak));

 #ifndef __WINS__

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

 #endif

 			summaryBufPtr = summaryBufPtr.Mid(nextLineBreak+1);

 			nextLineBreak = summaryBufPtr.Find(_L("\n"));

 			}

 		CleanupStack::PopAndDestroy(summaryBuf);

 		}

 	test.End();

 	test.Close();

 	} // RunTestsL

 /**

  *  Main entry point.

  */

 TInt E32Main()

 	{

 	//

 	// Allocate a clean up stack and top level TRAP...

 	//

 	__UHEAP_MARK;

 	CTrapCleanup*  cleanup = CTrapCleanup::New();

 	TInt  err = KErrNoMemory;

 	if (cleanup)

 		{

 		TRAP(err, RunTestsL());

         delete cleanup;

 		}

 	__UHEAP_MARKEND;

 	return err;

 	} // E32Main