X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=gui%2Fretracer.cpp;h=2de9d23ee849de85f12c6cbf51461750ba7edf68;hb=7257dfcc57b3a1af576a8a2ca69992ae8d77dea4;hp=ca9da9a01c0f7d23c7a15fcd1038b7eb540dfd65;hpb=5bba477616c20710142165f6c67eb9b6571aa086;p=apitrace diff --git a/gui/retracer.cpp b/gui/retracer.cpp index ca9da9a..2de9d23 100644 --- a/gui/retracer.cpp +++ b/gui/retracer.cpp @@ -1,9 +1,11 @@ #include "retracer.h" -#include #include "apitracecall.h" +#include "thumbnail.h" -#include "image.hpp" +#include "image/image.hpp" + +#include "trace_profiler.hpp" #include #include @@ -12,6 +14,116 @@ #include +/** + * Wrapper around a QProcess which enforces IO to block . + * + * Several QIODevice users (notably QJSON) expect blocking semantics, e.g., + * they expect that QIODevice::read() will blocked until the requested ammount + * of bytes is read or end of file is reached. But by default QProcess, does + * not block. And passing QIODevice::Unbuffered mitigates but does not fully + * address the problem either. + * + * This class wraps around QProcess, providing QIODevice interface, while + * ensuring that all reads block. + * + * This class also works around a bug in QProcess::atEnd() implementation. + * + * See also: + * - http://qt-project.org/wiki/Simple_Crypt_IO_Device + * - http://qt-project.org/wiki/Custom_IO_Device + */ +class BlockingIODevice : public QIODevice +{ + /* We don't use the Q_OBJECT in this class given we don't declare any + * signals and slots or use any other services provided by Qt's meta-object + * system. */ +public: + BlockingIODevice(QProcess * io); + bool isSequential() const; + bool atEnd() const; + bool waitForReadyRead(int msecs = -1); + +protected: + qint64 readData(char * data, qint64 maxSize); + qint64 writeData(const char * data, qint64 maxSize); + +private: + QProcess *m_device; +}; + +BlockingIODevice::BlockingIODevice(QProcess * io) : + m_device(io) +{ + /* + * We pass QIODevice::Unbuffered to prevent the base QIODevice class to do + * its own buffering on top of the overridden readData() method. + * + * The only buffering used will be to satisfy QIODevice::peek() and + * QIODevice::ungetChar(). + */ + setOpenMode(ReadOnly | Unbuffered); +} + +bool BlockingIODevice::isSequential() const +{ + return true; +} + +bool BlockingIODevice::atEnd() const +{ + /* + * XXX: QProcess::atEnd() documentation is wrong -- it will return true + * even when the process is running --, so we try to workaround that here. + */ + if (m_device->atEnd()) { + if (m_device->state() == QProcess::Running) { + if (!m_device->waitForReadyRead(-1)) { + return true; + } + } + } + return false; +} + +bool BlockingIODevice::waitForReadyRead(int msecs) +{ + Q_UNUSED(msecs); + return true; +} + +qint64 BlockingIODevice::readData(char * data, qint64 maxSize) +{ + qint64 bytesToRead = maxSize; + qint64 readSoFar = 0; + do { + qint64 chunkSize = m_device->read(data + readSoFar, bytesToRead); + if (chunkSize < 0) { + if (readSoFar) { + return readSoFar; + } else { + return chunkSize; + } + } + Q_ASSERT(chunkSize <= bytesToRead); + bytesToRead -= chunkSize; + readSoFar += chunkSize; + if (bytesToRead) { + if (!m_device->waitForReadyRead(-1)) { + qDebug() << "waitForReadyRead failed\n"; + break; + } + } + } while(bytesToRead); + + return readSoFar; +} + +qint64 BlockingIODevice::writeData(const char * data, qint64 maxSize) +{ + Q_ASSERT(false); + return -1; +} + Q_DECLARE_METATYPE(QList); Retracer::Retracer(QObject *parent) @@ -19,22 +131,12 @@ Retracer::Retracer(QObject *parent) m_benchmarking(false), m_doubleBuffered(true), m_captureState(false), - m_captureCall(0) + m_captureCall(0), + m_profileGpu(false), + m_profileCpu(false), + m_profilePixels(false) { qRegisterMetaType >(); - -#ifdef Q_OS_WIN - QString format = QLatin1String("%1;"); -#else - QString format = QLatin1String("%1:"); -#endif - QString buildPath = format.arg(APITRACE_BINARY_DIR); - m_processEnvironment = QProcessEnvironment::systemEnvironment(); - m_processEnvironment.insert("PATH", buildPath + - m_processEnvironment.value("PATH")); - - qputenv("PATH", - m_processEnvironment.value("PATH").toLatin1()); } QString Retracer::fileName() const @@ -47,6 +149,16 @@ void Retracer::setFileName(const QString &name) m_fileName = name; } +QString Retracer::remoteTarget() const +{ + return m_remoteTarget; +} + +void Retracer::setRemoteTarget(const QString &host) +{ + m_remoteTarget = host; +} + void Retracer::setAPI(trace::API api) { m_api = api; @@ -72,6 +184,33 @@ void Retracer::setDoubleBuffered(bool db) m_doubleBuffered = db; } +bool Retracer::isProfilingGpu() const +{ + return m_profileGpu; +} + +bool Retracer::isProfilingCpu() const +{ + return m_profileCpu; +} + +bool Retracer::isProfilingPixels() const +{ + return m_profilePixels; +} + +bool Retracer::isProfiling() const +{ + return m_profileGpu || m_profileCpu || m_profilePixels; +} + +void Retracer::setProfiling(bool gpu, bool cpu, bool pixels) +{ + m_profileGpu = gpu; + m_profileCpu = cpu; + m_profilePixels = pixels; +} + void Retracer::setCaptureAtCallNumber(qlonglong num) { m_captureCall = num; @@ -102,7 +241,6 @@ void Retracer::setCaptureThumbnails(bool enable) m_captureThumbnails = enable; } - /** * Starting point for the retracing thread. * @@ -110,7 +248,7 @@ void Retracer::setCaptureThumbnails(bool enable) */ void Retracer::run() { - QString msg; + QString msg = QLatin1String("Replay finished!"); /* * Construct command line @@ -119,40 +257,79 @@ void Retracer::run() QString prog; QStringList arguments; - if (m_api == trace::API_GL) { + switch (m_api) { + case trace::API_GL: prog = QLatin1String("glretrace"); - } else if (m_api == trace::API_EGL) { + break; + case trace::API_EGL: prog = QLatin1String("eglretrace"); - } else { - Q_ASSERT(0); + break; + case trace::API_DX: + case trace::API_D3D7: + case trace::API_D3D8: + case trace::API_D3D9: + case trace::API_DXGI: +#ifdef Q_OS_WIN + prog = QLatin1String("d3dretrace"); +#else + prog = QLatin1String("wine"); + arguments << QLatin1String("d3dretrace.exe"); +#endif + break; + default: + emit finished(QLatin1String("Unsupported API")); return; } - if (m_doubleBuffered) { - arguments << QLatin1String("-db"); - } else { - arguments << QLatin1String("-sb"); - } - if (m_captureState) { arguments << QLatin1String("-D"); arguments << QString::number(m_captureCall); } else if (m_captureThumbnails) { arguments << QLatin1String("-s"); // emit snapshots arguments << QLatin1String("-"); // emit to stdout - } else if (m_benchmarking) { - arguments << QLatin1String("-b"); + } else if (isProfiling()) { + if (m_profileGpu) { + arguments << QLatin1String("--pgpu"); + } + + if (m_profileCpu) { + arguments << QLatin1String("--pcpu"); + } + + if (m_profilePixels) { + arguments << QLatin1String("--ppd"); + } + } else { + if (m_doubleBuffered) { + arguments << QLatin1String("--db"); + } else { + arguments << QLatin1String("--sb"); + } + + if (m_benchmarking) { + arguments << QLatin1String("-b"); + } } arguments << m_fileName; + /* + * Support remote execution on a separate target. + */ + + if (m_remoteTarget.length() != 0) { + arguments.prepend(prog); + arguments.prepend(m_remoteTarget); + prog = QLatin1String("ssh"); + } + /* * Start the process. */ QProcess process; - process.start(prog, arguments); + process.start(prog, arguments, QIODevice::ReadOnly); if (!process.waitForStarted(-1)) { emit finished(QLatin1String("Could not start process")); return; @@ -164,28 +341,36 @@ void Retracer::run() QList thumbnails; QVariantMap parsedJson; + trace::Profile* profile = NULL; process.setReadChannel(QProcess::StandardOutput); if (process.waitForReadyRead(-1)) { + BlockingIODevice io(&process); + if (m_captureState) { /* * Parse JSON from the output. * - * XXX: QJSON does not wait for QIODevice::waitForReadyRead so we - * need to buffer all stdout. - * * XXX: QJSON's scanner is inneficient as it abuses single * character QIODevice::peek (not cheap), instead of maintaining a * lookahead character on its own. */ - if (!process.waitForFinished(-1)) { - return; - } - bool ok = false; QJson::Parser jsonParser; + + // Allow Nan/Infinity + jsonParser.allowSpecialNumbers(true); +#if 0 + parsedJson = jsonParser.parse(&io, &ok).toMap(); +#else + /* + * XXX: QJSON expects blocking IO, and it looks like + * BlockingIODevice does not work reliably in all cases. + */ + process.waitForFinished(-1); parsedJson = jsonParser.parse(&process, &ok).toMap(); +#endif if (!ok) { msg = QLatin1String("failed to parse JSON"); } @@ -194,20 +379,7 @@ void Retracer::run() * Parse concatenated PNM images from output. */ - while (true) { - /* - * QProcess::atEnd() documentation is wrong -- it will return - * true even when the process is running --, so try to handle - * that here. - */ - if (process.atEnd()) { - if (process.state() == QProcess::Running) { - if (!process.waitForReadyRead(-1)) { - break; - } - } - } - + while (!io.atEnd()) { unsigned channels = 0; unsigned width = 0; unsigned height = 0; @@ -217,14 +389,7 @@ void Retracer::run() int headerLines = 3; // assume no optional comment line for (int headerLine = 0; headerLine < headerLines; ++headerLine) { - while (!process.canReadLine()) { - if (!process.waitForReadyRead(-1)) { - qDebug() << "QProcess::waitForReadyRead failed"; - break; - } - } - - qint64 headerRead = process.readLine(&header[headerSize], sizeof(header) - headerSize); + qint64 headerRead = io.readLine(&header[headerSize], sizeof(header) - headerSize); // if header actually contains optional comment line, ... if (headerLine == 1 && header[headerSize] == '#') { @@ -249,28 +414,36 @@ void Retracer::run() int rowBytes = channels * width; for (int y = 0; y < height; ++y) { unsigned char *scanLine = snapshot.scanLine(y); - - while (process.bytesAvailable() < rowBytes) { - if (!process.waitForReadyRead(-1)) { - qDebug() << "QProcess::waitForReadyRead failed"; - break; - } - } - - qint64 read = process.read((char *) scanLine, rowBytes); - Q_ASSERT(read == rowBytes); + qint64 readBytes = io.read((char *) scanLine, rowBytes); + Q_ASSERT(readBytes == rowBytes); + (void)readBytes; } - QImage thumbnail = snapshot.scaled(16, 16, Qt::KeepAspectRatio, Qt::FastTransformation); - thumbnails.append(thumbnail); + QImage thumb = thumbnail(snapshot); + thumbnails.append(thumb); } Q_ASSERT(process.state() != QProcess::Running); + } else if (isProfiling()) { + profile = new trace::Profile(); + + while (!io.atEnd()) { + char line[256]; + qint64 lineLength; + + lineLength = io.readLine(line, 256); + if (lineLength == -1) + break; + + trace::Profiler::parseLine(line, profile); + } } else { QByteArray output; output = process.readAllStandardOutput(); - msg = QString::fromUtf8(output); + if (output.length() < 80) { + msg = QString::fromUtf8(output); + } } } @@ -301,6 +474,14 @@ void Retracer::run() error.type = regexp.cap(2); error.message = regexp.cap(3); errors.append(error); + } else if (!errors.isEmpty()) { + // Probably a multiligne message + ApiTraceError &previous = errors.last(); + if (line.endsWith("\n")) { + line.chop(1); + } + previous.message.append('\n'); + previous.message.append(line); } } @@ -311,13 +492,16 @@ void Retracer::run() if (m_captureState) { ApiTraceState *state = new ApiTraceState(parsedJson); emit foundState(state); - msg = QLatin1String("State fetched."); } if (m_captureThumbnails && !thumbnails.isEmpty()) { emit foundThumbnails(thumbnails); } + if (isProfiling() && profile) { + emit foundProfile(profile); + } + if (!errors.isEmpty()) { emit retraceErrors(errors); }