git.cworth.org Git - apitrace/blob - gui/retracer.cpp

   1 #include "retracer.h"
   2
   3 #include "apitracecall.h"
   4 #include "thumbnail.h"
   5
   6 #include "image/image.hpp"
   7
   8 #include "trace_profiler.hpp"
   9
  10 #include <QDebug>
  11 #include <QVariant>
  12 #include <QList>
  13 #include <QImage>
  14
  15 #include <qjson/parser.h>
  16
  17 /**
  18  * Wrapper around a QProcess which enforces IO to block .
  19  *
  20  * Several QIODevice users (notably QJSON) expect blocking semantics, e.g.,
  21  * they expect that QIODevice::read() will blocked until the requested ammount
  22  * of bytes is read or end of file is reached. But by default QProcess, does
  23  * not block.  And passing QIODevice::Unbuffered mitigates but does not fully
  24  * address the problem either.
  25  *
  26  * This class wraps around QProcess, providing QIODevice interface, while
  27  * ensuring that all reads block.
  28  *
  29  * This class also works around a bug in QProcess::atEnd() implementation.
  30  *
  31  * See also:
  32  * - http://qt-project.org/wiki/Simple_Crypt_IO_Device
  33  * - http://qt-project.org/wiki/Custom_IO_Device
  34  */
  35 class BlockingIODevice : public QIODevice
  36 {
  37     /* We don't use the Q_OBJECT in this class given we don't declare any
  38      * signals and slots or use any other services provided by Qt's meta-object
  39      * system. */
  40 public:
  41     BlockingIODevice(QProcess * io);
  42     bool isSequential() const;
  43     bool atEnd() const;
  44     bool waitForReadyRead(int msecs = -1);
  45
  46 protected:
  47     qint64 readData(char * data, qint64 maxSize);
  48     qint64 writeData(const char * data, qint64 maxSize);
  49
  50 private:
  51     QProcess *m_device;
  52 };
  53
  54 BlockingIODevice::BlockingIODevice(QProcess * io) :
  55     m_device(io)
  56 {
  57     /*
  58      * We pass QIODevice::Unbuffered to prevent the base QIODevice class to do
  59      * its own buffering on top of the overridden readData() method.
  60      *
  61      * The only buffering used will be to satisfy QIODevice::peek() and
  62      * QIODevice::ungetChar().
  63      */
  64     setOpenMode(ReadOnly | Unbuffered);
  65 }
  66
  67 bool BlockingIODevice::isSequential() const
  68 {
  69     return true;
  70 }
  71
  72 bool BlockingIODevice::atEnd() const
  73 {
  74     /*
  75      * XXX: QProcess::atEnd() documentation is wrong -- it will return true
  76      * even when the process is running --, so we try to workaround that here.
  77      */
  78     if (m_device->atEnd()) {
  79         if (m_device->state() == QProcess::Running) {
  80             if (!m_device->waitForReadyRead(-1)) {
  81                 return true;
  82             }
  83         }
  84     }
  85     return false;
  86 }
  87
  88 bool BlockingIODevice::waitForReadyRead(int msecs)
  89 {
  90     Q_UNUSED(msecs);
  91     return true;
  92 }
  93
  94 qint64 BlockingIODevice::readData(char * data, qint64 maxSize)
  95 {
  96     qint64 bytesToRead = maxSize;
  97     qint64 readSoFar = 0;
  98     do {
  99         qint64 chunkSize = m_device->read(data + readSoFar, bytesToRead);
 100         if (chunkSize < 0) {
 101             if (readSoFar) {
 102                 return readSoFar;
 103             } else {
 104                 return chunkSize;
 105             }
 106         }
 107         Q_ASSERT(chunkSize <= bytesToRead);
 108         bytesToRead -= chunkSize;
 109         readSoFar += chunkSize;
 110         if (bytesToRead) {
 111             if (!m_device->waitForReadyRead(-1)) {
 112                 qDebug() << "waitForReadyRead failed\n";
 113                 break;
 114             }
 115         }
 116     } while(bytesToRead);
 117
 118     return readSoFar;
 119 }
 120
 121 qint64 BlockingIODevice::writeData(const char * data, qint64 maxSize)
 122 {
 123     Q_ASSERT(false);
 124     return -1;
 125 }
 126
 127 Q_DECLARE_METATYPE(QList<ApiTraceError>);
 128
 129 Retracer::Retracer(QObject *parent)
 130     : QThread(parent),
 131       m_benchmarking(false),
 132       m_doubleBuffered(true),
 133       m_captureState(false),
 134       m_captureCall(0),
 135       m_profileGpu(false),
 136       m_profileCpu(false),
 137       m_profilePixels(false)
 138 {
 139     qRegisterMetaType<QList<ApiTraceError> >();
 140 }
 141
 142 QString Retracer::fileName() const
 143 {
 144     return m_fileName;
 145 }
 146
 147 void Retracer::setFileName(const QString &name)
 148 {
 149     m_fileName = name;
 150 }
 151
 152 QString Retracer::remoteTarget() const
 153 {
 154     return m_remoteTarget;
 155 }
 156
 157 void Retracer::setRemoteTarget(const QString &host)
 158 {
 159     m_remoteTarget = host;
 160 }
 161
 162 void Retracer::setAPI(trace::API api)
 163 {
 164     m_api = api;
 165 }
 166
 167 bool Retracer::isBenchmarking() const
 168 {
 169     return m_benchmarking;
 170 }
 171
 172 void Retracer::setBenchmarking(bool bench)
 173 {
 174     m_benchmarking = bench;
 175 }
 176
 177 bool Retracer::isDoubleBuffered() const
 178 {
 179     return m_doubleBuffered;
 180 }
 181
 182 void Retracer::setDoubleBuffered(bool db)
 183 {
 184     m_doubleBuffered = db;
 185 }
 186
 187 bool Retracer::isProfilingGpu() const
 188 {
 189     return m_profileGpu;
 190 }
 191
 192 bool Retracer::isProfilingCpu() const
 193 {
 194     return m_profileCpu;
 195 }
 196
 197 bool Retracer::isProfilingPixels() const
 198 {
 199     return m_profilePixels;
 200 }
 201
 202 bool Retracer::isProfiling() const
 203 {
 204     return m_profileGpu || m_profileCpu || m_profilePixels;
 205 }
 206
 207 void Retracer::setProfiling(bool gpu, bool cpu, bool pixels)
 208 {
 209     m_profileGpu = gpu;
 210     m_profileCpu = cpu;
 211     m_profilePixels = pixels;
 212 }
 213
 214 void Retracer::setCaptureAtCallNumber(qlonglong num)
 215 {
 216     m_captureCall = num;
 217 }
 218
 219 qlonglong Retracer::captureAtCallNumber() const
 220 {
 221     return m_captureCall;
 222 }
 223
 224 bool Retracer::captureState() const
 225 {
 226     return m_captureState;
 227 }
 228
 229 void Retracer::setCaptureState(bool enable)
 230 {
 231     m_captureState = enable;
 232 }
 233
 234 bool Retracer::captureThumbnails() const
 235 {
 236     return m_captureThumbnails;
 237 }
 238
 239 void Retracer::setCaptureThumbnails(bool enable)
 240 {
 241     m_captureThumbnails = enable;
 242 }
 243
 244 /**
 245  * Starting point for the retracing thread.
 246  *
 247  * Overrides QThread::run().
 248  */
 249 void Retracer::run()
 250 {
 251     QString msg = QLatin1String("Replay finished!");
 252
 253     /*
 254      * Construct command line
 255      */
 256
 257     QString prog;
 258     QStringList arguments;
 259
 260     switch (m_api) {
 261     case trace::API_GL:
 262         prog = QLatin1String("glretrace");
 263         break;
 264     case trace::API_EGL:
 265         prog = QLatin1String("eglretrace");
 266         break;
 267     case trace::API_DX:
 268     case trace::API_D3D7:
 269     case trace::API_D3D8:
 270     case trace::API_D3D9:
 271     case trace::API_DXGI:
 272 #ifdef Q_OS_WIN
 273         prog = QLatin1String("d3dretrace");
 274 #else
 275         prog = QLatin1String("wine");
 276         arguments << QLatin1String("d3dretrace.exe");
 277 #endif
 278         break;
 279     default:
 280         emit finished(QLatin1String("Unsupported API"));
 281         return;
 282     }
 283
 284     if (m_captureState) {
 285         arguments << QLatin1String("-D");
 286         arguments << QString::number(m_captureCall);
 287     } else if (m_captureThumbnails) {
 288         arguments << QLatin1String("-s"); // emit snapshots
 289         arguments << QLatin1String("-"); // emit to stdout
 290     } else if (isProfiling()) {
 291         if (m_profileGpu) {
 292             arguments << QLatin1String("--pgpu");
 293         }
 294
 295         if (m_profileCpu) {
 296             arguments << QLatin1String("--pcpu");
 297         }
 298
 299         if (m_profilePixels) {
 300             arguments << QLatin1String("--ppd");
 301         }
 302     } else {
 303         if (m_doubleBuffered) {
 304             arguments << QLatin1String("--db");
 305         } else {
 306             arguments << QLatin1String("--sb");
 307         }
 308
 309         if (m_benchmarking) {
 310             arguments << QLatin1String("-b");
 311         }
 312     }
 313
 314     arguments << m_fileName;
 315
 316     /*
 317      * Support remote execution on a separate target.
 318      */
 319
 320     if (m_remoteTarget.length() != 0) {
 321         arguments.prepend(prog);
 322         arguments.prepend(m_remoteTarget);
 323         prog = QLatin1String("ssh");
 324     }
 325
 326     /*
 327      * Start the process.
 328      */
 329
 330     QProcess process;
 331
 332     process.start(prog, arguments, QIODevice::ReadOnly);
 333     if (!process.waitForStarted(-1)) {
 334         emit finished(QLatin1String("Could not start process"));
 335         return;
 336     }
 337
 338     /*
 339      * Process standard output
 340      */
 341
 342     QList<QImage> thumbnails;
 343     QVariantMap parsedJson;
 344     trace::Profile* profile = NULL;
 345
 346     process.setReadChannel(QProcess::StandardOutput);
 347     if (process.waitForReadyRead(-1)) {
 348         BlockingIODevice io(&process);
 349
 350         if (m_captureState) {
 351             /*
 352              * Parse JSON from the output.
 353              *
 354              * XXX: QJSON's scanner is inneficient as it abuses single
 355              * character QIODevice::peek (not cheap), instead of maintaining a
 356              * lookahead character on its own.
 357              */
 358
 359             bool ok = false;
 360             QJson::Parser jsonParser;
 361
 362             // Allow Nan/Infinity
 363             jsonParser.allowSpecialNumbers(true);
 364 #if 0
 365             parsedJson = jsonParser.parse(&io, &ok).toMap();
 366 #else
 367             /*
 368              * XXX: QJSON expects blocking IO, and it looks like
 369              * BlockingIODevice does not work reliably in all cases.
 370              */
 371             process.waitForFinished(-1);
 372             parsedJson = jsonParser.parse(&process, &ok).toMap();
 373 #endif
 374             if (!ok) {
 375                 msg = QLatin1String("failed to parse JSON");
 376             }
 377         } else if (m_captureThumbnails) {
 378             /*
 379              * Parse concatenated PNM images from output.
 380              */
 381
 382             while (!io.atEnd()) {
 383                 unsigned channels = 0;
 384                 unsigned width = 0;
 385                 unsigned height = 0;
 386
 387                 char header[512];
 388                 qint64 headerSize = 0;
 389                 int headerLines = 3; // assume no optional comment line
 390
 391                 for (int headerLine = 0; headerLine < headerLines; ++headerLine) {
 392                     qint64 headerRead = io.readLine(&header[headerSize], sizeof(header) - headerSize);
 393
 394                     // if header actually contains optional comment line, ...
 395                     if (headerLine == 1 && header[headerSize] == '#') {
 396                         ++headerLines;
 397                     }
 398
 399                     headerSize += headerRead;
 400                 }
 401
 402                 const char *headerEnd = image::readPNMHeader(header, headerSize, &channels, &width, &height);
 403
 404                 // if invalid PNM header was encountered, ...
 405                 if (header == headerEnd) {
 406                     qDebug() << "error: invalid snapshot stream encountered";
 407                     break;
 408                 }
 409
 410                 // qDebug() << "channels: " << channels << ", width: " << width << ", height: " << height";
 411
 412                 QImage snapshot = QImage(width, height, channels == 1 ? QImage::Format_Mono : QImage::Format_RGB888);
 413
 414                 int rowBytes = channels * width;
 415                 for (int y = 0; y < height; ++y) {
 416                     unsigned char *scanLine = snapshot.scanLine(y);
 417                     qint64 readBytes = io.read((char *) scanLine, rowBytes);
 418                     Q_ASSERT(readBytes == rowBytes);
 419                     (void)readBytes;
 420                 }
 421
 422                 QImage thumb = thumbnail(snapshot);
 423                 thumbnails.append(thumb);
 424             }
 425
 426             Q_ASSERT(process.state() != QProcess::Running);
 427         } else if (isProfiling()) {
 428             profile = new trace::Profile();
 429
 430             while (!io.atEnd()) {
 431                 char line[256];
 432                 qint64 lineLength;
 433
 434                 lineLength = io.readLine(line, 256);
 435
 436                 if (lineLength == -1)
 437                     break;
 438
 439                 trace::Profiler::parseLine(line, profile);
 440             }
 441         } else {
 442             QByteArray output;
 443             output = process.readAllStandardOutput();
 444             if (output.length() < 80) {
 445                 msg = QString::fromUtf8(output);
 446             }
 447         }
 448     }
 449
 450     /*
 451      * Wait for process termination
 452      */
 453
 454     process.waitForFinished(-1);
 455
 456     if (process.exitStatus() != QProcess::NormalExit) {
 457         msg = QLatin1String("Process crashed");
 458     } else if (process.exitCode() != 0) {
 459         msg = QLatin1String("Process exited with non zero exit code");
 460     }
 461
 462     /*
 463      * Parse errors.
 464      */
 465
 466     QList<ApiTraceError> errors;
 467     process.setReadChannel(QProcess::StandardError);
 468     QRegExp regexp("(^\\d+): +(\\b\\w+\\b): ([^\\r\\n]+)[\\r\\n]*$");
 469     while (!process.atEnd()) {
 470         QString line = process.readLine();
 471         if (regexp.indexIn(line) != -1) {
 472             ApiTraceError error;
 473             error.callIndex = regexp.cap(1).toInt();
 474             error.type = regexp.cap(2);
 475             error.message = regexp.cap(3);
 476             errors.append(error);
 477         } else if (!errors.isEmpty()) {
 478             // Probably a multiligne message
 479             ApiTraceError &previous = errors.last();
 480             if (line.endsWith("\n")) {
 481                 line.chop(1);
 482             }
 483             previous.message.append('\n');
 484             previous.message.append(line);
 485         }
 486     }
 487
 488     /*
 489      * Emit signals
 490      */
 491
 492     if (m_captureState) {
 493         ApiTraceState *state = new ApiTraceState(parsedJson);
 494         emit foundState(state);
 495     }
 496
 497     if (m_captureThumbnails && !thumbnails.isEmpty()) {
 498         emit foundThumbnails(thumbnails);
 499     }
 500
 501     if (isProfiling() && profile) {
 502         emit foundProfile(profile);
 503     }
 504
 505     if (!errors.isEmpty()) {
 506         emit retraceErrors(errors);
 507     }
 508
 509     emit finished(msg);
 510 }
 511
 512 #include "retracer.moc"