1/****************************************************************************
2**
3** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4** Contact: http://www.qt-project.org/legal
5**
6** This file is part of the QtTest module of the Qt Toolkit.
7**
8** $QT_BEGIN_LICENSE:LGPL$
9** Commercial License Usage
10** Licensees holding valid commercial Qt licenses may use this file in
11** accordance with the commercial license agreement provided with the
12** Software or, alternatively, in accordance with the terms contained in
13** a written agreement between you and Digia. For licensing terms and
14** conditions see http://qt.digia.com/licensing. For further information
15** use the contact form at http://qt.digia.com/contact-us.
16**
17** GNU Lesser General Public License Usage
18** Alternatively, this file may be used under the terms of the GNU Lesser
19** General Public License version 2.1 as published by the Free Software
20** Foundation and appearing in the file LICENSE.LGPL included in the
21** packaging of this file. Please review the following information to
22** ensure the GNU Lesser General Public License version 2.1 requirements
23** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24**
25** In addition, as a special exception, Digia gives you certain additional
26** rights. These rights are described in the Digia Qt LGPL Exception
27** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28**
29** GNU General Public License Usage
30** Alternatively, this file may be used under the terms of the GNU
31** General Public License version 3.0 as published by the Free Software
32** Foundation and appearing in the file LICENSE.GPL included in the
33** packaging of this file. Please review the following information to
34** ensure the GNU General Public License version 3.0 requirements will be
35** met: http://www.gnu.org/copyleft/gpl.html.
36**
37**
38** $QT_END_LICENSE$
39**
40****************************************************************************/
41
42#include "QtTest/qbenchmark.h"
43#include "QtTest/private/qbenchmark_p.h"
44#include "QtTest/private/qbenchmarkmetric_p.h"
45
46#ifdef QT_GUI_LIB
47#include <QtGui/qapplication.h>
48#endif
49
50#include <QtCore/qprocess.h>
51#include <QtCore/qdir.h>
52#include <QtCore/qset.h>
53#include <QtCore/qdebug.h>
54
55QT_BEGIN_NAMESPACE
56
57QBenchmarkGlobalData *QBenchmarkGlobalData::current;
58
59QBenchmarkGlobalData::QBenchmarkGlobalData()
60 : measurer(0)
61 , walltimeMinimum(-1)
62 , iterationCount(-1)
63 , medianIterationCount(-1)
64 , createChart(false)
65 , verboseOutput(false)
66 , mode_(WallTime)
67{
68 setMode(mode_);
69}
70
71QBenchmarkGlobalData::~QBenchmarkGlobalData()
72{
73 delete measurer;
74 QBenchmarkGlobalData::current = 0;
75}
76
77void QBenchmarkGlobalData::setMode(Mode mode)
78{
79 mode_ = mode;
80
81 if (measurer)
82 delete measurer;
83 measurer = createMeasurer();
84}
85
86QBenchmarkMeasurerBase * QBenchmarkGlobalData::createMeasurer()
87{
88 QBenchmarkMeasurerBase *measurer = 0;
89 if (0) {
90#ifdef QTESTLIB_USE_VALGRIND
91 } else if (mode_ == CallgrindChildProcess || mode_ == CallgrindParentProcess) {
92 measurer = new QBenchmarkCallgrindMeasurer;
93#endif
94#ifdef HAVE_TICK_COUNTER
95 } else if (mode_ == TickCounter) {
96 measurer = new QBenchmarkTickMeasurer;
97#endif
98 } else if (mode_ == EventCounter) {
99 measurer = new QBenchmarkEvent;
100 } else {
101 measurer = new QBenchmarkTimeMeasurer;
102 }
103 measurer->init();
104 return measurer;
105}
106
107int QBenchmarkGlobalData::adjustMedianIterationCount()
108{
109 if (medianIterationCount != -1) {
110 return medianIterationCount;
111 } else {
112 return measurer->adjustMedianCount(1);
113 }
114}
115
116
117QBenchmarkTestMethodData *QBenchmarkTestMethodData::current;
118
119QBenchmarkTestMethodData::QBenchmarkTestMethodData()
120:resultAccepted(false), runOnce(false), iterationCount(-1)
121{
122
123}
124
125QBenchmarkTestMethodData::~QBenchmarkTestMethodData()
126{
127 QBenchmarkTestMethodData::current = 0;
128}
129
130void QBenchmarkTestMethodData::beginDataRun()
131{
132 iterationCount = adjustIterationCount(1);
133}
134
135void QBenchmarkTestMethodData::endDataRun()
136{
137
138}
139
140int QBenchmarkTestMethodData::adjustIterationCount(int suggestion)
141{
142 // Let the -iterations option override the measurer.
143 if (QBenchmarkGlobalData::current->iterationCount != -1) {
144 iterationCount = QBenchmarkGlobalData::current->iterationCount;
145 } else {
146 iterationCount = QBenchmarkGlobalData::current->measurer->adjustIterationCount(suggestion);
147 }
148
149 return iterationCount;
150}
151
152void QBenchmarkTestMethodData::setResult(
153 qreal value, QTest::QBenchmarkMetric metric, bool setByMacro)
154{
155 bool accepted = false;
156
157 // Always accept the result if the iteration count has been
158 // specified on the command line with -iterations.
159 if (QBenchmarkGlobalData::current->iterationCount != -1)
160 accepted = true;
161
162 else if (QBenchmarkTestMethodData::current->runOnce || !setByMacro) {
163 iterationCount = 1;
164 accepted = true;
165 }
166
167 // Test the result directly without calling the measurer if the minimum time
168 // has been specified on the command line with -minimumvalue.
169 else if (QBenchmarkGlobalData::current->walltimeMinimum != -1)
170 accepted = (value > QBenchmarkGlobalData::current->walltimeMinimum);
171 else
172 accepted = QBenchmarkGlobalData::current->measurer->isMeasurementAccepted(value);
173
174 // Accept the result or double the number of iterations.
175 if (accepted)
176 resultAccepted = true;
177 else
178 iterationCount *= 2;
179
180 this->result = QBenchmarkResult(
181 QBenchmarkGlobalData::current->context, value, iterationCount, metric, setByMacro);
182}
183
184/*!
185 \class QTest::QBenchmarkIterationController
186 \internal
187
188 The QBenchmarkIterationController class is used by the QBENCHMARK macro to
189 drive the benchmarking loop. It is repsonsible for starting and stopping
190 the timing measurements as well as calling the result reporting functions.
191*/
192
193/*! \internal
194*/
195QTest::QBenchmarkIterationController::QBenchmarkIterationController(RunMode runMode)
196{
197 i = 0;
198 if (runMode == RunOnce)
199 QBenchmarkTestMethodData::current->runOnce = true;
200 QTest::beginBenchmarkMeasurement();
201}
202
203QTest::QBenchmarkIterationController::QBenchmarkIterationController()
204{
205 i = 0;
206 QTest::beginBenchmarkMeasurement();
207}
208
209/*! \internal
210*/
211QTest::QBenchmarkIterationController::~QBenchmarkIterationController()
212{
213 const qreal result = QTest::endBenchmarkMeasurement();
214 QBenchmarkTestMethodData::current->setResult(result, QBenchmarkGlobalData::current->measurer->metricType());
215}
216
217/*! \internal
218*/
219bool QTest::QBenchmarkIterationController::isDone()
220{
221 if (QBenchmarkTestMethodData::current->runOnce)
222 return i > 0;
223 return i >= QTest::iterationCount();
224}
225
226/*! \internal
227*/
228void QTest::QBenchmarkIterationController::next()
229{
230 ++i;
231}
232
233/*! \internal
234*/
235int QTest::iterationCount()
236{
237 return QBenchmarkTestMethodData::current->iterationCount;
238}
239
240/*! \internal
241*/
242void QTest::setIterationCountHint(int count)
243{
244 QBenchmarkTestMethodData::current->adjustIterationCount(count);
245}
246
247/*! \internal
248*/
249void QTest::setIterationCount(int count)
250{
251 QBenchmarkTestMethodData::current->iterationCount = count;
252 QBenchmarkTestMethodData::current->resultAccepted = true;
253}
254
255/*! \internal
256*/
257void QTest::beginBenchmarkMeasurement()
258{
259 QBenchmarkGlobalData::current->measurer->start();
260 // the clock is ticking after the line above, don't add code here.
261}
262
263/*! \internal
264*/
265quint64 QTest::endBenchmarkMeasurement()
266{
267 // the clock is ticking before the line below, don't add code here.
268 return QBenchmarkGlobalData::current->measurer->stop();
269}
270
271/*!
272 Sets the benchmark result for this test function to \a result.
273
274 Use this function if you want to report benchmark results without
275 using the QBENCHMARK macro. Use \a metric to specify how QTestLib
276 should interpret the results.
277
278 The context for the result will be the test function name and any
279 data tag from the _data function. This function can only be called
280 once in each test function, subsequent calls will replace the
281 earlier reported results.
282
283 Note that the -iterations command line argument has no effect
284 on test functions without the QBENCHMARK macro.
285
286 \since 4.7
287*/
288void QTest::setBenchmarkResult(qreal result, QTest::QBenchmarkMetric metric)
289{
290 QBenchmarkTestMethodData::current->setResult(result, metric, false);
291}
292
293template <typename T>
294Q_TYPENAME T::value_type qAverage(const T &container)
295{
296 Q_TYPENAME T::const_iterator it = container.constBegin();
297 Q_TYPENAME T::const_iterator end = container.constEnd();
298 Q_TYPENAME T::value_type acc = Q_TYPENAME T::value_type();
299 int count = 0;
300 while (it != end) {
301 acc += *it;
302 ++it;
303 ++count;
304 }
305 return acc / count;
306}
307
308QT_END_NAMESPACE
309