trace_writer.cpp
trace_local_writer.cpp
trace_model_writer.cpp
+ trace_loader.cpp
image.cpp
image_bmp.cpp
image_pnm.cpp
add_executable (tracedump tracedump.cpp)
install (TARGETS tracedump RUNTIME DESTINATION bin)
+add_executable (loadertest loadertest.cpp)
+install (TARGETS loadertest RUNTIME DESTINATION bin)
##############################################################################
# API tracers
--- /dev/null
+#include "trace_loader.hpp"
+
+#include <iostream>
+
+int main(int argc, char **argv)
+{
+ int i;
+
+ for (i = 1; i < argc; ++i) {
+ Trace::Loader loader;
+
+ if (!loader.open(argv[i])) {
+ std::cerr << "error: failed to open " << argv[i] << "\n";
+ return 1;
+ }
+
+ std::cout << "Number of frames = "
+ << loader.numberOfFrames()
+ << std::endl;
+ std::cout << "Number of calls in frame 0 = "
+ << loader.numberOfCallsInFrame(0)
+ << std::endl;
+ int lastFrame = loader.numberOfFrames() - 1;
+ std::cout << "Number of calls in frame "
+ << lastFrame << " = "
+ << loader.numberOfCallsInFrame(lastFrame)
+ << std::endl;
+
+
+ std::vector<Trace::Call*> frame = loader.frame(
+ 0);
+ std::vector<Trace::Call*>::const_iterator itr;
+ for (itr = frame.begin(); itr != frame.end(); ++itr) {
+ (*itr)->dump(std::cout, true);
+ }
+ }
+
+
+ return 0;
+}
+
close();
}
+
+File::Offset File::currentOffset()
+{
+ return File::Offset();
+}
+
+void File::setCurrentOffset(const File::Offset &offset)
+{
+}
+
bool File::isZLibCompressed(const std::string &filename)
{
std::fstream stream(filename.c_str(),
{
gzflush(m_gzFile, Z_SYNC_FLUSH);
}
+
+
+bool ZLibFile::supportsOffsets() const
+{
+ return false;
+}
#include <string>
#include <fstream>
+#include <stdint.h>
namespace Trace {
Read,
Write
};
+ struct Offset {
+ Offset()
+ : chunk(0),
+ offsetInChunk(0)
+ {}
+ uint64_t chunk;
+ uint32_t offsetInChunk;
+ };
+
public:
static bool isZLibCompressed(const std::string &filename);
static bool isSnappyCompressed(const std::string &filename);
void flush(void);
int getc();
+ virtual bool supportsOffsets() const = 0;
+ virtual File::Offset currentOffset();
+ virtual void setCurrentOffset(const File::Offset &offset);
protected:
virtual bool rawOpen(const std::string &filename, File::Mode mode) = 0;
virtual bool rawWrite(const void *buffer, int length) = 0;
File::Mode mode = File::Read);
virtual ~ZLibFile();
+
+ virtual bool supportsOffsets() const;
protected:
virtual bool rawOpen(const std::string &filename, File::Mode mode);
virtual bool rawWrite(const void *buffer, int length);
--- /dev/null
+#include "trace_loader.hpp"
+
+#include "trace_snappyfile.hpp"
+
+using namespace Trace;
+
+Loader::Loader()
+ : m_frameMarker(FrameMarker_SwapBuffers),
+ file(0)
+{
+}
+
+Loader::~Loader()
+{
+ close();
+}
+
+Loader::FrameMarker Loader::frameMarker() const
+{
+ return m_frameMarker;
+}
+
+void Loader::setFrameMarker(Loader::FrameMarker marker)
+{
+ m_frameMarker = marker;
+}
+
+int Loader::numberOfFrames() const
+{
+ return m_frameOffsets.size();
+}
+
+int Loader::numberOfCallsInFrame(int frameIdx)
+{
+ if (frameIdx > m_frameOffsets.size()) {
+ return 0;
+ }
+
+ return m_frameOffsets[frameIdx].numberOfCalls;
+}
+
+bool Loader::open(const char *filename)
+{
+ if (!m_parser.open(filename)) {
+ std::cerr << "error: failed to open " << filename << "\n";
+ return false;
+ }
+
+ Trace::Call *call;
+ File::Offset startOffset;
+ int numOfFrames = 0;
+ int numOfCalls = 0;
+
+ startOffset = m_parser.currentOffset();
+
+ while ((call = m_parser.parse_call())) {
+
+ ++numOfCalls;
+
+ if (isCallAFrameMarker(call)) {
+ File::Offset endOffset = m_parser.currentOffset();
+ FrameOffset frameOffset(startOffset, endOffset);
+
+ frameOffset.numberOfCalls = numOfCalls;
+ m_frameOffsets[numOfFrames] = frameOffset;
+ ++numOfFrames;
+
+ startOffset = endOffset;
+ numOfCalls = 0;
+ }
+ //call->dump(std::cout, color);
+ delete call;
+ }
+ return true;
+}
+
+void Loader::close()
+{
+ m_parser.close();
+}
+
+bool Loader::isCallAFrameMarker(const Trace::Call *call) const
+{
+ std::string name = call->name();
+
+ switch (m_frameMarker) {
+ case FrameMarker_SwapBuffers:
+ return name.find("SwapBuffers") != std::string::npos ||
+ name == "CGLFlushDrawable" ||
+ name == "glFrameTerminatorGREMEDY";
+ break;
+ case FrameMarker_Flush:
+ return name == "glFlush";
+ break;
+ case FrameMarker_Finish:
+ return name == "glFinish";
+ break;
+ case FrameMarker_Clear:
+ return name == "glClear";
+ break;
+ }
+ return false;
+}
+
+std::vector<Trace::Call *> Trace::Loader::frame(int idx)
+{
+ int numOfCalls = numberOfCallsInFrame(idx);
+ if (numOfCalls) {
+ std::vector<Trace::Call*> calls(numOfCalls);
+ m_parser.setCurrentOffset(m_frameOffsets[idx].start);
+
+ Trace::Call *call;
+ int parsedCalls = 0;
+ while ((call = m_parser.parse_call())) {
+
+ if (isCallAFrameMarker(call)) {
+ break;
+ }
+
+ calls[parsedCalls] = call;
+ ++parsedCalls;
+ }
+ return calls;
+ }
+ return std::vector<Trace::Call*>();
+}
--- /dev/null
+#ifndef TRACE_LOADER_HPP
+#define TRACE_LOADER_HPP
+
+#include "trace_file.hpp"
+#include "trace_parser.hpp"
+
+#include <string>
+#include <map>
+#include <queue>
+#include <vector>
+
+namespace Trace {
+
+class Frame;
+
+class Loader
+{
+public:
+ enum FrameMarker {
+ FrameMarker_SwapBuffers,
+ FrameMarker_Flush,
+ FrameMarker_Finish,
+ FrameMarker_Clear
+ };
+public:
+ Loader();
+ ~Loader();
+
+ Loader::FrameMarker frameMarker() const;
+ void setFrameMarker(Loader::FrameMarker marker);
+
+ int numberOfFrames() const;
+ int numberOfCallsInFrame(int frameIdx);
+
+ bool open(const char *filename);
+ void close();
+
+ std::vector<Trace::Call*> frame(int idx);
+
+private:
+ struct FrameOffset {
+ FrameOffset()
+ : numberOfCalls(0)
+ {}
+ FrameOffset(const File::Offset &s,
+ const File::Offset &e)
+ : start(s),
+ end(e),
+ numberOfCalls(0)
+ {}
+
+ File::Offset start;
+ File::Offset end;
+ int numberOfCalls;
+ };
+ bool isCallAFrameMarker(const Trace::Call *call) const;
+
+private:
+ Trace::Parser m_parser;
+ FrameMarker m_frameMarker;
+
+ std::map<int, Trace::Frame*> m_frameCache;
+ std::queue<Trace::Frame*> m_loadedFrames;
+
+ std::map<int, FrameOffset> m_frameOffsets;
+
+ Trace::File *file;
+};
+
+}
+
+#endif // TRACE_LOADER_HPP
template <typename Container>
inline void
-deleteAll(const Container &c)
+deleteAll(Container &c)
{
deleteAll(c.begin(), c.end());
+ c.clear();
}
void Parser::close(void) {
#include <iostream>
#include <list>
+#include "trace_file.hpp"
#include "trace_format.hpp"
#include "trace_model.hpp"
namespace Trace {
-class File;
-
class Parser
{
protected:
Call *parse_call(void);
+ bool supportsOffsets() const
+ {
+ return file-supportsOffsets();
+ }
+
+ File::Offset currentOffset()
+ {
+ return file->currentOffset();
+ }
+
+ void setCurrentOffset(const File::Offset &offset)
+ {
+ file->setCurrentOffset(offset);
+ }
+
protected:
void parse_enter(void);
#include <snappy.h>
+#include <iostream>
+
#include <assert.h>
#include <string.h>
bool SnappyFile::rawRead(void *buffer, int length)
{
- if (m_stream.eof()) {
+ if (endOfData()) {
return false;
}
- if (freeCacheSize() > length) {
- memcpy(buffer, m_cachePtr, length);
- m_cachePtr += length;
- } else if (freeCacheSize() == length) {
+
+ if (freeCacheSize() >= length) {
memcpy(buffer, m_cachePtr, length);
m_cachePtr += length;
- flushCache();
} else {
int sizeToRead = length;
int offset = 0;
if (m_stream.eof())
return;
//assert(m_cachePtr == m_cache + m_cacheSize);
+ m_currentOffset.chunk = m_stream.tellg();
size_t compressedLength;
compressedLength = readCompressedLength();
m_stream.read((char*)m_compressedCache, compressedLength);
+ /*
+ * The reason we peek here is because the last read will
+ * read all the way until the last character, but that will not
+ * trigger m_stream.eof() to be set, so by calling peek
+ * we assure that if we in fact have read the entire stream
+ * then the m_stream.eof() is always set.
+ */
+ m_stream.peek();
::snappy::GetUncompressedLength(m_compressedCache, compressedLength,
&m_cacheSize);
if (m_cache)
m_stream.read((char*)&len, sizeof len);
return len;
}
+
+bool SnappyFile::supportsOffsets() const
+{
+ return true;
+}
+
+File::Offset SnappyFile::currentOffset()
+{
+ m_currentOffset.offsetInChunk = m_cachePtr - m_cache;
+ return m_currentOffset;
+}
+
+void SnappyFile::setCurrentOffset(const File::Offset &offset)
+{
+ // to remove eof bit
+ m_stream.clear();
+ // seek to the start of a chunk
+ m_stream.seekg(offset.chunk, std::ios::beg);
+ // load the chunk
+ flushCache();
+ assert(m_cacheSize >= offset.offsetInChunk);
+ // seek within our cache to the correct location within the chunk
+ m_cachePtr = m_cache + offset.offsetInChunk;
+
+}
File::Mode mode = File::Read);
virtual ~SnappyFile();
+ virtual bool supportsOffsets() const;
+ virtual File::Offset currentOffset();
+ virtual void setCurrentOffset(const File::Offset &offset);
protected:
virtual bool rawOpen(const std::string &filename, File::Mode mode);
virtual bool rawWrite(const void *buffer, int length);
else
return 0;
}
+ inline bool endOfData() const
+ {
+ return m_stream.eof() && freeCacheSize() == 0;
+ }
+
void flushCache();
void createCache(size_t size);
void writeCompressedLength(uint32_t num);
size_t m_cacheSize;
char *m_compressedCache;
+
+ File::Offset m_currentOffset;
};
}
projects / apitrace / commitdiff