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

   1 #include "traceloader.h"
   2
   3 #include <QDebug>
   4 #include <QFile>
   5
   6 #define FRAMES_TO_CACHE 100
   7
   8 static ApiTraceCall *
   9 apiCallFromTraceCall(const Trace::Call *call,
  10                      const QHash<QString, QUrl> &helpHash,
  11                      ApiTraceFrame *frame,
  12                      TraceLoader *loader)
  13 {
  14     ApiTraceCall *apiCall = new ApiTraceCall(frame, loader, call);
  15
  16     apiCall->setHelpUrl(helpHash.value(apiCall->name()));
  17
  18     return apiCall;
  19 }
  20
  21 TraceLoader::TraceLoader(QObject *parent)
  22     : QObject(parent),
  23       m_frameMarker(ApiTrace::FrameMarker_SwapBuffers)
  24 {
  25 }
  26
  27 TraceLoader::~TraceLoader()
  28 {
  29     m_parser.close();
  30 }
  31
  32 void TraceLoader::loadTrace(const QString &filename)
  33 {
  34     if (m_helpHash.isEmpty()) {
  35         loadHelpFile();
  36     }
  37
  38     if (!m_parser.open(filename.toLatin1())) {
  39         qDebug() << "error: failed to open " << filename;
  40         return;
  41     }
  42     qDebug()<<"load trace with "<<filename;
  43     emit startedParsing();
  44
  45     qDebug() <<"\t support offsets = "<<m_parser.supportsOffsets();
  46     if (m_parser.supportsOffsets()) {
  47        scanTrace();
  48     } else {
  49        //Load the entire file into memory
  50        parseTrace();
  51     }
  52
  53     emit finishedParsing();
  54 }
  55
  56 void TraceLoader::loadFrame(int frameIdx)
  57 {
  58     if (m_parser.supportsOffsets()) {
  59         int numOfCalls = numberOfCallsInFrame(frameIdx);
  60         if (numOfCalls) {
  61             const FrameOffset &frameOffset = m_frameOffsets[frameIdx];
  62             std::vector<Trace::Call*> calls(numOfCalls);
  63             m_parser.setCurrentOffset(frameOffset.start);
  64             m_parser.setCurrentCallNumber(frameOffset.callNumber);
  65
  66             Trace::Call *call;
  67             int parsedCalls = 0;
  68             while ((call = m_parser.parse_call())) {
  69
  70                 calls[parsedCalls] = call;
  71                 ++parsedCalls;
  72
  73                 if (isCallAFrameMarker(call)) {
  74                     break;
  75                 }
  76
  77             }
  78             assert(parsedCalls == numOfCalls);
  79 //            emit parsedFrame();
  80         }
  81     }
  82 }
  83
  84 void TraceLoader::setFrameMarker(ApiTrace::FrameMarker marker)
  85 {
  86     m_frameMarker = marker;
  87 }
  88
  89 bool TraceLoader::isCallAFrameMarker(const Trace::Call *call) const
  90 {
  91     std::string name = call->name();
  92
  93     switch (m_frameMarker) {
  94     case ApiTrace::FrameMarker_SwapBuffers:
  95        return  name.find("SwapBuffers") != std::string::npos ||
  96                name == "CGLFlushDrawable" ||
  97                name == "glFrameTerminatorGREMEDY";
  98        break;
  99     case ApiTrace::FrameMarker_Flush:
 100        return name == "glFlush";
 101        break;
 102     case ApiTrace::FrameMarker_Finish:
 103        return name == "glFinish";
 104        break;
 105     case ApiTrace::FrameMarker_Clear:
 106        return name == "glClear";
 107        break;
 108     }
 109     return false;
 110 }
 111
 112 int TraceLoader::numberOfFrames() const
 113 {
 114     return m_frameOffsets.size();
 115 }
 116
 117 int TraceLoader::numberOfCallsInFrame(int frameIdx) const
 118 {
 119     if (frameIdx > m_frameOffsets.size()) {
 120         return 0;
 121     }
 122     FrameOffsets::const_iterator itr =
 123           m_frameOffsets.find(frameIdx);
 124     return itr->numberOfCalls;
 125 }
 126
 127 void TraceLoader::loadHelpFile()
 128 {
 129    QFile file(":/resources/glreference.tsv");
 130    if (file.open(QIODevice::ReadOnly | QIODevice::Text)) {
 131       QString line;
 132       while (!file.atEnd()) {
 133          line = file.readLine();
 134          QString function = line.section('\t', 0, 0).trimmed();
 135          QUrl url = QUrl(line.section('\t', 1, 1).trimmed());
 136          //qDebug()<<"function = "<<function<<", url = "<<url.toString();
 137          m_helpHash.insert(function, url);
 138       }
 139    } else {
 140       qWarning() << "Couldn't open reference file "
 141                  << file.fileName();
 142    }
 143    file.close();
 144 }
 145
 146 void TraceLoader::scanTrace()
 147 {
 148    QList<ApiTraceFrame*> frames;
 149    ApiTraceFrame *currentFrame = 0;
 150
 151    Trace::Call *call;
 152    Trace::File::Offset startOffset;
 153    int numOfFrames = 0;
 154    int numOfCalls = 0;
 155    unsigned callNum = 0;
 156    int lastPercentReport = 0;
 157
 158    startOffset = m_parser.currentOffset();
 159    callNum = m_parser.currentCallNumber();
 160
 161    while ((call = m_parser.scan_call())) {
 162        ++numOfCalls;
 163
 164        if (isCallAFrameMarker(call)) {
 165            Trace::File::Offset endOffset = m_parser.currentOffset();
 166            FrameOffset frameOffset(startOffset);
 167            frameOffset.numberOfCalls = numOfCalls;
 168            frameOffset.callNumber = callNum;
 169
 170            currentFrame = new ApiTraceFrame();
 171            currentFrame->number = numOfFrames;
 172            currentFrame->setNumChildren(numOfCalls);
 173            frames.append(currentFrame);
 174
 175            m_frameOffsets[numOfFrames] = frameOffset;
 176            ++numOfFrames;
 177
 178            if (m_parser.percentRead() - lastPercentReport >= 5) {
 179                emit parsed(m_parser.percentRead());
 180                lastPercentReport = m_parser.percentRead();
 181            }
 182            startOffset = endOffset;
 183            callNum = m_parser.currentCallNumber();
 184            numOfCalls = 0;
 185        }
 186        //call->dump(std::cout, color);
 187        delete call;
 188    }
 189
 190    if (numOfCalls) {
 191 //      Trace::File::Offset endOffset = m_parser.currentOffset();
 192       FrameOffset frameOffset(startOffset);
 193       frameOffset.numberOfCalls = numOfCalls;
 194       frameOffset.callNumber = callNum;
 195
 196       currentFrame = new ApiTraceFrame();
 197       currentFrame->number = numOfFrames;
 198       currentFrame->setNumChildren(numOfCalls);
 199       frames.append(currentFrame);
 200
 201       m_frameOffsets[numOfFrames] = frameOffset;
 202       ++numOfFrames;
 203    }
 204
 205    emit parsed(100);
 206
 207    emit framesLoaded(frames);
 208 }
 209
 210 void TraceLoader::parseTrace()
 211 {
 212    QList<ApiTraceFrame*> frames;
 213    ApiTraceFrame *currentFrame = 0;
 214    int frameCount = 0;
 215    QVector<ApiTraceCall*> calls;
 216    quint64 binaryDataSize = 0;
 217
 218    int lastPercentReport = 0;
 219
 220    Trace::Call *call = m_parser.parse_call();
 221    while (call) {
 222       //std::cout << *call;
 223       if (!currentFrame) {
 224          currentFrame = new ApiTraceFrame();
 225          currentFrame->number = frameCount;
 226          ++frameCount;
 227       }
 228       ApiTraceCall *apiCall =
 229             apiCallFromTraceCall(call, m_helpHash, currentFrame, this);
 230       calls.append(apiCall);
 231       if (apiCall->hasBinaryData()) {
 232          QByteArray data =
 233                apiCall->arguments()[apiCall->binaryDataIndex()].toByteArray();
 234          binaryDataSize += data.size();
 235       }
 236       if (ApiTrace::isCallAFrameMarker(apiCall,
 237                                        m_frameMarker)) {
 238          calls.squeeze();
 239          currentFrame->setCalls(calls, binaryDataSize);
 240          calls.clear();
 241          frames.append(currentFrame);
 242          currentFrame = 0;
 243          binaryDataSize = 0;
 244          if (frames.count() >= FRAMES_TO_CACHE) {
 245             emit framesLoaded(frames);
 246             frames.clear();
 247          }
 248          if (m_parser.percentRead() - lastPercentReport >= 5) {
 249             emit parsed(m_parser.percentRead());
 250             lastPercentReport = m_parser.percentRead();
 251          }
 252       }
 253       delete call;
 254       call = m_parser.parse_call();
 255    }
 256
 257    //last frames won't have markers
 258    //  it's just a bunch of Delete calls for every object
 259    //  after the last SwapBuffers
 260    if (currentFrame) {
 261        calls.squeeze();
 262        currentFrame->setCalls(calls, binaryDataSize);
 263        frames.append(currentFrame);
 264        currentFrame = 0;
 265    }
 266    if (frames.count()) {
 267        emit framesLoaded(frames);
 268    }
 269 }
 270
 271
 272 ApiTraceCallSignature * TraceLoader::signature(unsigned id)
 273 {
 274     if (id >= m_signatures.count()) {
 275         m_signatures.resize(id + 1);
 276         return NULL;
 277     } else {
 278         return m_signatures[id];
 279     }
 280 }
 281
 282 void TraceLoader::addSignature(unsigned id, ApiTraceCallSignature *signature)
 283 {
 284     m_signatures[id] = signature;
 285 }
 286
 287 ApiTraceEnumSignature * TraceLoader::enumSignature(unsigned id)
 288 {
 289     if (id >= m_enumSignatures.count()) {
 290         m_enumSignatures.resize(id + 1);
 291         return NULL;
 292     } else {
 293         return m_enumSignatures[id];
 294     }
 295 }
 296
 297 void TraceLoader::addEnumSignature(unsigned id, ApiTraceEnumSignature *signature)
 298 {
 299     m_enumSignatures[id] = signature;
 300 }
 301
 302 #include "traceloader.moc"