--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/activityfw/testapplications/newtestappset/actautobenchmark/hbmeasuretest.cpp Thu Sep 16 12:11:40 2010 +0100
@@ -0,0 +1,642 @@
+/*
+* Copyright (c) 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:
+*
+*/
+
+#include "hbmeasuretest.h"
+
+#include <QGridLayout>
+#include <HbLabel>
+#include <HbPushButton>
+#include <QCoreApplication>
+#include <QSignalMapper>
+#include <QVariant>
+
+#include <QVariantHash>
+#include <HbComboBox>
+#include <QBrush>
+#include <QPalette>
+#include <QGraphicsGridLayout>
+#include <QTimer>
+#include <QFile>
+#include <QTextStream>
+#include <e32std.h>
+#include <HbInstance>
+#include <qservicemanager.h>
+#include <HbScrollArea>
+#include <afactivitystorage.h>
+#include <afactivation.h>
+#include "afstorageglobals.h"
+#include <HbCheckBox>
+#include <hblineedit.h>
+#include <f32file.h>
+
+QTM_USE_NAMESPACE
+
+const int KDefaultTimes = 10;
+const int KDefaultLoop = 10;
+const int KDefaultSaveBytes = 10*1024;
+const int KGet1Bytes = 10*1024;
+const int KGet2Bytes = 100*1024;
+const int KGet3Bytes = 1024*1024;
+const int KDefaultRepeat = 3;
+
+MeasureTest::MeasureTest(QGraphicsItem *parent) : HbView(parent), mByteArray(NULL),
+ mActionCounter(0)
+
+{
+ mFile = new QFile("c:\\data\\actautobenchmark.txt");
+ mFile->open(QIODevice::Append | QIODevice::Text);
+ mStream = new QTextStream(mFile);
+
+ QServiceManager serviceManager;
+ serviceManager.addService(":/activityserviceplugin.xml");
+
+ mActivityManager = serviceManager.loadInterface("com.nokia.qt.activities.ActivityManager");
+ if (!mActivityManager) {
+ qFatal("Cannot initialize critical com.nokia.qt.activities.ActivityManager service.");
+ }
+
+
+ mActivityStorage = new AfActivityStorage;
+ mActivation = new AfActivation;
+
+ mResultLabel = new HbLabel();
+ mItemLabel = new HbLabel();
+
+
+ mSaveOneButton = new HbPushButton("Save 1 in loop");
+ mSaveMoreButton = new HbPushButton("Save 10 in loop");
+ mGetButton = new HbPushButton("Get in loop");
+ mAllButton = new HbPushButton("All");
+
+
+ mLayout = new QGraphicsGridLayout();
+ mLayout->addItem(mResultLabel, 0, 0, 1, 6);
+ mLayout->addItem(mItemLabel, 1, 0, 1, 6);
+ mLayout->addItem(mSaveOneButton, 2, 0, 1, 6);
+ mLayout->addItem(mSaveMoreButton, 3, 0, 1, 6);
+ mLayout->addItem(mGetButton, 4, 0, 1, 6);
+ mLayout->addItem(mAllButton, 5, 0, 1, 6);
+ setLayout(mLayout);
+
+
+ connect(mSaveOneButton, SIGNAL(released()), this, SLOT(preClear()));
+ connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(preClear()));
+ connect(mGetButton, SIGNAL(released()), this, SLOT(preClear()));
+ connect(mAllButton, SIGNAL(released()), this, SLOT(preClear()));
+
+ connect(mSaveOneButton, SIGNAL(released()), this, SLOT(saveOne()));
+ connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(saveMore()));
+ connect(mGetButton, SIGNAL(released()), this, SLOT(getOne()));
+ connect(mAllButton, SIGNAL(released()), this, SLOT(all()));
+
+ connect(mSaveOneButton, SIGNAL(released()), this, SLOT(startTimer()));
+ connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(startTimer()));
+ connect(mGetButton, SIGNAL(released()), this, SLOT(startTimer()));
+ connect(mAllButton, SIGNAL(released()), this, SLOT(startTimer()));
+
+ mTimer = new QTimer(this);
+ connect(mTimer, SIGNAL(timeout()), this, SLOT(timeout()));
+
+}
+
+MeasureTest::~MeasureTest()
+{
+ delete mFile;
+ delete mStream;
+ delete mActivityManager;
+ delete mActivityStorage;
+ delete mActivation;
+}
+
+
+void MeasureTest::Before()
+{
+ TTime time;
+ time.HomeTime();
+ iBefore = time.Int64();
+}
+
+void MeasureTest::After()
+{
+ TTime time;
+ time.HomeTime();
+ iAfter = time.Int64();
+}
+
+void MeasureTest::Result()
+{
+ TInt64 res(0);
+ res = iAfter-iBefore;
+ res = res/1000;
+ iResult = res;
+}
+
+
+int MeasureTest::average(const QList<int>& list)
+{
+ int count = list.count();
+ int sum=0;
+ for(int i=0; i<count; i++) {
+ sum += list.at(i);
+ }
+ sum = (sum+0.5)/count;
+ return sum;
+}
+
+int MeasureTest::writeResults(const QList<int>& list, int average)
+{
+ for(int i=0; i<list.count(); i++){
+ *mStream<<"| ";
+ *mStream<<list.at(i);
+ *mStream<<" |\n";
+ }
+ *mStream<<"| ";
+ *mStream<<average;
+ *mStream<<" |\n";
+}
+
+void MeasureTest::logError(const QString& mess)
+{
+ *mStream<<"*Fail: "<<mess<<" *\n";
+ mStream->flush();
+}
+
+bool MeasureTest::saveBytes(int bytes)
+{
+ delete mByteArray;
+ mByteArray = NULL;
+ mByteArray = new QByteArray(bytes, 'a');
+ QVariant variant;
+ variant = *mByteArray;
+
+ HbMainWindow *mainWindow = hbInstance->allMainWindows().first();
+ QPixmap screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());
+
+
+ QVariantHash metadata;
+ metadata.insert(ActivityScreenshotKeyword, screenshot);
+
+
+ bool ok = false;
+ QString name("0");
+
+ ok = mActivityStorage->saveActivity(name, variant, metadata);
+ return ok;
+}
+
+bool MeasureTest::deleteActivities()
+{
+ QStringList activities = mActivityStorage->allActivities();
+ QString name;
+ bool ok = true;
+ for (int i=0; i<activities.count(); i++) {
+ ok = mActivityStorage->removeActivity(activities.at(i));
+ if (!ok) {
+ break;
+ }
+ }
+ return ok;
+}
+
+bool MeasureTest::saveOneInLoop(int action)
+{
+ int bytes = KDefaultSaveBytes;
+ delete mByteArray;
+ mByteArray = NULL;
+ mByteArray = new QByteArray(bytes, 'a');
+ QVariant variant;
+ variant = *mByteArray;
+
+ HbMainWindow *mainWindow = hbInstance->allMainWindows().first();
+ QPixmap screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());
+
+
+ QVariantHash metadata;
+ metadata.insert(ActivityScreenshotKeyword, screenshot);
+
+ int times = KDefaultTimes;
+ bool ok = false;
+ QString name("0");
+ ok = deleteActivities();
+ if(!ok) {
+ logError("Remove");
+ return false;
+ }
+ User::After(2000000); //2s
+
+ for (int i=0; i<times; i++) {
+ Before();
+ ok = mActivityStorage->saveActivity(name, variant, metadata);
+ After();
+ Result();
+ if (!ok) {
+ break;
+ }
+ mResultsList[action].append(iResult);
+ ok = deleteActivities();
+ if(!ok) {
+ logError("Remove");
+ return false;
+ }
+ User::After(2000000); //2s
+ }
+
+ int averageint = average(mResultsList.at(action));
+ mResultsList[action].append(averageint);
+
+ if(!ok) {
+ logError("SaveOne");
+ }
+
+ return ok;
+
+}
+
+bool MeasureTest::saveMoreInLoop(int action)
+{
+ int bytes = KDefaultSaveBytes;
+ delete mByteArray;
+ mByteArray = NULL;
+ mByteArray = new QByteArray(bytes, 'a');
+ QVariant variant;
+ variant = *mByteArray;
+
+ HbMainWindow *mainWindow = hbInstance->allMainWindows().first();
+ QPixmap screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());
+
+
+ QVariantHash metadata;
+ metadata.insert(ActivityScreenshotKeyword, screenshot);
+
+ bool ok = deleteActivities();
+ if(!ok) {
+ logError("Remove");
+ return false;
+ }
+
+ int times = KDefaultTimes;
+
+
+ ok = false;
+ QString name;
+
+ User::After(2000000); //2s
+ for(int i=0; i<times; i++) {
+ Before();
+ for (int i=0; i<KDefaultLoop; i++) {
+
+ name.setNum(i);
+ ok = mActivityStorage->saveActivity(name, variant, metadata);
+ if (!ok) {
+ break;
+ }
+ }
+ After();
+ Result();
+ mResultsList[action].append(iResult);
+
+ QStringList activities = mActivityStorage->allActivities();
+
+ ok = deleteActivities();
+ if(!ok) {
+ logError("Remove");
+ return false;
+ }
+ User::After(2000000); //2s
+
+ }
+
+ int averageint = average(mResultsList.at(action));
+ averageint = (averageint+0.5)/KDefaultLoop;
+ mResultsList[action].append(averageint);
+
+ if(!ok) {
+ logError("SaveMore");
+ }
+
+ return ok;
+}
+
+bool MeasureTest::getOneInLoop(int bytes, int action)
+{
+ int times = KDefaultTimes;
+ bool ok = deleteActivities();
+ if(!ok) {
+ logError("Remove");
+ return false;
+ }
+ ok = saveBytes(bytes);
+ if(!ok) {
+ logError("SaveBytes");
+ return false;
+ }
+
+ QStringList activities = mActivityStorage->allActivities();
+
+
+ User::After(2000000); //2s
+ QString name;
+ QVariant data;
+
+ for(int i=0; i<times; i++) {
+ Before();
+ for (int i=0; i<activities.count(); i++) {
+ data = mActivityStorage->activityData(activities.at(i));
+ }
+ After();
+ Result();
+ mResultsList[action].append(iResult);
+ User::After(2000000); //2s
+ }
+
+ int averageint = average(mResultsList.at(action));
+ mResultsList[action].append(averageint);
+
+ if(!ok) {
+ logError("GetOne");
+ }
+
+ return ok;
+}
+
+void MeasureTest::saveOne()
+{
+ QList<int> l;
+ for(int i=0; i<KDefaultRepeat; i++) {
+ mActionsList.append("save1");
+ mResultsList.append(l);
+ }
+}
+
+void MeasureTest::saveMore()
+{
+ QList<int> l;
+ for(int i=0; i<KDefaultRepeat; i++) {
+ mActionsList.append("save10");
+ mResultsList.append(l);
+ }
+}
+
+void MeasureTest::getOne()
+{
+ QList<int> l;
+ for(int i=0; i<KDefaultRepeat; i++) {
+ mActionsList.append("get1");
+ mResultsList.append(l);
+ }
+ for(int i=0; i<KDefaultRepeat; i++) {
+ mActionsList.append("get2");
+ mResultsList.append(l);
+ }
+ for(int i=0; i<KDefaultRepeat; i++) {
+ mActionsList.append("get3");
+ mResultsList.append(l);
+ }
+}
+
+void MeasureTest::all()
+{
+ saveOne();
+ saveMore();
+ getOne();
+}
+
+void MeasureTest::timeout()
+{
+ if(mActionCounter == mActionsList.count()) {
+ mTimer->stop();
+ logResult();
+ enableControls(true);
+ return;
+ }
+ QString actionName = mActionsList.at(mActionCounter);
+ bool ok = false;
+
+ if(actionName == "save1") {
+ ok = saveOneInLoop(mActionCounter);
+ }
+ else if(actionName == "save10") {
+ ok = saveMoreInLoop(mActionCounter);
+ }
+ else if(actionName == "get1") {
+ ok = getOneInLoop(KGet1Bytes, mActionCounter);
+ }
+ else if(actionName == "get2") {
+ ok = getOneInLoop(KGet2Bytes, mActionCounter);
+ }
+ else if(actionName == "get3") {
+ ok = getOneInLoop(KGet3Bytes, mActionCounter);
+ }
+ else {
+ ok = false;
+ }
+
+ mItemMessage.clear();
+ mResultMessage.clear();
+
+ mItemMessage = (tr("action: %1")).arg(actionName);
+ mResultMessage = (tr("count: %1")).arg(mActionCounter).arg(ok);
+
+ mItemLabel->setPlainText(mItemMessage);
+ mResultLabel->setPlainText(mResultMessage);
+
+ mActionCounter++;
+}
+
+void MeasureTest::preClear()
+{
+ mResultsList.clear();
+ mActionsList.clear();
+ mActionCounter = 0;
+ enableControls(false);
+}
+
+void MeasureTest::startTimer()
+{
+ mTimer->start(1);
+}
+
+void MeasureTest::logResult()
+{
+ QList<int> save1indexes;
+ QList<int> save10indexes;
+ QList<int> get1indexes;
+ QList<int> get2indexes;
+ QList<int> get3indexes;
+
+ for(int i=0; i<mActionsList.count(); i++) {
+ QString actionName = mActionsList.at(i);
+ if(actionName == "save1") {
+ save1indexes.append(i);
+ }
+ else if(actionName == "save10") {
+ save10indexes.append(i);
+ }
+ else if(actionName == "get1") {
+ get1indexes.append(i);
+ }
+ else if(actionName == "get2") {
+ get2indexes.append(i);
+ }
+ else if(actionName == "get3") {
+ get3indexes.append(i);
+ }
+ }
+ logSaveSummary(save1indexes, save10indexes);
+ logResult(save1indexes, 1, "Save one activity", "save");
+ logResult(save10indexes, 2, "Save 10 activities in loop", "save");
+
+ logGetSummary(get1indexes, get2indexes, get3indexes);
+ logResult(get1indexes, 1, "Get activities with 10 KB of data", "get");
+ logResult(get2indexes, 2, "Get activities with 100 KB of data", "get");
+ logResult(get3indexes, 3, "Get activities with 1 MB of data", "get");
+
+}
+
+void MeasureTest::logResult(const QList<int>& indexes, int caseno, const QString& mess, const QString& type)
+{
+ int indexno = indexes.count();
+ if(indexno == 0) {
+ return;
+ }
+
+ QString caseness = tr("---+++++ Case %1.\n\n").arg(caseno);
+ *mStream<<caseness;
+
+ *mStream<<mess<<"\n\n";
+
+ *mStream<<"| |";
+ for(int i=0; i<indexno; i++) {
+ QString mess = tr(" *Test %1 [ms]* |").arg(i);
+ *mStream<<mess;
+ }
+ *mStream<<"\n";
+ QString tempmess;
+ for(int i=0; i<KDefaultTimes+1; i++) {
+ if(i == KDefaultTimes) {
+ tempmess = tr("| *Average per one %1* |").arg(type);
+ }
+ else {
+ tempmess = tr("| *Sample %1* |").arg(i);
+ }
+ *mStream<<tempmess;
+
+ for(int j=0; j<indexno; j++) {
+ const QList<int>& reslist = mResultsList.at(indexes.at(j));
+ if(reslist.count()>i) {
+ int res = reslist.at(i);
+ *mStream<<" "<<res<<" |";
+ }
+ else {
+ *mStream<<" - |";
+ }
+ }
+ *mStream<<"\n";
+ }
+ *mStream<<"\n\n";
+ mStream->flush();
+}
+
+QString MeasureTest::middle(const QList<int>& list)
+{
+ if(list.count()==0) {
+ return "-";
+ }
+ QList<int> tlist = list;
+ qSort(tlist);
+ int count = tlist.count();
+ QString res;
+ res.setNum(tlist.at(count/2));
+ return res;
+}
+
+void MeasureTest::logSaveSummary(const QList<int>& indexes1, const QList<int>& indexes10)
+{
+ *mStream<<"---++++ Midle time of save activity - the faster and the slowest result has been rejected.\n\n";
+
+ QList<int> save1averages;
+ QList<int> save10averages;
+
+ for(int i=0; i<indexes1.count(); i++) {
+ const QList<int>& reslist = mResultsList.at(indexes1.at(i));
+ if(reslist.count()==KDefaultTimes+1) {
+ int d = reslist.at(KDefaultTimes);
+ save1averages.append(reslist.at(KDefaultTimes));
+ }
+ }
+
+ for(int i=0; i<indexes10.count(); i++) {
+ const QList<int>& reslist = mResultsList.at(indexes10.at(i));
+ if(reslist.count()==KDefaultTimes+1) {
+ save10averages.append(reslist.at(KDefaultTimes));
+ }
+ }
+ QString save1middle = middle(save1averages);
+ QString save10middle = middle(save10averages);
+
+ *mStream<<"| *Case no.* | *no. of saved activity in one measure* | *Midle time [ms]* |\n";
+ *mStream<<"| 1 | 1 | "<<save1middle<<" |\n";
+ *mStream<<"| 2 | 10 | "<<save10middle<<" |\n\n";
+ mStream->flush();
+}
+
+void MeasureTest::logGetSummary(const QList<int>& get1, const QList<int>& get2 , const QList<int>& get3)
+{
+ *mStream<<"---++++ Midle time of get activity - the faster and the slowest result has been rejected.\n\n";
+
+ QList<int> get1averages;
+ QList<int> get2averages;
+ QList<int> get3averages;
+
+ for(int i=0; i<get1.count(); i++) {
+ const QList<int>& reslist = mResultsList.at(get1.at(i));
+ if(reslist.count()==KDefaultTimes+1) {
+ get1averages.append(reslist.at(KDefaultTimes));
+ }
+ }
+
+ for(int i=0; i<get2.count(); i++) {
+ const QList<int>& reslist = mResultsList.at(get2.at(i));
+ if(reslist.count()==KDefaultTimes+1) {
+ get2averages.append(reslist.at(KDefaultTimes));
+ }
+ }
+
+ for(int i=0; i<get3.count(); i++) {
+ const QList<int>& reslist = mResultsList.at(get3.at(i));
+ if(reslist.count()==KDefaultTimes+1) {
+ get3averages.append(reslist.at(KDefaultTimes));
+ }
+ }
+ QString get1middle = middle(get1averages);
+ QString get2middle = middle(get2averages);
+ QString get3middle = middle(get3averages);
+
+ *mStream<<"| *Case no.* | *Data size [KB]* | *Midle time [ms]* |\n";
+ *mStream<<"| 1 | 10 | "<<get1middle<<" |\n";
+ *mStream<<"| 2 | 100 | "<<get2middle<<" |\n";
+ *mStream<<"| 3 | 1024 | "<<get3middle<<" |\n\n";
+ mStream->flush();
+}
+
+void MeasureTest::enableControls(bool enable)
+{
+ mSaveOneButton->setEnabled(enable);
+ mSaveMoreButton->setEnabled(enable);
+ mGetButton->setEnabled(enable);
+ mAllButton->setEnabled(enable);
+}