qbenchmarkvalgrind.cpp

Jenkins

Absolute File Name:

/home/qt/qt5_coco/qt5/qtbase/src/testlib/qbenchmarkvalgrind.cpp

Line

Source

Count

/****************************************************************************

** Contact: https://www.qt.io/licensing/

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

** $QT_BEGIN_LICENSE:LGPL$

** Commercial License Usage

** Licensees holding valid commercial Qt licenses may use this file in

** accordance with the commercial license agreement provided with the

** Software or, alternatively, in accordance with the terms contained in

** a written agreement between you and The Qt Company. For licensing terms

** and conditions see https://www.qt.io/terms-conditions. For further

** information use the contact form at https://www.qt.io/contact-us.

** GNU Lesser General Public License Usage

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

** General Public License version 3 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL3 included in the

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

** ensure the GNU Lesser General Public License version 3 requirements

** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.

** GNU General Public License Usage

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

** General Public License version 2.0 or (at your option) the GNU General

** Public license version 3 or any later version approved by the KDE Free

** Qt Foundation. The licenses are as published by the Free Software

** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3

** included in the packaging of this file. Please review the following

** information to ensure the GNU General Public License requirements will

** be met: https://www.gnu.org/licenses/gpl-2.0.html and

** https://www.gnu.org/licenses/gpl-3.0.html.

** $QT_END_LICENSE$

****************************************************************************/

#include <QtTest/private/qbenchmark_p.h>

#ifdef QTESTLIB_USE_VALGRIND

#include <QtTest/private/qbenchmarkvalgrind_p.h>

#include <QtCore/qstringlist.h>

#include <QtCore/qcoreapplication.h>

#include <QtCore/qprocess.h>

#include <QtCore/qdir.h>

#include <QtCore/qset.h>

#include <QtTest/private/callgrind_p.h>

QT_BEGIN_NAMESPACE

// Returns \c true if valgrind is available.

bool QBenchmarkValgrindUtils::haveValgrind()

{

#ifdef NVALGRIND

return false;

#else

QProcess process;

process.start(QLatin1String("valgrind"), QStringList(QLatin1String("--version")));

return process.waitForStarted() && process.waitForFinished(-1);

#endif

}

// Reruns this program through callgrind.

// Returns \c true upon success, otherwise false.

bool QBenchmarkValgrindUtils::rerunThroughCallgrind(const QStringList &origAppArgs, int &exitCode)

{

if (!QBenchmarkValgrindUtils::runCallgrindSubProcess(origAppArgs, exitCode)) {

qWarning("failed to run callgrind subprocess");

return false;

}

return true;

}

static void dumpOutput(const QByteArray &data, FILE *fh)

{

QFile file;

file.open(fh, QIODevice::WriteOnly);

file.write(data);

}

qint64 QBenchmarkValgrindUtils::extractResult(const QString &fileName)

{

QFile file(fileName);

const bool openOk = file.open(QIODevice::ReadOnly | QIODevice::Text);

Q_ASSERT(openOk);

Q_UNUSED(openOk);

qint64 val = -1;

bool valSeen = false;

QRegExp rxValue(QLatin1String("^summary: (\\d+)"));

while (!file.atEnd()) {

!file.atEnd()	Description
TRUE	never evaluated
FALSE	never evaluated

const QString line(QLatin1String(file.readLine()));

if (rxValue.indexIn(line) != -1) {

rxValue.indexIn(line) != -1	Description
TRUE	never evaluated
FALSE	never evaluated

Q_ASSERT(rxValue.captureCount() == 1);

bool ok;

val = rxValue.cap(1).toLongLong(&ok);

100

Q_ASSERT(ok);

101

valSeen = true;

102

break;

never executed: break;

103

}

104

}

never executed: end of block

105

if (Q_UNLIKELY(!valSeen)))

__builtin_expe...lSeen), false)	Description
TRUE	never evaluated
FALSE	never evaluated

106

qFatal("Failed to extract result");

never executed: QMessageLogger(__FILE__, 106, __PRETTY_FUNCTION__).fatal("Failed to extract result");

107

return val;

never executed: return val;

108

}

109

110

// Gets the newest file name (i.e. the one with the highest integer suffix).

111

QString QBenchmarkValgrindUtils::getNewestFileName()

112

