Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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));