1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include "hbmeasuretest.h"

    19 

    20 #include <QGridLayout>

    21 #include <HbLabel>

    22 #include <HbPushButton>

    23 #include <QCoreApplication>

    24 #include <QSignalMapper>

    25 #include <QVariant>

    26 

    27 #include <QVariantHash>

    28 #include <HbComboBox>

    29 #include <QBrush>

    30 #include <QPalette>

    31 #include <QGraphicsGridLayout>

    32 #include <QTimer>

    33 #include <QFile>

    34 #include <QTextStream>

    35 #include <e32std.h>

    36 #include <HbInstance>

    37 #include <qservicemanager.h>

    38 #include <HbScrollArea>

    39 #include <afactivitystorage.h>

    40 #include <afactivation.h>

    41 #include "afstorageglobals.h"

    42 #include <HbCheckBox>

    43 #include <hblineedit.h>

    44 #include <f32file.h>

    45 

    46 QTM_USE_NAMESPACE

    47 

    48 const int KDefaultTimes = 10;

    49 const int KDefaultLoop = 10;

    50 const int KDefaultSaveBytes = 10*1024;

    51 const int KGet1Bytes = 10*1024;

    52 const int KGet2Bytes = 100*1024;

    53 const int KGet3Bytes = 1024*1024;

    54 const int KDefaultRepeat = 3;

    55 

    56 MeasureTest::MeasureTest(QGraphicsItem *parent) : HbView(parent), mByteArray(NULL),

    57     mActionCounter(0)

    58 

    59 {

    60     mFile = new QFile("c:\\data\\actautobenchmark.txt");    

    61     mFile->open(QIODevice::Append | QIODevice::Text);

    62     mStream = new QTextStream(mFile);

    63         

    64     QServiceManager serviceManager;

    65     serviceManager.addService(":/activityserviceplugin.xml");

    66     

    67     mActivityManager = serviceManager.loadInterface("com.nokia.qt.activities.ActivityManager");

    68     if (!mActivityManager) {

    69         qFatal("Cannot initialize critical com.nokia.qt.activities.ActivityManager service.");

    70         }

    71         

    72 

    73     mActivityStorage = new AfActivityStorage;

    74     mActivation = new AfActivation;

    75              	

    76     mResultLabel = new HbLabel();

    77     mItemLabel = new HbLabel();

    78 

    79 

    80     mSaveOneButton = new HbPushButton("Save 1 in loop");

    81     mSaveMoreButton = new HbPushButton("Save 10 in loop");    

    82     mGetButton = new HbPushButton("Get in loop");

    83     mAllButton = new HbPushButton("All");

    84     

    85 

    86     mLayout  = new QGraphicsGridLayout();

    87     mLayout->addItem(mResultLabel, 0, 0, 1, 6);

    88     mLayout->addItem(mItemLabel, 1, 0, 1, 6);

    89     mLayout->addItem(mSaveOneButton, 2, 0, 1, 6);

    90     mLayout->addItem(mSaveMoreButton, 3, 0, 1, 6);

    91     mLayout->addItem(mGetButton, 4, 0, 1, 6);

    92     mLayout->addItem(mAllButton, 5, 0, 1, 6);

    93     setLayout(mLayout);

    94     

    95     

    96     connect(mSaveOneButton, SIGNAL(released()), this, SLOT(preClear()));    

    97     connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(preClear()));

    98     connect(mGetButton, SIGNAL(released()), this, SLOT(preClear()));

    99     connect(mAllButton, SIGNAL(released()), this, SLOT(preClear()));

   100         

   101     connect(mSaveOneButton, SIGNAL(released()), this, SLOT(saveOne()));    

   102     connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(saveMore()));

   103     connect(mGetButton, SIGNAL(released()), this, SLOT(getOne()));

   104     connect(mAllButton, SIGNAL(released()), this, SLOT(all()));

   105     

   106     connect(mSaveOneButton, SIGNAL(released()), this, SLOT(startTimer()));    

   107     connect(mSaveMoreButton, SIGNAL(released()), this, SLOT(startTimer()));

   108     connect(mGetButton, SIGNAL(released()), this, SLOT(startTimer()));

   109     connect(mAllButton, SIGNAL(released()), this, SLOT(startTimer()));

   110     

   111     mTimer = new QTimer(this);

   112     connect(mTimer, SIGNAL(timeout()), this, SLOT(timeout()));

   113 

   114 }

   115 

   116 MeasureTest::~MeasureTest()

   117 {

   118     delete mFile;

   119     delete mStream;    

   120     delete mActivityManager;

   121     delete mActivityStorage;

   122     delete mActivation;

   123 }

   124 

   125 

   126 void MeasureTest::Before()

   127 {

   128     TTime time;

   129     time.HomeTime();

   130     iBefore = time.Int64();

   131 }

   132 

   133 void MeasureTest::After()

   134 {

   135     TTime time;

   136     time.HomeTime();

   137     iAfter = time.Int64();

   138 }

   139 

   140 void MeasureTest::Result()

   141 {

   142     TInt64 res(0);

   143     res = iAfter-iBefore;

   144     res = res/1000;

   145     iResult = res;

   146 }

   147 

   148 

   149 int MeasureTest::average(const QList<int>& list)

   150 {

   151     int count = list.count();

   152     int sum=0;

   153     for(int i=0; i<count; i++) {

   154         sum += list.at(i);

   155     }

   156     sum = (sum+0.5)/count;

   157     return sum;

   158 }

   159 

   160 int MeasureTest::writeResults(const QList<int>& list, int average)

   161 {

   162     for(int i=0; i<list.count(); i++){

   163         *mStream<<"|  ";

   164         *mStream<<list.at(i);

   165         *mStream<<"  |\n";

   166     }

   167     *mStream<<"|  ";

   168     *mStream<<average;

   169     *mStream<<"  |\n";

   170 }

   171 

   172 void MeasureTest::logError(const QString& mess)

   173 {

   174     *mStream<<"*Fail: "<<mess<<" *\n";

   175     mStream->flush();

   176 }

   177 

   178 bool MeasureTest::saveBytes(int bytes)

   179 {    

   180     delete mByteArray;

   181     mByteArray = NULL;

   182     mByteArray = new QByteArray(bytes, 'a');

   183     QVariant variant;

   184     variant = *mByteArray;

   185     

   186     HbMainWindow *mainWindow = hbInstance->allMainWindows().first();

   187     QPixmap screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());

   188 

   189     

   190     QVariantHash metadata;

   191     metadata.insert(ActivityScreenshotKeyword, screenshot);

   192     

   193     

   194     bool ok = false;

   195     QString name("0");

   196 

   197     ok = mActivityStorage->saveActivity(name, variant, metadata);

   198     return ok;

   199 }

   200 

   201 bool MeasureTest::deleteActivities()

   202 {

   203     QStringList activities = mActivityStorage->allActivities();    

   204     QString name;    

   205     bool ok = true;

   206     for (int i=0; i<activities.count(); i++) {

   207         ok = mActivityStorage->removeActivity(activities.at(i));        

   208         if (!ok) {

   209             break;

   210         }

   211     }        

   212     return ok;

   213 }

   214 

   215 bool MeasureTest::saveOneInLoop(int action)

   216 {

   217     int bytes = KDefaultSaveBytes;

   218     delete mByteArray;

   219     mByteArray = NULL;

   220     mByteArray = new QByteArray(bytes, 'a');

   221     QVariant variant;

   222     variant = *mByteArray;

   223     

   224     HbMainWindow *mainWindow = hbInstance->allMainWindows().first();

   225     QPixmap screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());

   226 

   227     

   228     QVariantHash metadata;

   229     metadata.insert(ActivityScreenshotKeyword, screenshot);

   230     

   231     int times = KDefaultTimes;    

   232     bool ok = false;    

   233     QString name("0");

   234     ok = deleteActivities();

   235     if(!ok) {

   236         logError("Remove");

   237         return false;

   238     }

   239     User::After(2000000); //2s

   240     

   241     for (int i=0; i<times; i++) {

   242         Before();

   243         ok = mActivityStorage->saveActivity(name, variant, metadata);

   244         After();

   245         Result();

   246         if (!ok) {

   247               break;

   248           }

   249         mResultsList[action].append(iResult);

   250         ok = deleteActivities();

   251         if(!ok) {

   252             logError("Remove");

   253             return false;

   254         }

   255         User::After(2000000); //2s

   256     }

   257     

   258     int averageint = average(mResultsList.at(action));

   259     mResultsList[action].append(averageint);

   260 

   261     if(!ok) {

   262         logError("SaveOne");        

   263     }

   264     

   265     return ok;

   266     

   267 }

   268 

   269 bool MeasureTest::saveMoreInLoop(int action)

   270 {

   271     int bytes = KDefaultSaveBytes;

   272     delete mByteArray;

   273     mByteArray = NULL;

   274     mByteArray = new QByteArray(bytes, 'a');

   275     QVariant variant;

   276     variant = *mByteArray;

   277     

   278     HbMainWindow *mainWindow = hbInstance->allMainWindows().first();

   279     QPixmap screenshot = QPixmap::grabWidget(mainWindow, mainWindow->rect());

   280 

   281     

   282     QVariantHash metadata;

   283     metadata.insert(ActivityScreenshotKeyword, screenshot);

   284     

   285     bool ok = deleteActivities();

   286     if(!ok) {

   287         logError("Remove");

   288         return false;

   289     }

   290     

   291     int times = KDefaultTimes;    

   292      

   293      

   294      ok = false;

   295      QString name;

   296      

   297      User::After(2000000); //2s

   298      for(int i=0; i<times; i++) {

   299          Before();

   300          for (int i=0; i<KDefaultLoop; i++) {

   301              

   302              name.setNum(i);

   303              ok = mActivityStorage->saveActivity(name, variant, metadata);

   304              if (!ok) {

   305                  break;

   306              }            

   307          }

   308          After();

   309          Result();

   310          mResultsList[action].append(iResult);

   311          

   312          QStringList activities = mActivityStorage->allActivities();      

   313      

   314          ok = deleteActivities();

   315          if(!ok) {

   316              logError("Remove");

   317              return false;

   318          }

   319          User::After(2000000); //2s        

   320 

   321      }       

   322      

   323      int averageint = average(mResultsList.at(action));

   324      averageint = (averageint+0.5)/KDefaultLoop;

   325      mResultsList[action].append(averageint);

   326 

   327      if(!ok) {

   328          logError("SaveMore");        

   329      }

   330      

   331      return ok;

   332 }

   333 

   334 bool MeasureTest::getOneInLoop(int bytes, int action)

   335 {

   336     int times = KDefaultTimes;

   337     bool ok = deleteActivities();

   338     if(!ok) {

   339         logError("Remove");

   340         return false;

   341     }

   342     ok = saveBytes(bytes);

   343     if(!ok) {

   344         logError("SaveBytes");

   345         return false;

   346     }

   347     

   348      QStringList activities = mActivityStorage->allActivities();

   349      

   350      

   351      User::After(2000000); //2s

   352      QString name;

   353      QVariant data;        

   354      

   355      for(int i=0; i<times; i++) {

   356          Before();

   357          for (int i=0; i<activities.count(); i++) {

   358              data = mActivityStorage->activityData(activities.at(i));

   359          }

   360          After();

   361          Result();

   362          mResultsList[action].append(iResult);

   363          User::After(2000000); //2s

   364      }

   365      

   366      int averageint = average(mResultsList.at(action));

   367      mResultsList[action].append(averageint);

   368 

   369      if(!ok) {

   370          logError("GetOne");        

   371      }

   372      

   373      return ok;

   374 }

   375 

   376 void MeasureTest::saveOne()

   377 {

   378     QList<int> l;

   379     for(int i=0; i<KDefaultRepeat; i++) {

   380         mActionsList.append("save1");        

   381         mResultsList.append(l);

   382     }

   383 }

   384 

   385 void MeasureTest::saveMore()

   386 {

   387     QList<int> l;

   388     for(int i=0; i<KDefaultRepeat; i++) {

   389         mActionsList.append("save10");        

   390         mResultsList.append(l);

   391     }

   392 }

   393 

   394 void MeasureTest::getOne()

   395 {

   396     QList<int> l;

   397     for(int i=0; i<KDefaultRepeat; i++) {

   398         mActionsList.append("get1"); 

   399         mResultsList.append(l);

   400     }

   401     for(int i=0; i<KDefaultRepeat; i++) {

   402         mActionsList.append("get2"); 

   403         mResultsList.append(l);

   404     }

   405     for(int i=0; i<KDefaultRepeat; i++) {

   406         mActionsList.append("get3"); 

   407         mResultsList.append(l);

   408     }

   409 }

   410 

   411 void MeasureTest::all()

   412 {

   413     saveOne();

   414     saveMore();

   415     getOne();

   416 }

   417 

   418 void MeasureTest::timeout()

   419 {

   420     if(mActionCounter == mActionsList.count()) {

   421         mTimer->stop();

   422         logResult();

   423         enableControls(true);

   424         return;

   425     }

   426     QString actionName = mActionsList.at(mActionCounter);

   427     bool ok = false;

   428     

   429     if(actionName == "save1") {

   430         ok = saveOneInLoop(mActionCounter);

   431     }

   432     else if(actionName == "save10") {

   433         ok = saveMoreInLoop(mActionCounter);

   434     }

   435     else if(actionName == "get1") {

   436         ok = getOneInLoop(KGet1Bytes, mActionCounter);

   437     }

   438     else if(actionName == "get2") {

   439         ok = getOneInLoop(KGet2Bytes, mActionCounter);

   440     }

   441     else if(actionName == "get3") {

   442         ok = getOneInLoop(KGet3Bytes, mActionCounter);

   443     }

   444     else {

   445         ok = false;

   446     }

   447     

   448     mItemMessage.clear();

   449     mResultMessage.clear();

   450 

   451     mItemMessage = (tr("action: %1")).arg(actionName);

   452     mResultMessage = (tr("count: %1")).arg(mActionCounter).arg(ok);

   453 

   454     mItemLabel->setPlainText(mItemMessage);

   455     mResultLabel->setPlainText(mResultMessage); 

   456     

   457     mActionCounter++;

   458 }

   459 

   460 void MeasureTest::preClear()

   461 {

   462     mResultsList.clear();

   463     mActionsList.clear();

   464     mActionCounter = 0;

   465     enableControls(false);

   466 }

   467 

   468 void MeasureTest::startTimer()

   469 {

   470     mTimer->start(1);

   471 }

   472 

   473 void MeasureTest::logResult()

   474 {

   475     QList<int> save1indexes;

   476     QList<int> save10indexes;

   477     QList<int> get1indexes;

   478     QList<int> get2indexes;

   479     QList<int> get3indexes;

   480     

   481     for(int i=0; i<mActionsList.count(); i++) {

   482         QString actionName = mActionsList.at(i);

   483         if(actionName == "save1") {

   484             save1indexes.append(i);

   485         }

   486         else if(actionName == "save10") {

   487             save10indexes.append(i);

   488         }

   489         else if(actionName == "get1") {

   490             get1indexes.append(i);

   491         }

   492         else if(actionName == "get2") {

   493             get2indexes.append(i);

   494         }

   495         else if(actionName == "get3") {

   496             get3indexes.append(i);

   497         }

   498     }

   499     logSaveSummary(save1indexes, save10indexes);

   500     logResult(save1indexes, 1, "Save one activity", "save");

   501     logResult(save10indexes, 2, "Save 10 activities in loop", "save");

   502     

   503     logGetSummary(get1indexes, get2indexes, get3indexes);

   504     logResult(get1indexes, 1, "Get activities with 10 KB of data", "get");

   505     logResult(get2indexes, 2, "Get activities with 100 KB of data", "get");

   506     logResult(get3indexes, 3, "Get activities with 1 MB of data", "get");

   507     

   508 }

   509 

   510 void MeasureTest::logResult(const QList<int>& indexes, int caseno, const QString& mess, const QString& type)

   511 {

   512     int indexno = indexes.count();

   513     if(indexno == 0) {

   514         return;

   515     }

   516     

   517     QString caseness = tr("---+++++ Case %1.\n\n").arg(caseno);

   518     *mStream<<caseness;

   519     

   520     *mStream<<mess<<"\n\n";

   521     

   522     *mStream<<"|    |";

   523     for(int i=0; i<indexno; i++) {

   524         QString mess = tr("  *Test %1 [ms]*  |").arg(i);

   525         *mStream<<mess;

   526     }

   527     *mStream<<"\n";

   528     QString tempmess;

   529     for(int i=0; i<KDefaultTimes+1; i++) {

   530         if(i == KDefaultTimes) {

   531             tempmess = tr("|  *Average per one %1*  |").arg(type);            

   532         }

   533         else {

   534             tempmess = tr("|  *Sample %1*  |").arg(i);    

   535         }

   536         *mStream<<tempmess;

   537         

   538         for(int j=0; j<indexno; j++) {            

   539             const QList<int>& reslist = mResultsList.at(indexes.at(j));

   540             if(reslist.count()>i) {

   541                 int res = reslist.at(i); 

   542                 *mStream<<"  "<<res<<"  |";

   543             }

   544             else {

   545                 *mStream<<"  -  |";

   546             }

   547         }

   548         *mStream<<"\n";

   549     }

   550     *mStream<<"\n\n";

   551     mStream->flush();    

   552 }

   553 

   554 QString MeasureTest::middle(const QList<int>& list)

   555 {    

   556     if(list.count()==0) {

   557         return "-";

   558     }

   559     QList<int> tlist = list;

   560     qSort(tlist);

   561     int count = tlist.count();

   562     QString res;

   563     res.setNum(tlist.at(count/2));

   564     return res;

   565 }

   566 

   567 void MeasureTest::logSaveSummary(const QList<int>& indexes1, const QList<int>& indexes10)

   568 {

   569     *mStream<<"---++++ Midle time of save activity - the faster and the slowest result has been rejected.\n\n";

   570     

   571     QList<int> save1averages;

   572     QList<int> save10averages;

   573     

   574     for(int i=0; i<indexes1.count(); i++) {

   575         const QList<int>& reslist = mResultsList.at(indexes1.at(i));

   576         if(reslist.count()==KDefaultTimes+1) {

   577             int d = reslist.at(KDefaultTimes);

   578             save1averages.append(reslist.at(KDefaultTimes));

   579         }

   580     }

   581     

   582     for(int i=0; i<indexes10.count(); i++) {

   583             const QList<int>& reslist = mResultsList.at(indexes10.at(i));

   584             if(reslist.count()==KDefaultTimes+1) {

   585                 save10averages.append(reslist.at(KDefaultTimes));

   586             }

   587         }

   588     QString save1middle = middle(save1averages);

   589     QString save10middle = middle(save10averages);

   590     

   591     *mStream<<"|  *Case no.*  |  *no. of saved activity in one measure*  |  *Midle time [ms]*  |\n";

   592     *mStream<<"|  1  |  1  |  "<<save1middle<<"  |\n";  

   593     *mStream<<"|  2  |  10  |  "<<save10middle<<"  |\n\n";

   594     mStream->flush();

   595 }

   596 

   597 void MeasureTest::logGetSummary(const QList<int>& get1, const QList<int>& get2 , const QList<int>& get3)

   598 {

   599     *mStream<<"---++++ Midle time of get activity - the faster and the slowest result has been rejected.\n\n";

   600     

   601     QList<int> get1averages;

   602     QList<int> get2averages;

   603     QList<int> get3averages;

   604     

   605     for(int i=0; i<get1.count(); i++) {

   606         const QList<int>& reslist = mResultsList.at(get1.at(i));

   607         if(reslist.count()==KDefaultTimes+1) {

   608             get1averages.append(reslist.at(KDefaultTimes));

   609         }

   610     }

   611     

   612     for(int i=0; i<get2.count(); i++) {

   613             const QList<int>& reslist = mResultsList.at(get2.at(i));

   614             if(reslist.count()==KDefaultTimes+1) {

   615                 get2averages.append(reslist.at(KDefaultTimes));

   616             }

   617         }

   618     

   619     for(int i=0; i<get3.count(); i++) {

   620             const QList<int>& reslist = mResultsList.at(get3.at(i));

   621             if(reslist.count()==KDefaultTimes+1) {

   622                 get3averages.append(reslist.at(KDefaultTimes));

   623             }

   624         }

   625     QString get1middle = middle(get1averages);

   626     QString get2middle = middle(get2averages);

   627     QString get3middle = middle(get3averages);

   628     

   629     *mStream<<"|  *Case no.*  |  *Data size [KB]*  |  *Midle time [ms]*  |\n";

   630     *mStream<<"|  1  |  10  |  "<<get1middle<<"  |\n";  

   631     *mStream<<"|  2  |  100  |  "<<get2middle<<"  |\n";

   632     *mStream<<"|  3  |  1024  |  "<<get3middle<<"  |\n\n";

   633     mStream->flush();

   634 }

   635 

   636 void MeasureTest::enableControls(bool enable)

   637 {

   638     mSaveOneButton->setEnabled(enable);

   639     mSaveMoreButton->setEnabled(enable);

   640     mGetButton->setEnabled(enable);

   641     mAllButton->setEnabled(enable);

   642 }