]> git.cworth.org Git - apitrace/blob - gui/retracer.cpp
glretrace: Flush outstanding requests when waiting for user input.
[apitrace] / 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"