{

113

QStringList nameFilters;

114

QString base = QBenchmarkGlobalData::current->callgrindOutFileBase;

115

Q_ASSERT(!base.isEmpty());

116

117

nameFilters << QString::fromLatin1("%1.*").arg(base);

118

const QFileInfoList fiList = QDir().entryInfoList(nameFilters, QDir::Files | QDir::Readable);

119

Q_ASSERT(!fiList.empty());

120

int hiSuffix = -1;

121

QFileInfo lastFileInfo;

122

const QString pattern = QString::fromLatin1("%1.(\\d+)").arg(base);

123

QRegExp rx(pattern);

124

foreachfor (const QFileInfo &fileInfo ,: fiList) {

125

const int index = rx.indexIn(fileInfo.fileName());

126

Q_ASSERT(index == 0);

127

Q_UNUSED(index);

128

bool ok;

129

const int suffix = rx.cap(1).toInt(&ok);

130

Q_ASSERT(ok);

131

Q_ASSERT(suffix >= 0);

132

if (suffix > hiSuffix) {

suffix > hiSuffix	Description
TRUE	never evaluated
FALSE	never evaluated

133

lastFileInfo = fileInfo;

134

hiSuffix = suffix;

135

}

never executed: end of block

136

}

never executed: end of block

137

138

return lastFileInfo.fileName();

never executed: return lastFileInfo.fileName();

139

}

140

141

qint64 QBenchmarkValgrindUtils::extractLastResult()

142

{

143

return extractResult(getNewestFileName());

144

}

145

146

void QBenchmarkValgrindUtils::cleanup()

147

{

148

QStringList nameFilters;

149

QString base = QBenchmarkGlobalData::current->callgrindOutFileBase;

150

Q_ASSERT(!base.isEmpty());

151

nameFilters

152

<< base // overall summary

153

<< QString::fromLatin1("%1.*").arg(base); // individual dumps

154

const QFileInfoList fiList = QDir().entryInfoList(nameFilters, QDir::Files | QDir::Readable);

155

foreachfor (const QFileInfo &fileInfo ,: fiList) {

156

const bool removeOk = QFile::remove(fileInfo.fileName());

157

Q_ASSERT(removeOk);

158

Q_UNUSED(removeOk);

159

}

never executed: end of block

160

}

never executed: end of block

161

162

QString QBenchmarkValgrindUtils::outFileBase(qint64 pid)

163

{

164

return QString::fromLatin1("callgrind.out.%1").arg(

165

pid != -1 ? pid : QCoreApplication::applicationPid());

166

}

167

168

// Reruns this program through callgrind, storing callgrind result files in the

169

// current directory.

170

// Returns \c true upon success, otherwise false.

171

bool QBenchmarkValgrindUtils::runCallgrindSubProcess(const QStringList &origAppArgs, int &exitCode)

172

{

173

const QString execFile(origAppArgs.at(0));

174

QStringList args;

175

args << QLatin1String("--tool=callgrind") << QLatin1String("--instr-atstart=yes")

176

<< QLatin1String("--quiet")

177

<< execFile << QLatin1String("-callgrindchild");

178

179

// pass on original arguments that make sense (e.g. avoid wasting time producing output

180

// that will be ignored anyway) ...

181

for (int i = 1; i < origAppArgs.size(); ++i) {

182

const QString arg(origAppArgs.at(i));

183

if (arg == QLatin1String("-callgrind"))

184

continue;

185

args << arg; // ok to pass on

}

QProcess process;

process.start(QLatin1String("valgrind"), args);

190

process.waitForStarted(-1);

191

QBenchmarkGlobalData::current->callgrindOutFileBase =

192

QBenchmarkValgrindUtils::outFileBase(process.pid());

193

const bool finishedOk = process.waitForFinished(-1);

194

exitCode = process.exitCode();

195

196

dumpOutput(process.readAllStandardOutput(), stdout);

197

dumpOutput(process.readAllStandardError(), stderr);

return finishedOk;

}

void QBenchmarkCallgrindMeasurer::start()

203

{

204

CALLGRIND_ZERO_STATS;

205

}

206

207

qint64 QBenchmarkCallgrindMeasurer::checkpoint()

208

{

209

CALLGRIND_DUMP_STATS;

210

const qint64 result = QBenchmarkValgrindUtils::extractLastResult();

return result;

}

qint64 QBenchmarkCallgrindMeasurer::stop()

{

return checkpoint();

}

bool QBenchmarkCallgrindMeasurer::isMeasurementAccepted(qint64 measurement)

220

{

221

Q_UNUSED(measurement);

return true;

}

int QBenchmarkCallgrindMeasurer::adjustIterationCount(int)

{

return 1;

}

int QBenchmarkCallgrindMeasurer::adjustMedianCount(int)

{

return 1;

}

bool QBenchmarkCallgrindMeasurer::needsWarmupIteration()

{

return true;

}

QTest::QBenchmarkMetric QBenchmarkCallgrindMeasurer::metricType()

241

{

242

return QTest::InstructionReads;

}

QT_END_NAMESPACE

#endif // QTESTLIB_USE_VALGRIND

Generated by Squish Coco Non-Commercial 4.3.0-BETA-master-30-08-2018-4cb69e9