diff -r 000000000000 -r a41df078684a kerneltest/e32test/bench/t_userasmfnc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/bench/t_userasmfnc.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,520 @@ +// 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\t_userasmfnc.cpp +// +// + +#include "t_userbm.h" +#include +#include +#include +#include +#include +#include +#include + +TBool PointsEqual(const TPoint& a, const TPoint& b) + { + return a.iX == b.iX && a.iY == b.iY; + } + +TInt ComparePoints(const TPoint& a, const TPoint& b) + { + if (a.iX < b.iX) + return -1; + else if (a.iX > b.iX) + return 1; + else if (a.iY < b.iY) + return -1; + else + return a.iY < b.iY; + } + +RArray ArrayTInt; // RArrayPointerBase derived +RArray ArrayTUint; // RArrayPointerBase derived +RPointerArray ArrayTPointPtr; +RArray ArrayTPoint; + +TPoint Point(6, 13); +TIdentityRelation PointIdentity(PointsEqual); +TLinearOrder PointOrder(ComparePoints); + +CObjectConIx* ObjectConIx; +CObjectIx* ObjectIx; +CObjectCon* ObjectCon; +TInt ObjectHandle; + +TUint32 HuffmanTable[] = { 0, 1, 3, 8, 10, 3, 1, 0 }; +TBitInput BitInput; +TUint8 BitData[] = { 0, 0, 0, 0 }; + +RRegion Region, Region2, Region3; +TRect Rect1(20, 20, 40, 40); + +SPoly* Poly; +TRealX PolyXCoeffs[] = { 1.0, 3.0, 5.0 }; + +RHeap* Heap; +const TInt HeapSize = 32768; +const TInt SmallAlloc = 4; +const TInt Allocs = HeapSize / 2 / (SmallAlloc + RHeap::EAllocCellSize) / 2 * 2; + +void InitDataL() + { + TInt array1Data[] = { 1, 2, 3, 5, 7, 11, 13, 17, 23 }; + for (TUint i = 0 ; i < sizeof(array1Data) / sizeof(TInt) ; ++i) + { + User::LeaveIfError(ArrayTInt.Append(array1Data[i])); + User::LeaveIfError(ArrayTUint.Append(array1Data[i])); + TPoint* p = new (ELeave) TPoint(i, array1Data[i]); + CleanupStack::PushL(p); + User::LeaveIfError(ArrayTPointPtr.Append(p)); + CleanupStack::Pop(p); + User::LeaveIfError(ArrayTPoint.Append(*p)); + } + + ObjectConIx = CObjectConIx::NewL(); + ObjectCon = ObjectConIx->CreateL(); + ObjectIx = CObjectIx::NewL(); + CObject* o = new (ELeave) CObject; + ObjectCon->AddL(o); + ObjectHandle = ObjectIx->AddL(o); + + Huffman::HuffmanL(HuffmanTable, sizeof(HuffmanTable) / sizeof(TUint32), HuffmanTable); + Huffman::Decoding(HuffmanTable, sizeof(HuffmanTable) / sizeof(TUint32), HuffmanTable); + + Region.AddRect(TRect(10, 10, 30, 30)); + Region.AddRect(TRect(30, 20, 50, 50)); + Region.AddRect(TRect(10, 50, 50, 60)); + + Region2.AddRect(TRect(0, 40, 100, 60)); + Region2.AddRect(TRect(40, 0, 60, 100)); + Region2.AddRect(TRect(30, 30, 70, 70)); + + Region3.AddRect(TRect(0, 30, 100, 40)); + Region3.AddRect(TRect(0, 0, 100, 10)); + Region3.AddRect(TRect(0, 20, 100, 30)); + Region3.AddRect(TRect(0, 10, 100, 20)); + Region3.AddRect(TRect(0, 40, 100, 50)); + + Poly = (SPoly*) User::AllocL(sizeof(SPoly) + (3 - 1) * sizeof(TReal)); + Poly->num = 3; + Poly->c[0] = 3; + Poly->c[1] = 6; + Poly->c[2] = 9; + + Heap = (RHeap*)User::LeaveIfNull(UserHeap::ChunkHeap(NULL, HeapSize, HeapSize)); + TInt x; + TAny* cells[Allocs]; + for (x=0; xAlloc(4); + for (x=0; xFree(cells[x]); + } + +// Define benchmarks for assembler-coded euser functions. Note that these are +// named after the function we're trying to test, which is not necessarily the +// one we call. + +// RPointerArrayBase +DEFINE_USER_BENCHMARK(RPointerArrayBase_At, + , + ArrayTInt[4]); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_Append, + RArray a, + a.Reset(); a.Append(1)); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_Find1, + , + ArrayTInt.Find(5)); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_Find2, + , + ArrayTPointPtr.Find(&Point, PointIdentity)); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_BinarySearchSigned, + TInt i, + ArrayTInt.SpecificFindInOrder(13, i, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_BinarySearchUnsigned, + TInt i, + ArrayTUint.SpecificFindInOrder(13, i, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_BinarySearch, + , + ArrayTPointPtr.SpecificFindInOrder(&Point, PointOrder, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_FindIsqSigned, + , + ArrayTInt.SpecificFindInOrder(5, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_FindIsqUnsigned, + , + ArrayTUint.SpecificFindInOrder(5, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_FindIsq, + , + ArrayTPointPtr.SpecificFindInOrder(&Point, PointOrder, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_HeapSortSigned, + , + ArrayTInt.Sort()); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_HeapSortUnsigned, + , + ArrayTUint.Sort()); + +DEFINE_USER_BENCHMARK(RPointerArrayBase_HeapSort, + , + ArrayTPointPtr.Sort(PointOrder)); + +// RArrayBase +DEFINE_USER_BENCHMARK(RArrayBase_At, + , + ArrayTPoint[4]); + +DEFINE_USER_BENCHMARK(RArrayBase_Append, + RArray a, + a.Reset(); a.Append(Point)); + +DEFINE_USER_BENCHMARK(RArrayBase_Find1, + , + ArrayTPoint.Find(Point)); + +DEFINE_USER_BENCHMARK(RArrayBase_Find2, + , + ArrayTPoint.Find(Point, PointIdentity)); + +DEFINE_USER_BENCHMARK(RArrayBase_BinarySearchSigned, + TInt i, + ArrayTPoint.SpecificFindInSignedKeyOrder(Point, i, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RArrayBase_BinarySearchUnsigned, + TInt i, + ArrayTPoint.SpecificFindInUnsignedKeyOrder(Point, i, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RArrayBase_BinarySearch, + TInt i, + ArrayTPoint.FindInOrder(Point, i, PointOrder)); + +DEFINE_USER_BENCHMARK(RArrayBase_FindIsqSigned, + , + ArrayTPoint.SpecificFindInSignedKeyOrder(Point, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RArrayBase_FindIsqUnsigned, + , + ArrayTPoint.SpecificFindInUnsignedKeyOrder(Point, EArrayFindMode_Any)); + +DEFINE_USER_BENCHMARK(RArrayBase_HeapSortSigned, + , + ArrayTPoint.SortSigned()); + +DEFINE_USER_BENCHMARK(RArrayBase_HeapSortUnsigned, + , + ArrayTPoint.SortUnsigned()); + +DEFINE_USER_BENCHMARK(RArrayBase_HeapSort, + , + ArrayTPointPtr.Sort(PointOrder)); + +// CObject related +DEFINE_USER_BENCHMARK(CObjectIx_At1, + , + ObjectIx->At(ObjectHandle)); + +DEFINE_USER_BENCHMARK(CObjectIx_At2, + , + ObjectIx->At(ObjectHandle, 0)); + +DEFINE_USER_BENCHMARK(CObjectIx_ArrayOperator, + , + (*ObjectIx)[0]); + +DEFINE_USER_BENCHMARK(CObjectCon_ArrayOperator, + , + (*ObjectCon)[0]); + +DEFINE_USER_BENCHMARK(CObjectCon_At, + , + ObjectCon->At(ObjectHandle)); + +DEFINE_USER_BENCHMARK(CObjectCon_AtL, + , + ObjectCon->AtL(ObjectHandle)); + +// Huffman coding +DEFINE_USER_BENCHMARK(TBitInput_ReadL1, + , + BitInput.Set(BitData, 128); BitInput.ReadL()); + +DEFINE_USER_BENCHMARK(TBitInput_ReadL2, + , + BitInput.Set(BitData, 128); BitInput.ReadL(7)); + +DEFINE_USER_BENCHMARK(TBitInput_HuffmanL, + , + BitInput.Set(BitData, 128); BitInput.HuffmanL(HuffmanTable)); + +// Regions +DEFINE_USER_BENCHMARK(TRegion_BoundingRect, + , + Region.BoundingRect()); + +DEFINE_USER_BENCHMARK(TRegion_IsContainedBy, + TRect r(0,0,90,90), + Region.IsContainedBy(r)); + +DEFINE_USER_BENCHMARK(TRegion_Copy, + RRegion r, + r.Copy(Region)); + +DEFINE_USER_BENCHMARK(TRegion_Offset1, + , + Region.Offset(0, 0)); + +DEFINE_USER_BENCHMARK(TRegion_Contains, + TPoint p(0, 0), + Region.Contains(p)); + +DEFINE_USER_BENCHMARK(TRegion_Intersects, + TRect r(0, 0, 10, 10), + Region2.Intersects(r)); + +DEFINE_USER_BENCHMARK(TRegion_SubRect, + RRegion r, + r.Copy(Region); r.SubRect(Rect1)); + +DEFINE_USER_BENCHMARK(TRegion_Intersection, + RRegion r, + r.Intersection(Region, Region2)); + +DEFINE_USER_BENCHMARK(TRegion_ClipRect, + RRegion r, + r.Copy(Region); r.ClipRect(Rect1)); + +DEFINE_USER_BENCHMARK(TRegion_Tidy, + RRegion r, + r.Copy(Region3); r.Tidy()); + +// Maths +DEFINE_USER_BENCHMARK(Math_Frac, + TReal t, + Math::Frac(t, KPi)); + +DEFINE_USER_BENCHMARK(Math_Int1, + TReal t, + Math::Int(t, KPi)); + +DEFINE_USER_BENCHMARK(Math_Int2, + TInt16 t, + Math::Int(t, KPi)); + +DEFINE_USER_BENCHMARK(Math_Int3, + TInt32 t, + Math::Int(t, KPi)); + +DEFINE_USER_BENCHMARK(Math_IsZero, + , + Math::IsZero(KPi)); + +DEFINE_USER_BENCHMARK(Math_IsNaN, + , + Math::IsNaN(KPi)); + +DEFINE_USER_BENCHMARK(Math_IsInfinite, + , + Math::IsInfinite(KPi)); + +DEFINE_USER_BENCHMARK(Math_IsFinite, + , + Math::IsFinite(KPi)); + +DEFINE_USER_BENCHMARK(Math_Sqrt, + TReal t, + Math::Sqrt(t, KPi)); + +DEFINE_USER_BENCHMARK(Math_Poly, + TRealX t, + Math::PolyX(t, KPi, 3, PolyXCoeffs)); + +// Not tested due to not being exported: +// Math::SetZero +// Math::SetNan +// Math::SetInfinite + +// TRealX +DEFINE_USER_BENCHMARK(TRealX_Cons1, + TRealX t, + new (&t) TRealX); + +DEFINE_USER_BENCHMARK(TRealX_Cons2, + TRealX t, + new (&t) TRealX(0, 0, 0)); + +// covers TRealX::Set(TInt), TRealX::TRealX(TInt) and TRealX::operator=(TInt) +DEFINE_USER_BENCHMARK(TRealX_SetInt, + TRealX t, + t = (TInt) 23); + +// covers TRealX::Set(TUint), TRealX::TRealX(TUint) and TRealX::operator=(TUint) +DEFINE_USER_BENCHMARK(TRealX_SetUint, + TRealX t, + t = (TUint) 23); + +// covers TRealX::Set(TInt64), TRealX::TRealX(TInt64) and TRealX::operator=(TInt64) +DEFINE_USER_BENCHMARK(TRealX_SetInt64, + TRealX t, + t = (TInt64) 23); + +// covers TRealX::Set(TReal32), TRealX::TRealX(TReal32) and TRealX::operator=(TReal32) +DEFINE_USER_BENCHMARK(TRealX_SetReal32, + TRealX t; TReal32 v = 23, + t = v); + +// covers TRealX::Set(TReal64), TRealX::TRealX(TReal64) and TRealX::operator=(TReal64) +DEFINE_USER_BENCHMARK(TRealX_SetReal64, + TRealX t; TReal64 v = 23, + t = v); + +DEFINE_USER_BENCHMARK(TRealX_SetZero, + TRealX t, + t.SetZero(EFalse)); + +DEFINE_USER_BENCHMARK(TRealX_SetNaN, + TRealX t, + t.SetNaN()); + +DEFINE_USER_BENCHMARK(TRealX_SetInfinite, + TRealX t, + t.SetInfinite(EFalse)); + +DEFINE_USER_BENCHMARK(TRealX_IsZero, + TRealX t, + t.IsZero()); + +DEFINE_USER_BENCHMARK(TRealX_IsNaN, + TRealX t; t.SetNaN(), + t.IsNaN()); + +DEFINE_USER_BENCHMARK(TRealX_IsInfinite, + TRealX t; t.SetInfinite(EFalse), + t.IsInfinite()); + +DEFINE_USER_BENCHMARK(TRealX_IsFinite, + TRealX t, + t.IsFinite()); + +DEFINE_USER_BENCHMARK(TRealX_Int, + TRealX t = 2.3, + (TInt) t); + +DEFINE_USER_BENCHMARK(TRealX_Uint, + TRealX t = 2.3, + (TUint) t); + +DEFINE_USER_BENCHMARK(TRealX_Int64, + TRealX t = 2.3, + (TInt64) t); + +DEFINE_USER_BENCHMARK(TRealX_Real32, + TRealX t = 2.3, + (TReal32) t); + +DEFINE_USER_BENCHMARK(TRealX_Real64, + TRealX t = 2.3, + (TReal64) t); + +DEFINE_USER_BENCHMARK(TRealX_GetReal32, + TRealX t = 2.3; TReal32 out, + t.GetTReal(out)); + +DEFINE_USER_BENCHMARK(TRealX_GetReal64, + TRealX t = 2.3; TReal64 out, + t.GetTReal(out)); + +DEFINE_USER_BENCHMARK(TRealX_UnaryPlus, + TRealX t, + +t); + +DEFINE_USER_BENCHMARK(TRealX_UnaryMinus, + TRealX t, + -t); + +DEFINE_USER_BENCHMARK(TRealX_Compare, + TRealX a = 0.2; TRealX b = 0.21, + a.Compare(b)); + +DEFINE_USER_BENCHMARK(TRealX_Sub, + TRealX a = 1.0; TRealX b = 0.2, + a - b); + +DEFINE_USER_BENCHMARK(TRealX_Add, + TRealX a = 1.0; TRealX b = 0.2, + a + b); + +DEFINE_USER_BENCHMARK(TRealX_Mult, + TRealX a = 1.0; TRealX b = 0.2, + a * b); + +DEFINE_USER_BENCHMARK(TRealX_Div, + TRealX a = 1.0; TRealX b = 0.2, + a / b); + +DEFINE_USER_BENCHMARK(TRealX_Mod, + TRealX a = 1.1; TRealX b = 0.2, + a % b); + +DEFINE_USER_BENCHMARK(TRealX_PreInc, + TRealX t = 0.0, + ++t); + +DEFINE_USER_BENCHMARK(TRealX_PostInc, + TRealX t = 0.0, + t++); + +DEFINE_USER_BENCHMARK(TRealX_PreDec, + TRealX t = 0.0, + --t); + +DEFINE_USER_BENCHMARK(TRealX_PostDec, + TRealX t = 0.0, + t--); + +DEFINE_USER_BENCHMARK(RHeap_AllocFree, + TAny* mem, + mem = Heap->Alloc(8); + Heap->Free(mem)); + +// The following were added for timing functions affected by user-side thread data. + +DEFINE_USER_BENCHMARK(User_Heap, + , + User::Heap()); + +DEFINE_USER_BENCHMARK(CActiveScheduler_Current, + , + CActiveScheduler::Current()); + +DEFINE_USER_BENCHMARK(User_TrapHandler, + , + User::TrapHandler()); + +DEFINE_USER_BENCHMARK(UserSvr_DllSetTls, + , + UserSvr::DllSetTls(0, 0, 0)); + +DEFINE_USER_BENCHMARK(UserSvr_DllTls, + , + UserSvr::DllTls(0));