diff -r 000000000000 -r a41df078684a kerneltest/e32test/benchmark/property.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/benchmark/property.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,501 @@ +// Copyright (c) 2002-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: +// + +#include +#include + +#include "bm_suite.h" + +static const TInt32 KUidPropBenchmarkCategoryValue = 0x101f75b7; +static const TUid KPropBenchmarkCategory = { KUidPropBenchmarkCategoryValue }; +static _LIT_SECURITY_POLICY_PASS(KPassPolicy); + +typedef void (*MeasurementFunc)(TBMResult*, TBMUInt64 aIter, struct Measurement*); +enum TSetGetType + { + EOneArg, + EThreeArgsInt, + EThreeArgsBuf8, + EThreeArgsBuf16 + }; + +struct Measurement + { + MeasurementFunc iFunc; + TPtrC iName; + TBool iRemote; + RProperty::TType iType; + TInt iSize; + TSetGetType iSetGetType; + + Measurement(MeasurementFunc aFunc, const TDesC& aName, + RProperty::TType aType, TInt aSize, TBool aRemote = EFalse, + TSetGetType aSetGetType = EOneArg) : + iFunc(aFunc), iName(aName), iRemote(aRemote), iType(aType), iSize(aSize), + iSetGetType(aSetGetType) {} + }; + +class Property : public BMProgram + { +public : + Property() : BMProgram(_L("Properties")) + {} + virtual TBMResult* Run(TBMUInt64 aIter, TInt* aCount); + + + static TBMResult iResults[]; + static Measurement iMeasurements[]; + + static void NotificationLatencyParent(TBMResult* aResult, TBMUInt64 aIter, Measurement*); + static TInt NotificationLatencyChild(TAny*); + + static void SetOverhead(TBMResult* aResult, TBMUInt64 aIter, struct Measurement* aM); + static void GetOverhead(TBMResult* aResult, TBMUInt64 aIter, struct Measurement* aM); + + +private: + static TBuf8 iInBuf; + static TBuf8 iOutBuf; + static TBuf16 iInBuf16; + static TBuf16 iOutBuf16; + }; + +Measurement Property::iMeasurements[] = + { + Measurement(&Property::NotificationLatencyParent, _L("Local Int Notification Latency "), + RProperty::EInt, 0, EFalse), + Measurement(&Property::NotificationLatencyParent, _L("Remote Int Notification Latency"), + RProperty::EInt, 0,ETrue), + Measurement(&Property::NotificationLatencyParent, _L("Local Byte(1) Notification Latency"), + RProperty::EByteArray, 1, EFalse), + Measurement(&Property::NotificationLatencyParent, _L("Remote Byte(1) Notification Latency"), + RProperty::EByteArray, 1, ETrue), + Measurement(&Property::NotificationLatencyParent, _L("Local Byte(8) Notification Latency"), + RProperty::EByteArray, 8, EFalse), + Measurement(&Property::NotificationLatencyParent, _L("Remote Byte(8) Notification Latency"), + RProperty::EByteArray, 8,ETrue), + Measurement(&Property::NotificationLatencyParent, _L("Local Byte(512) Notification Latency"), + RProperty::EByteArray, 512, EFalse), + Measurement(&Property::NotificationLatencyParent, _L("Remote Byte(512) Notification Latency"), + RProperty::EByteArray, 512,ETrue), + + Measurement(&Property::NotificationLatencyParent, _L("Local Int Notification Latency ThreeArgsInt"), + RProperty::EInt, 0, EFalse, EThreeArgsInt), + Measurement(&Property::NotificationLatencyParent, _L("Remote Int Notification Latency ThreeArgsInt"), + RProperty::EInt, 0,ETrue, EThreeArgsInt), + Measurement(&Property::NotificationLatencyParent, _L("Local Byte(1) Notification Latency ThreeArgsBuf8"), + RProperty::EByteArray, 1, EFalse, EThreeArgsBuf8), + Measurement(&Property::NotificationLatencyParent, _L("Remote Byte(1) Notification Latency ThreeArgsBuf8"), + RProperty::EByteArray, 1, ETrue, EThreeArgsBuf8), + Measurement(&Property::NotificationLatencyParent, _L("Local TUint16(1) Notification Latency ThreeArgsBuf16"), + RProperty::EByteArray, 1, EFalse, EThreeArgsBuf16), + Measurement(&Property::NotificationLatencyParent, _L("Remote TUint16(1) Notification Latency ThreeArgsBuf16"), + RProperty::EByteArray, 1, ETrue, EThreeArgsBuf16), + Measurement(&Property::NotificationLatencyParent, _L("Local Byte(8) Notification Latency ThreeArgsBuf8"), + RProperty::EByteArray, 8, EFalse, EThreeArgsBuf8), + Measurement(&Property::NotificationLatencyParent, _L("Remote Byte(8) Notification Latency ThreeArgsBuf8"), + RProperty::EByteArray, 8,ETrue, EThreeArgsBuf8), + Measurement(&Property::NotificationLatencyParent, _L("Local TUint16(8) Notification Latency ThreeArgsBuf16"), + RProperty::EByteArray, 8, EFalse, EThreeArgsBuf16), + Measurement(&Property::NotificationLatencyParent, _L("Remote TUint16(8) Notification Latency ThreeArgsBuf16"), + RProperty::EByteArray, 8,ETrue, EThreeArgsBuf16), + Measurement(&Property::NotificationLatencyParent, _L("Local Byte(512) Notification Latency ThreeArgsBuf8"), + RProperty::EByteArray, 512, EFalse, EThreeArgsBuf8), + Measurement(&Property::NotificationLatencyParent, _L("Remote Byte(512) Notification Latency ThreeArgsBuf8"), + RProperty::EByteArray, 512,ETrue, EThreeArgsBuf8), + Measurement(&Property::NotificationLatencyParent, _L("Local TUint16(512) Notification Latency ThreeArgsBuf16"), + RProperty::ELargeByteArray, 512, EFalse, EThreeArgsBuf16), + Measurement(&Property::NotificationLatencyParent, _L("Remote TUint16(512) Notification Latency ThreeArgsBuf16"), + RProperty::ELargeByteArray, 512,ETrue, EThreeArgsBuf16), + + + + Measurement(&Property::SetOverhead, _L("Int Set Overhead"), + RProperty::EInt, 0), + Measurement(&Property::SetOverhead, _L("Byte(1) Set Overhead"), + RProperty::EByteArray, 1), + Measurement(&Property::SetOverhead, _L("Byte(8) Set Overhead"), + RProperty::EByteArray, 8), + Measurement(&Property::SetOverhead, _L("Byte(512) Set Overhead"), + RProperty::EByteArray, 512), + + Measurement(&Property::SetOverhead, _L("Int Set Overhead ThreeArgsInt"), + RProperty::EInt, 0, EFalse, EThreeArgsInt), + Measurement(&Property::SetOverhead, _L("Byte(1) Set Overhead ThreeArgsBuf8"), + RProperty::EByteArray, 1, EFalse, EThreeArgsBuf8), + Measurement(&Property::SetOverhead, _L("TUint16(1) Set Overhead ThreeArgsBuf16"), + RProperty::EByteArray, 1, EFalse, EThreeArgsBuf16), + Measurement(&Property::SetOverhead, _L("Byte(8) Set Overhead ThreeArgsBuf8"), + RProperty::EByteArray, 8, EFalse, EThreeArgsBuf8), + Measurement(&Property::SetOverhead, _L("TUint16(8) Set Overhead ThreeArgsBuf16"), + RProperty::EByteArray, 8, EFalse, EThreeArgsBuf16), + Measurement(&Property::SetOverhead, _L("Byte(512) Set Overhead ThreeArgsBuf8"), + RProperty::EByteArray, 512, EFalse, EThreeArgsBuf8), + Measurement(&Property::SetOverhead, _L("TUint16(512) Set Overhead ThreeArgsBuf16"), + RProperty::ELargeByteArray, 512, EFalse, EThreeArgsBuf16), + + + + Measurement(&Property::GetOverhead, _L("Int Get Overhead"), + RProperty::EInt, 0), + Measurement(&Property::GetOverhead, _L("Byte(1) Get Overhead"), + RProperty::EByteArray, 1), + Measurement(&Property::GetOverhead, _L("Byte(8) Get Overhead"), + RProperty::EByteArray, 8), + Measurement(&Property::GetOverhead, _L("Byte(512) Get Overhead"), + RProperty::EByteArray, 512), + + Measurement(&Property::GetOverhead, _L("Int Get Overhead ThreeArgsInt"), + RProperty::EInt, 0, EFalse, EThreeArgsInt), + Measurement(&Property::GetOverhead, _L("Byte(1) Get Overhead ThreeArgsBuf8"), + RProperty::EByteArray, 1, EFalse, EThreeArgsBuf8), + Measurement(&Property::GetOverhead, _L("TUint16(1) Get Overhead ThreeArgsBuf16"), + RProperty::EByteArray, 1, EFalse, EThreeArgsBuf16), + Measurement(&Property::GetOverhead, _L("Byte(8) Get Overhead ThreeArgsBuf8"), + RProperty::EByteArray, 8, EFalse, EThreeArgsBuf8), + Measurement(&Property::GetOverhead, _L("TUint16(8) Get Overhead ThreeArgsBuf16"), + RProperty::EByteArray, 8, EFalse, EThreeArgsBuf16), + Measurement(&Property::GetOverhead, _L("Byte(512) Get Overhead ThreeArgsBuf8"), + RProperty::EByteArray, 512, EFalse, EThreeArgsBuf8), + Measurement(&Property::GetOverhead, _L("TUint16(512) Get Overhead ThreeArgsBuf16"), + RProperty::ELargeByteArray, 512, EFalse, EThreeArgsBuf16), + + }; +TBMResult Property::iResults[sizeof(Property::iMeasurements)/sizeof(Property::iMeasurements[0])]; + +TBuf8 Property::iInBuf(RProperty::KMaxPropertySize); +TBuf8 Property::iOutBuf(RProperty::KMaxPropertySize); +TBuf16 Property::iInBuf16(RProperty::KMaxPropertySize); +TBuf16 Property::iOutBuf16(RProperty::KMaxPropertySize); + + +static Property property; + +class NotificationLatencyArgs : public TBMSpawnArgs + { +public: + + TBMUInt64 iIterationCount; + RProperty::TType iType; + TInt iSize; + TSetGetType iSetGetType; + + NotificationLatencyArgs(RProperty::TType aType, TInt aSize, TInt aRemote, TBMUInt64 aIter, + TSetGetType aSetGetType); + }; + +NotificationLatencyArgs::NotificationLatencyArgs(RProperty::TType aType, TInt aSize, TInt aRemote, + TBMUInt64 aIter, TSetGetType aSetGetType) : + TBMSpawnArgs(Property::NotificationLatencyChild, KBMPriorityLow, aRemote, sizeof(*this)), + iIterationCount(aIter), iType(aType), iSize(aSize), iSetGetType(aSetGetType) + { + } + +void Property::NotificationLatencyParent(TBMResult* aResult, TBMUInt64 aIter, struct Measurement* aM) + { + RProperty time; + TInt r = time.Define(KPropBenchmarkCategory, 0, RProperty::EByteArray, KPassPolicy, KPassPolicy); + BM_ERROR(r, r == KErrNone); + r = time.Attach(KPropBenchmarkCategory, 0); + BM_ERROR(r, r == KErrNone); + + RProperty prop; + r = prop.Define(KPropBenchmarkCategory, 1, aM->iType, KPassPolicy, KPassPolicy); + BM_ERROR(r, r == KErrNone); + r = prop.Attach(KPropBenchmarkCategory, 1); + BM_ERROR(r, r == KErrNone); + + NotificationLatencyArgs sl(aM->iType, aM->iSize, aM->iRemote, aIter, aM->iSetGetType); + MBMChild* child = property.SpawnChild(&sl); + for (TBMUInt64 i = 0; i < aIter; ++i) + { + TRequestStatus st; + prop.Subscribe(st); + User::WaitForRequest(st); + switch(aM->iSetGetType) + { + case EOneArg: + if (aM->iType == RProperty::EInt) + { + TInt value; + r = prop.Get(value); + BM_ERROR(r, r == KErrNone); + } + else + { + r = prop.Get(iInBuf); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsInt: + { + TInt value; + r = prop.Get(KPropBenchmarkCategory, 1, value); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsBuf8: + r = prop.Get(KPropBenchmarkCategory, 1, iInBuf); + BM_ERROR(r, r == KErrNone); + break; + case EThreeArgsBuf16: + r = prop.Get(KPropBenchmarkCategory, 1, iInBuf16); + BM_ERROR(r, r == KErrNone); + break; + } + + TBMTicks now; + ::bmTimer.Stamp(&now); + BM_ERROR(st.Int(), st.Int() == KErrNone); + + // subscribe for the time just before Set() + time.Subscribe(st); + User::WaitForRequest(st); + BM_ERROR(st.Int(), st.Int() == KErrNone); + // get the time just before Set() + TBMTicks propSetTime; + TPtr8 ptr((TUint8*) &propSetTime, sizeof(propSetTime), sizeof(propSetTime)); + r = time.Get(KPropBenchmarkCategory, 0, ptr); + BM_ERROR(r, r == KErrNone); + + aResult->Cumulate(TBMTicksDelta(propSetTime, now)); + } + prop.Close(); + time.Close(); + child->WaitChildExit(); + r = prop.Delete(KPropBenchmarkCategory, 1); + BM_ERROR(r, r == KErrNone); + r = time.Delete(KPropBenchmarkCategory, 0); + BM_ERROR(r, r == KErrNone); + } + +TInt Property::NotificationLatencyChild(TAny* cookie) + { + NotificationLatencyArgs* sl = (NotificationLatencyArgs*) cookie; + TInt prio = BMProgram::SetAbsPriority(RThread(), sl->iChildOrigPriority); + + for (TInt j = 0; j < RProperty::KMaxPropertySize; ++j) + { + iOutBuf[j] = (TUint8)(j + 1); + } + RProperty time; + RProperty prop; + TInt r = prop.Attach(KPropBenchmarkCategory, 1); + BM_ERROR(r, r == KErrNone); + for (TBMUInt64 i = 0; i < sl->iIterationCount; ++i) + { + TBMTicks propSetTime; + ::bmTimer.Stamp(&propSetTime); + switch(sl->iSetGetType) + { + case EOneArg: + if (sl->iType == RProperty::EInt) + { + TInt value = 0xdeadbeef; + r = prop.Set(value); + BM_ERROR(r, r == KErrNone); + } + else + { + TPtrC8 ptr(iOutBuf.Ptr(), sl->iSize); + r = prop.Set(ptr); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsInt: + { + TInt value = 0xdeadbeef; + r = prop.Set(KPropBenchmarkCategory, 1, value); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsBuf8: + { + TPtrC8 ptr(iOutBuf.Ptr(), sl->iSize); + r = prop.Set(KPropBenchmarkCategory, 1, ptr); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsBuf16: + { + TPtrC16 ptr(iOutBuf16.Ptr(), sl->iSize); + r = prop.Set(KPropBenchmarkCategory, 1, ptr); + BM_ERROR(r, r == KErrNone); + } + break; + } + // publish the time just before Set() + TPtr8 ptr((TUint8*) &propSetTime, sizeof(propSetTime), sizeof(propSetTime)); + r = time.Set(KPropBenchmarkCategory, 0, ptr); + BM_ERROR(r, r == KErrNone); + } + prop.Close(); + time.Close(); + + BMProgram::SetAbsPriority(RThread(), prio); + return KErrNone; + } + + +void Property::SetOverhead(TBMResult* aResult, TBMUInt64 aIter, struct Measurement* aM) + { + RProperty prop; + TInt r = prop.Define(KPropBenchmarkCategory, 1, aM->iType, KPassPolicy, KPassPolicy); + BM_ERROR(r, r == KErrNone); + r = prop.Attach(KPropBenchmarkCategory, 1); + BM_ERROR(r, r == KErrNone); + + if (aM->iType == RProperty::EByteArray) + { + TPtrC8 ptr(iOutBuf.Ptr(), aM->iSize); + r = prop.Set(ptr); + BM_ERROR(r, r == KErrNone); + } + + TBMTimeInterval ti; + ti.Begin(); + for (TBMUInt64 i = 0; i < aIter; ++i) + { + switch(aM->iSetGetType) + { + case EOneArg: + if (aM->iType == RProperty::EInt) + { + TInt value = 1; + r = prop.Set(value); + BM_ERROR(r, r == KErrNone); + } + else + { + TPtrC8 ptr(iOutBuf.Ptr(), aM->iSize); + r = prop.Set(ptr); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsInt: + { + TInt value = 1; + r = prop.Set(KPropBenchmarkCategory, 1, value); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsBuf8: + { + TPtrC8 ptr(iOutBuf.Ptr(), aM->iSize); + r = prop.Set(KPropBenchmarkCategory, 1, ptr); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsBuf16: + { + TPtrC16 ptr(iOutBuf16.Ptr(), aM->iSize); + r = prop.Set(KPropBenchmarkCategory, 1, ptr); + BM_ERROR(r, r == KErrNone); + } + break; + } + } + TBMTicks t = ti.End(); + + prop.Close(); + r = prop.Delete(KPropBenchmarkCategory, 1); + BM_ERROR(r, r == KErrNone); + + aResult->Cumulate(t, aIter); + } + +void Property::GetOverhead(TBMResult* aResult, TBMUInt64 aIter, struct Measurement* aM) + { + RProperty prop; + TInt r = prop.Define(KPropBenchmarkCategory, 1, aM->iType, KPassPolicy, KPassPolicy); + BM_ERROR(r, r == KErrNone); + r = prop.Attach(KPropBenchmarkCategory, 1); + BM_ERROR(r, r == KErrNone); + + if (aM->iType == RProperty::EByteArray) + { + TPtrC8 ptr(iOutBuf.Ptr(), aM->iSize); + r = prop.Set(ptr); + BM_ERROR(r, r == KErrNone); + } + + TBMTimeInterval ti; + ti.Begin(); + for (TBMUInt64 i = 0; i < aIter; ++i) + { + switch(aM->iSetGetType) + { + case EOneArg: + if (aM->iType == RProperty::EInt) + { + TInt value = 1; + r = prop.Get(value); + BM_ERROR(r, r == KErrNone); + } + else + { + r = prop.Get(iInBuf); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsInt: + { + TInt value = 1; + r = prop.Get(KPropBenchmarkCategory, 1, value); + BM_ERROR(r, r == KErrNone); + } + break; + case EThreeArgsBuf8: + r = prop.Get(KPropBenchmarkCategory, 1, iInBuf); + BM_ERROR(r, r == KErrNone); + break; + case EThreeArgsBuf16: + r = prop.Get(KPropBenchmarkCategory, 1, iInBuf16); + BM_ERROR(r, r == KErrNone); + break; + } + } + TBMTicks t = ti.End(); + + prop.Close(); + r = prop.Delete(KPropBenchmarkCategory, 1); + BM_ERROR(r, r == KErrNone); + + aResult->Cumulate(t, aIter); + } + + + +TBMResult* Property::Run(TBMUInt64 aIter, TInt* aCount) + { + TInt count = sizeof(iResults)/sizeof(iResults[0]); + + for (TInt i = 0; i < count; ++i) + { + iResults[i].Reset(iMeasurements[i].iName); + iMeasurements[i].iFunc(&iResults[i], aIter, &iMeasurements[i]); + iResults[i].Update(); + } + + *aCount = count; + return iResults; + } + +void AddProperty() + { + BMProgram* next = bmSuite; + bmSuite=(BMProgram*)&property; + bmSuite->Next()=next; + }