Add a file identifier to snappy compressed traces

[apitrace] / trace_file.cpp

diff --git a/trace_file.cpp b/trace_file.cpp
index 4bba837c74062e2695b28ddf3dca4fa3fa210488..27b3eb18c07d10eb7e0a2fc3e5dc1bdd9e366b26 100644 (file)
--- a/trace_file.cpp
+++ b/trace_file.cpp
@@ -10,6 +10,9 @@
 
 using namespace Trace;
 
+#define SNAPPY_BYTE1 'a'
+#define SNAPPY_BYTE2 't'
+
 File::File(const std::string &filename,
            File::Mode mode)
     : m_filename(filename),
@@ -21,11 +24,9 @@ File::File(const std::string &filename,
     }
 }
 
-static size_t writtenRef = 0;
 
 File::~File()
 {
-    std::cerr << "written ref = "<<writtenRef << std::endl;
     close();
 }
 
@@ -59,7 +60,6 @@ bool File::write(const void *buffer, int length)
     if (!m_isOpened || m_mode != File::Write) {
         return false;
     }
-    writtenRef += length;
     return rawWrite(buffer, length);
 }
 
@@ -84,7 +84,7 @@ void File::flush()
     rawFlush();
 }
 
-char File::getc()
+int File::getc()
 {
     if (!m_isOpened || m_mode != File::Read) {
         return 0;
@@ -92,6 +92,38 @@ char File::getc()
     return rawGetc();
 }
 
+bool File::isZLibCompressed(const std::string &filename)
+{
+    std::fstream stream(filename.c_str(),
+                        std::fstream::binary | std::fstream::in);
+    if (!stream.is_open())
+        return false;
+
+    unsigned char byte1, byte2;
+    stream >> byte1;
+    stream >> byte2;
+    stream.close();
+
+    return (byte1 == 0x1f && byte2 == 0x8b);
+}
+
+
+bool File::isSnappyCompressed(const std::string &filename)
+{
+    std::fstream stream(filename.c_str(),
+                        std::fstream::binary | std::fstream::in);
+    if (!stream.is_open())
+        return false;
+
+    unsigned char byte1, byte2;
+    stream >> byte1;
+    stream >> byte2;
+    stream.close();
+
+    return (byte1 == SNAPPY_BYTE1 && byte2 == SNAPPY_BYTE2);
+}
+
+
 ZLibFile::ZLibFile(const std::string &filename,
                    File::Mode mode)
     : File(filename, mode),
@@ -120,7 +152,7 @@ bool ZLibFile::rawRead(void *buffer, int length)
     return gzread(m_gzFile, buffer, length) != -1;
 }
 
-char ZLibFile::rawGetc()
+int ZLibFile::rawGetc()
 {
     return gzgetc(m_gzFile);
 }
@@ -153,9 +185,6 @@ SnappyFile::~SnappyFile()
     delete [] m_compressedCache;
 }
 
