diff -r 000000000000 -r 5d03bc08d59c graphicstest/uibench/src/tfbsbitmaphandleperf.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicstest/uibench/src/tfbsbitmaphandleperf.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,286 @@ +// 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 "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: +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include "tfbsbitmaphandleperf.h" + +const TInt KIterationsToTest = 1000; +const TInt KMaxNumSmallTestBitmaps = 40; +const TInt KMaxNumLargeTestBitmaps = 4; +const TInt KNumTestBitmapSizes = 8; +const TDisplayMode KTestDisplayMode = EColor256; +const TDisplayMode KTestDisplayMode2 = EColor64K; + + +CTFbsBitmapHandlePerf::CTFbsBitmapHandlePerf() + { + SetTestStepName(KTFbsBitmapHandlePerfName); + } + +CTFbsBitmapHandlePerf::~CTFbsBitmapHandlePerf() + { + iTestBitmaps.ResetAndDestroy(); + } + +/** +Override of base class pure virtual +Our implementation only gets called if the base class doTestStepPreambleL() did +not leave. That being the case, the current test result value will be EPass. + +@return - TVerdict code +*/ +TVerdict CTFbsBitmapHandlePerf::doTestStepL() + { + SetTestStepID(_L("GRAPHICS-UI-BENCH-0074")); + SmallBitmapCreationL(KTestDisplayMode, _L("Small Bitmap-Create")); //8 bit + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0006")); + LargeBitmapCreationL(KTestDisplayMode, _L("Large Bitmap-Create")); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0087")); + SmallBitmapCreationSimpleL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0088")); + LargeBitmapCreationSimpleL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0007")); + BitmapDuplicateL(); + RecordTestResultL(); + return TestStepResult(); + } + +/** +Creates and destroys bitmaps KIterationsToTest times with various sizes +using a pseudo-random sequence to try to simulate real usage patterns. + +@param aSizes Array of KNumTestBitmapSizes sizes to create bitmaps with. +@param aMaxNumBitmaps Maximum number of created but not yet deleted bitmaps at any given time. +@param aDisplayMode The display mode to create bitmaps with. +*/ +void CTFbsBitmapHandlePerf::BitmapCreationL(const TSize aSizes[], TInt aMaxNumBitmaps, const TDisplayMode aDisplayMode) + { + TInt64 seed = 0; + iProfiler->InitResults(); + for (TInt count = KIterationsToTest; count > 0; --count) + { + CFbsBitmap* bitmap = new(ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + TInt err = bitmap->Create(aSizes[count % KNumTestBitmapSizes], aDisplayMode); + User::LeaveIfError(err); + iTestBitmaps.AppendL(bitmap); + CleanupStack::Pop(bitmap); + if (iTestBitmaps.Count() >= aMaxNumBitmaps) + { + TInt i = Math::Rand(seed) % aMaxNumBitmaps; + delete iTestBitmaps[i]; + iTestBitmaps.Remove(i); + } + iProfiler->MarkResultSetL(); + } + iTestBitmaps.ResetAndDestroy(); + } + +/** +Creates and destroys bitmaps of the same size KIterationsToTest times. + +@param aWidth The width of the created bitmaps. +@param aHeight The height of the created bitmaps. +@param aDisplayMode The display mode to create bitmaps with. +@param aTestDescription The description of the test. +*/ +void CTFbsBitmapHandlePerf::BitmapCreationSimpleL(const TInt aWidth, const TInt aHeight, const TDisplayMode aDisplayMode, const TDesC& aTestDescription) + { + iProfiler->InitResults(); + for (TInt count = KIterationsToTest; count > 0; --count) + { + CFbsBitmap bitmap; + TInt err = bitmap.Create(TSize(aWidth, aHeight), aDisplayMode); + User::LeaveIfError(err); + iProfiler->MarkResultSetL(); + } + iProfiler->ResultsAnalysis(aTestDescription, aDisplayMode, 0, 0, KIterationsToTest); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0074 + +@SYMTestCaseDesc +The test determines how long it takes to create and destroy small bitmap objects. + +@SYMTestActions +Compare the results over time, and before and after changes to bitmap construction and destruction code. + +@SYMTestExpectedResults +Test should pass and display total test time and time per bitmap + +@param aDisplayMode The display mode to create bitmaps with. +@param aTestDescription The description of the test. +*/ +void CTFbsBitmapHandlePerf::SmallBitmapCreationL(const TDisplayMode aDisplayMode, const TDesC& aTestDescription) + { + // width X height X bytes per pixel < KMaxLargeBitmapAlloc (16KB as of writing) + const TSize KSmallSizes[KNumTestBitmapSizes] = + { + TSize(20, 20), // 1st + TSize(22, 22), // 2nd + TSize(24, 24), // 3rd + TSize(28, 28), // 4th + TSize(32, 32), // 5th + TSize(40, 40), // 6th + TSize(48, 48), // 7th + TSize(60, 60) // 8th + }; + BitmapCreationL(KSmallSizes, KMaxNumSmallTestBitmaps, aDisplayMode); + iProfiler->ResultsAnalysis(aTestDescription, aDisplayMode, 0, 0, KIterationsToTest); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0006 + +@SYMTestCaseDesc +The test determines how long it takes to create and destroy large bitmap objects. + +@SYMTestActions +Compare the results over time, and before and after changes to bitmap construction and destruction code. + +@SYMTestExpectedResults +Test should pass and display total test time and time per bitmap + +@param aDisplayMode The display mode to create bitmaps with. +@param aTestDescription The description of the test. +*/ +void CTFbsBitmapHandlePerf::LargeBitmapCreationL(const TDisplayMode aDisplayMode, const TDesC& aTestDescription) + { + // width X height X bytes per pixel > KMaxLargeBitmapAlloc (16KB as of writing) + const TSize KLargeSizes[KNumTestBitmapSizes] = + { + TSize(200, 200), // 1st + TSize(220, 220), // 2nd + TSize(240, 240), // 3rd + TSize(280, 280), // 4th + TSize(320, 320), // 5th + TSize(400, 400), // 6th + TSize(480, 480), // 7th + TSize(600, 600) // 8th + }; + BitmapCreationL(KLargeSizes, KMaxNumLargeTestBitmaps, aDisplayMode); + iProfiler->ResultsAnalysis(aTestDescription, aDisplayMode, 0, 0, KIterationsToTest); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0007 + +@SYMTestCaseDesc +Tests how long it takes to duplicate a bitmap + +@SYMTestActions +Compare the results over time, and before and after changes to bitmap duplication code. + +@SYMTestExpectedResults +Test should pass and display total test time and time per bitmap +*/ +void CTFbsBitmapHandlePerf::BitmapDuplicateL() + { + + TSize size(200,200); + TInt err; + + RArray handles; + RPointerArray bitmapArray; + CleanupClosePushL(bitmapArray); + + // Create bitmaps for each display mode and store in array + for(TInt count=KNumValidBitmapModes-1; count>=0; --count) + { + CFbsBitmap* bitmap=new(ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + TDisplayMode mode = KValidBitmapModes[count]; + err = bitmap->Create(size, mode); + User::LeaveIfError(err); + User::LeaveIfError(bitmapArray.Append(bitmap)); + CleanupStack::Pop(bitmap); + User::LeaveIfError(handles.Append(bitmap->Handle())); + } + + // Duplicate each bitmap in the array and measure performance + iProfiler->InitResults(); + for(TInt count=KIterationsToTest; count>=0; --count) + { + CFbsBitmap* duplicateBitmap=new (ELeave) CFbsBitmap; + CleanupStack::PushL(duplicateBitmap); + TInt hn=count%KNumValidBitmapModes; + TInt handle=handles[hn]; + err=duplicateBitmap->Duplicate(handle); + User::LeaveIfError(err); + CleanupStack::PopAndDestroy(duplicateBitmap); + iProfiler->MarkResultSetL(); + } + iProfiler->ResultsAnalysis(_L("Bitmap-Duplicate"), 0, 0, 0, KIterationsToTest); + + handles.Reset(); + + bitmapArray.ResetAndDestroy(); + CleanupStack::PopAndDestroy(&bitmapArray); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0087 + +@SYMTestCaseDesc +The test determines how long it takes to create and destroy small simple bitmap objects. + +@SYMTestActions +Compare the results over time, and before and after changes to bitmap construction and destruction code. + +@SYMTestExpectedResults +Test should pass and display total test time and time per bitmap + +@param aDisplayMode The display mode to create bitmaps with. +@param aTestDescription The description of the test. +*/ +void CTFbsBitmapHandlePerf::SmallBitmapCreationSimpleL() + { + BitmapCreationSimpleL(32, 32, KTestDisplayMode2, _L("Small Bitmap-Create-64K-Simple")); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0088 + +@SYMTestCaseDesc +The test determines how long it takes to create and destroy large simple bitmap objects. + +@SYMTestActions +Compare the results over time, and before and after changes to bitmap construction and destruction code. + +@SYMTestExpectedResults +Test should pass and display total test time and time per bitmap + +@param aDisplayMode The display mode to create bitmaps with. +@param aTestDescription The description of the test. +*/ +void CTFbsBitmapHandlePerf::LargeBitmapCreationSimpleL() + { + BitmapCreationSimpleL(500, 500, KTestDisplayMode2, _L("Large Bitmap-Create-64K-Simple")); + }