// 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 <e32huffman.h>
#include <e32math.h>
#include <e32base.h>
#include <e32base_private.h>
#include <e32std.h>
#include <e32std_private.h>
#include <e32svr.h>
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<TInt> ArrayTInt; // RArrayPointerBase derived
RArray<TUint> ArrayTUint; // RArrayPointerBase derived
RPointerArray<TPoint> ArrayTPointPtr;
RArray<TPoint> ArrayTPoint;
TPoint Point(6, 13);
TIdentityRelation<TPoint> PointIdentity(PointsEqual);
TLinearOrder<TPoint> 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; x<Allocs; ++x)
cells[x] = Heap->Alloc(4);
for (x=0; x<Allocs; x += 2)
Heap->Free(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<TInt> 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<TPoint> 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));