1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtTest module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "QtTest/qbenchmark.h"

    43 #include "QtTest/private/qbenchmark_p.h"

    44 

    45 #ifdef QT_GUI_LIB

    46 #include <QtGui/qapplication.h>

    47 #endif

    48 

    49 #include <QtCore/qprocess.h>

    50 #include <QtCore/qdir.h>

    51 #include <QtCore/qset.h>

    52 #include <QtCore/qdebug.h>

    53 

    54 QT_BEGIN_NAMESPACE

    55 

    56 QBenchmarkGlobalData *QBenchmarkGlobalData::current;

    57 

    58 QBenchmarkGlobalData::QBenchmarkGlobalData()

    59     : measurer(0)

    60     , walltimeMinimum(-1)

    61     , iterationCount(-1)

    62     , medianIterationCount(-1)

    63     , createChart(false)

    64     , verboseOutput(false)

    65     , mode_(WallTime)

    66 {

    67     setMode(mode_);

    68 }

    69 

    70 QBenchmarkGlobalData::~QBenchmarkGlobalData()

    71 {

    72     delete measurer;

    73     QBenchmarkGlobalData::current = 0;

    74 }

    75 

    76 void QBenchmarkGlobalData::setMode(Mode mode)

    77 {

    78     mode_ = mode;

    79 

    80     if (measurer)

    81         delete measurer;

    82     measurer = createMeasurer();

    83 }

    84 

    85 QBenchmarkMeasurerBase * QBenchmarkGlobalData::createMeasurer()

    86 {

    87     QBenchmarkMeasurerBase *measurer = 0;

    88     if (0) {

    89 #ifdef QTESTLIB_USE_VALGRIND

    90     } else if (mode_ == CallgrindChildProcess || mode_ == CallgrindParentProcess) {

    91         measurer = new QBenchmarkCallgrindMeasurer;

    92 #endif

    93 #ifdef HAVE_TICK_COUNTER

    94     } else if (mode_ == TickCounter) {

    95         measurer = new QBenchmarkTickMeasurer;

    96 #endif

    97     } else if (mode_ == EventCounter) {

    98         measurer = new QBenchmarkEvent;

    99     } else {

   100         measurer =  new QBenchmarkTimeMeasurer;

   101     }

   102     measurer->init();

   103     return measurer;

   104 }

   105 

   106 int QBenchmarkGlobalData::adjustMedianIterationCount()

   107 {

   108     if (medianIterationCount != -1) {

   109         return medianIterationCount;

   110     } else {

   111         return measurer->adjustMedianCount(1);

   112     }

   113 }

   114 

   115 

   116 QBenchmarkTestMethodData *QBenchmarkTestMethodData::current;

   117 

   118 QBenchmarkTestMethodData::QBenchmarkTestMethodData()

   119 :resultAccepted(false), runOnce(false), iterationCount(-1)

   120 {

   121    

   122 }

   123 

   124 QBenchmarkTestMethodData::~QBenchmarkTestMethodData()

   125 {

   126     QBenchmarkTestMethodData::current = 0;

   127 }

   128 

   129 void QBenchmarkTestMethodData::beginDataRun()

   130 {

   131     iterationCount = adjustIterationCount(1);

   132 }

   133 

   134 void QBenchmarkTestMethodData::endDataRun()

   135 {

   136 

   137 }

   138 

   139 int QBenchmarkTestMethodData::adjustIterationCount(int suggestion)

   140 {

   141     // Let the -iteration-count option override the measurer.

   142     if (QBenchmarkGlobalData::current->iterationCount != -1) {

   143         iterationCount = QBenchmarkGlobalData::current->iterationCount;

   144     } else {

   145         iterationCount = QBenchmarkGlobalData::current->measurer->adjustIterationCount(suggestion);

   146     }

   147 

   148     return iterationCount;

   149 }

   150 

   151 void QBenchmarkTestMethodData::setResult(qint64 value)

   152 {

   153     bool accepted = false;

   154 

   155     // Always accept the result if the iteration count has been

   156     // specified on the command line with -iteartion-count.

   157     if (QBenchmarkGlobalData::current->iterationCount != -1)

   158         accepted = true;

   159 

   160     if (QBenchmarkTestMethodData::current->runOnce) {

   161         iterationCount = 1;

   162         accepted = true;

   163     }

   164     

   165     // Test the result directly without calling the measurer if the minimum time 

   166     // has been specifed on the command line with -minimumvalue.

   167     else if (QBenchmarkGlobalData::current->walltimeMinimum != -1)

   168         accepted = (value > QBenchmarkGlobalData::current->walltimeMinimum);

   169     else

   170         accepted = QBenchmarkGlobalData::current->measurer->isMeasurementAccepted(value);

   171 

   172     // Accept the result or double the number of iterations.

   173     if (accepted)

   174         resultAccepted = true;

   175     else

   176         iterationCount *= 2;

   177 

   178     this->result = 

   179         QBenchmarkResult(QBenchmarkGlobalData::current->context, value, iterationCount);

   180 }

   181 

   182 /*!

   183     \class QTest::QBenchmarkIterationController

   184     \internal

   185 

   186     The QBenchmarkIterationController class is used by the QBENCHMARK macro to

   187     drive the benchmarking loop. It is repsonsible for starting and stopping

   188     the timing measurements as well as calling the result reporting functions.

   189 */

   190 

   191 /*! \internal

   192 */

   193 QTest::QBenchmarkIterationController::QBenchmarkIterationController(RunMode runMode)

   194 {

   195     i = 0;

   196     if (runMode == RunOnce)

   197         QBenchmarkTestMethodData::current->runOnce = true;    

   198     QTest::beginBenchmarkMeasurement();

   199 }

   200 

   201 QTest::QBenchmarkIterationController::QBenchmarkIterationController()

   202 {

   203     i = 0;

   204     QTest::beginBenchmarkMeasurement();

   205 }

   206 

   207 /*! \internal

   208 */

   209 QTest::QBenchmarkIterationController::~QBenchmarkIterationController()

   210 {

   211     QBenchmarkTestMethodData::current->setResult(QTest::endBenchmarkMeasurement());

   212 }

   213 

   214 /*! \internal

   215 */

   216 bool QTest::QBenchmarkIterationController::isDone()

   217 {

   218     if (QBenchmarkTestMethodData::current->runOnce)

   219         return i > 0;

   220     return i >= QTest::iterationCount();

   221 }

   222 

   223 /*! \internal

   224 */

   225 void QTest::QBenchmarkIterationController::next()

   226 {

   227     ++i;

   228 }

   229 

   230 /*! \internal

   231 */

   232 int QTest::iterationCount()

   233 {

   234     return QBenchmarkTestMethodData::current->iterationCount;

   235 }

   236 

   237 /*! \internal

   238 */

   239 void QTest::setIterationCountHint(int count)

   240 {

   241     QBenchmarkTestMethodData::current->adjustIterationCount(count);

   242 }

   243 

   244 /*! \internal

   245 */

   246 void QTest::setIterationCount(int count)

   247 {

   248     QBenchmarkTestMethodData::current->iterationCount = count;

   249     QBenchmarkTestMethodData::current->resultAccepted = true;

   250 }

   251 

   252 /*! \internal

   253 */

   254 void QTest::beginBenchmarkMeasurement()

   255 {

   256     QBenchmarkGlobalData::current->measurer->start();

   257     // the clock is ticking after the line above, don't add code here.

   258 }

   259 

   260 /*! \internal

   261 */

   262 qint64 QTest::endBenchmarkMeasurement()

   263 {

   264     // the clock is ticking before the line below, don't add code here.

   265     return QBenchmarkGlobalData::current->measurer->stop();    

   266 }

   267 

   268 /*! \internal

   269 */

   270 void QTest::setResult(qint64 result)

   271 {

   272     QBenchmarkTestMethodData::current->setResult(result);

   273 }

   274 

   275 /*! \internal

   276 */

   277 void QTest::setResult(const QString &tag, qint64 result)

   278 {

   279     QBenchmarkContext context = QBenchmarkGlobalData::current->context;

   280     context.tag = tag;

   281     QBenchmarkTestMethodData::current->result = 

   282         QBenchmarkResult( context, result,

   283             QBenchmarkTestMethodData::current->iterationCount);

   284 }

   285 

   286 template <typename T>

   287 Q_TYPENAME T::value_type qAverage(const T &container)

   288 {

   289     Q_TYPENAME T::const_iterator it = container.constBegin();

   290     Q_TYPENAME T::const_iterator end = container.constEnd();

   291     Q_TYPENAME T::value_type acc = Q_TYPENAME T::value_type();

   292     int count = 0;

   293     while (it != end) {

   294         acc += *it;

   295         ++it;

   296         ++count;

   297     }

   298     return acc / count;

   299 }

   300 

   301 

   302 QT_END_NAMESPACE

   303