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