-static size_t written = 0;
-static size_t writtenComp = 0;
-
 bool SnappyFile::rawOpen(const std::string &filename, File::Mode mode)
 {
     std::ios_base::openmode fmode = std::fstream::binary;
@@ -170,22 +199,23 @@ bool SnappyFile::rawOpen(const std::string &filename, File::Mode mode)
 
     //read in the initial buffer if we're reading
     if (m_stream.is_open() && mode == File::Read) {
+        // read the snappy file identifier
+        unsigned char byte1, byte2;
+        m_stream >> byte1;
+        m_stream >> byte2;
+        assert(byte1 == SNAPPY_BYTE1 && byte2 == SNAPPY_BYTE2);
+
         flushCache();
+    } else if (m_stream.is_open() && mode == File::Write) {
+        // write the snappy file identifier
+        m_stream << SNAPPY_BYTE1;
+        m_stream << SNAPPY_BYTE2;
     }
     return m_stream.is_open();
 }
 
 bool SnappyFile::rawWrite(const void *buffer, int length)
 {
-    static int bufWritten = 0;
-    if (bufWritten < 500) {
-        const char *cbuffer = (const char*)buffer;
-        for (int i = 0; i < length; ++i) {
-            std::cerr << "--- "<<bufWritten << ") "<< (int) cbuffer[i]
-                      << std::endl;
-            ++ bufWritten;
-        }
-    }
     if (freeCacheSize() > length) {
         memcpy(m_cachePtr, buffer, length);
         m_cachePtr += length;
@@ -216,19 +246,19 @@ bool SnappyFile::rawWrite(const void *buffer, int length)
 
 bool SnappyFile::rawRead(void *buffer, int length)
 {
-    std::cerr << "Reading byte = "<< (m_cachePtr - m_cache) << std::endl;
+    if (m_stream.eof()) {
+        return false;
+    }
     if (freeCacheSize() > length) {
         memcpy(buffer, m_cachePtr, length);
         m_cachePtr += length;
     } else if (freeCacheSize() == length) {
         memcpy(buffer, m_cachePtr, length);
         m_cachePtr += length;
-        assert(0);
         flushCache();
     } else {
         int sizeToRead = length;
         int offset = 0;
-        assert(0);
         while (sizeToRead) {
             int chunkSize = std::min(freeCacheSize(), sizeToRead);
             offset = length - sizeToRead;
@@ -243,19 +273,17 @@ bool SnappyFile::rawRead(void *buffer, int length)
     return true;
 }
 
-char SnappyFile::rawGetc()
+int SnappyFile::rawGetc()
 {
-    char c;
-    rawRead(&c, 1);
+    int c = 0;
+    if (!rawRead(&c, 1))
+        return -1;
     return c;
 }
 
 void SnappyFile::rawClose()
 {
     flushCache();
-    std::cerr << "written = "<< written
-              <<", comp = "<< writtenComp
-              << std::endl;
     m_stream.close();
     delete [] m_cache;
     m_cache = NULL;
@@ -272,27 +300,11 @@ void SnappyFile::flushCache()
     if (m_mode == File::Write) {
         size_t compressedLength;
 
-        static bool first = true;
-        if (first) {
-            std::cerr << "Buffer = [";
-            for (int i = 0; i < 512; ++i) {
-                std::cerr << i << " ) "<< (int)m_cache[i] << std::endl;
-            }
-            std::cerr << "]"<<std::endl;
-            first = false;
-        }
-
         ::snappy::RawCompress(m_cache, SNAPPY_CHUNK_SIZE - freeCacheSize(),
                               m_compressedCache, &compressedLength);
 
         m_stream << compressedLength;
         m_stream.write(m_compressedCache, compressedLength);
-        std::cerr << "compressed length = "<<compressedLength
-                  <<" cache size = "<<(SNAPPY_CHUNK_SIZE - freeCacheSize())
-                  <<" (ref = " << SNAPPY_CHUNK_SIZE <<")"
-                  << std::endl;
-        written += SNAPPY_CHUNK_SIZE - freeCacheSize();
-        writtenComp += compressedLength;
         m_cachePtr = m_cache;
     } else if (m_mode == File::Read) {
         if (m_stream.eof())
@@ -303,24 +315,11 @@ void SnappyFile::flushCache()
         m_stream.read((char*)m_compressedCache, compressedLength);
         ::snappy::GetUncompressedLength(m_compressedCache, compressedLength,
                                         &m_cacheSize);
-        std::cerr << "compressed length = "<<compressedLength
-                  <<" cache size = "<<m_cacheSize
-                  <<" (ref = " << SNAPPY_CHUNK_SIZE <<")"
-                  << std::endl;
         if (m_cache)
             delete [] m_cache;
         createCache(m_cacheSize);
         ::snappy::RawUncompress(m_compressedCache, compressedLength,
                                 m_cache);
-        static bool first = true;
-        if (first) {
-            std::cerr << "Buffer = [";
-            for (int i = 0; i < 512; ++i) {
-                std::cerr << i << " ) "<< (int)m_cache[i] << std::endl;
-            }
-            std::cerr << "]"<<std::endl;
-            first = false;
-        }
     }
 }