git.cworth.org Git - apitrace/blob - trace_loader.cpp

   1 #include "trace_loader.hpp"
   2
   3 #include "trace_snappyfile.hpp"
   4
   5 using namespace Trace;
   6
   7 Loader::Loader()
   8     : m_frameMarker(FrameMarker_SwapBuffers)
   9 {
  10 }
  11
  12 Loader::~Loader()
  13 {
  14     close();
  15 }
  16
  17 Loader::FrameMarker Loader::frameMarker() const
  18 {
  19     return m_frameMarker;
  20 }
  21
  22 void Loader::setFrameMarker(Loader::FrameMarker marker)
  23 {
  24     m_frameMarker = marker;
  25 }
  26
  27 int Loader::numberOfFrames() const
  28 {
  29     return m_frameOffsets.size();
  30 }
  31
  32 int Loader::numberOfCallsInFrame(int frameIdx) const
  33 {
  34     if (frameIdx > m_frameOffsets.size()) {
  35         return 0;
  36     }
  37     FrameOffsets::const_iterator itr =
  38         m_frameOffsets.find(frameIdx);
  39     return itr->second.numberOfCalls;
  40 }
  41
  42 bool Loader::open(const char *filename)
  43 {
  44     if (!m_parser.open(filename)) {
  45         std::cerr << "error: failed to open " << filename << "\n";
  46         return false;
  47     }
  48     if (!m_parser.supportsOffsets()) {
  49         std::cerr << "error: " <<filename<< " doesn't support seeking "
  50                   << "\n";
  51         return false;
  52     }
  53
  54     Trace::Call *call;
  55     File::Offset startOffset;
  56     int numOfFrames = 0;
  57     int numOfCalls = 0;
  58     unsigned callNum = 0;
  59     int lastPercentReport = 0;
  60
  61     startOffset = m_parser.currentOffset();
  62     callNum = m_parser.currentCallNumber();
  63
  64     while ((call = m_parser.scan_call())) {
  65         ++numOfCalls;
  66
  67         if (isCallAFrameMarker(call)) {
  68             File::Offset endOffset = m_parser.currentOffset();
  69             FrameOffset frameOffset(startOffset);
  70             frameOffset.numberOfCalls = numOfCalls;
  71             frameOffset.callNumber = callNum;
  72
  73             m_frameOffsets[numOfFrames] = frameOffset;
  74             ++numOfFrames;
  75
  76             if (m_parser.percentRead() - lastPercentReport >= 5) {
  77                 std::cerr << "\tPercent scanned = "
  78                           << m_parser.percentRead()
  79                           << "..."<<std::endl;
  80                 lastPercentReport = m_parser.percentRead();
  81             }
  82             startOffset = endOffset;
  83             callNum = m_parser.currentCallNumber();
  84             numOfCalls = 0;
  85         }
  86         //call->dump(std::cout, color);
  87         delete call;
  88     }
  89     return true;
  90 }
  91
  92 void Loader::close()
  93 {
  94     m_parser.close();
  95 }
  96
  97 bool Loader::isCallAFrameMarker(const Trace::Call *call) const
  98 {
  99     std::string name = call->name();
 100
 101     switch (m_frameMarker) {
 102     case FrameMarker_SwapBuffers:
 103         return  name.find("SwapBuffers") != std::string::npos ||
 104                 name == "CGLFlushDrawable" ||
 105                 name == "glFrameTerminatorGREMEDY";
 106         break;
 107     case FrameMarker_Flush:
 108         return name == "glFlush";
 109         break;
 110     case FrameMarker_Finish:
 111         return name == "glFinish";
 112         break;
 113     case FrameMarker_Clear:
 114         return name == "glClear";
 115         break;
 116     }
 117     return false;
 118 }
 119
 120 std::vector<Trace::Call *> Loader::frame(int idx)
 121 {
 122     int numOfCalls = numberOfCallsInFrame(idx);
 123     if (numOfCalls) {
 124         const FrameOffset &frameOffset = m_frameOffsets[idx];
 125         std::vector<Trace::Call*> calls(numOfCalls);
 126         m_parser.setCurrentOffset(frameOffset.start);
 127         m_parser.setCurrentCallNumber(frameOffset.callNumber);
 128
 129         Trace::Call *call;
 130         int parsedCalls = 0;
 131         while ((call = m_parser.parse_call())) {
 132
 133             calls[parsedCalls] = call;
 134             ++parsedCalls;
 135
 136             if (isCallAFrameMarker(call)) {
 137                 break;
 138             }
 139
 140         }
 141         assert(parsedCalls == numOfCalls);
 142         return calls;
 143     }
 144     return std::vector<Trace::Call*>();
 145 }