Merge branch 'master' into on-demand-loading

Conflicts:
	trace_snappyfile.cpp

diff --git a/trace_file.hpp b/trace_file.hpp
index 487121187fdd9dad368fe631445b3ffea218a80e..c096ef934d24c000c662a6b6ea7a4824d1c3d9fb 100644 (file)
--- a/trace_file.hpp
+++ b/trace_file.hpp
@@ -139,7 +139,9 @@ inline void File::close()
 
 inline void File::flush(void)
 {
-    rawFlush();
+    if (m_mode == File::Write) {
+        rawFlush();
+    }
 }
 
 inline int File::getc()

diff --git a/trace_snappyfile.cpp b/trace_snappyfile.cpp
index cea4e6866c45fb14d529df6652bd8755c4b60c53..db20abb97e120df95dcad10438c58fb67666ad81 100644 (file)
--- a/trace_snappyfile.cpp
+++ b/trace_snappyfile.cpp
@@ -99,7 +99,7 @@ bool SnappyFile::rawOpen(const std::string &filename, File::Mode mode)
         m_stream >> byte2;
         assert(byte1 == SNAPPY_BYTE1 && byte2 == SNAPPY_BYTE2);
 
-        flushCache();
+        flushReadCache();
     } else if (m_stream.is_open() && mode == File::Write) {
         // write the snappy file identifier
         m_stream << SNAPPY_BYTE1;
@@ -116,7 +116,7 @@ bool SnappyFile::rawWrite(const void *buffer, size_t length)
     } else if (freeCacheSize() == length) {
         memcpy(m_cachePtr, buffer, length);
         m_cachePtr += length;
-        flushCache();
+        flushWriteCache();
     } else {
         int sizeToWrite = length;
 
@@ -126,7 +126,7 @@ bool SnappyFile::rawWrite(const void *buffer, size_t length)
             memcpy(m_cachePtr, (const char*)buffer + offset, endSize);
             sizeToWrite -= endSize;
             m_cachePtr += endSize;
-            flushCache();
+            flushWriteCache();
         }
         if (sizeToWrite) {
             int offset = length - sizeToWrite;
@@ -156,10 +156,12 @@ bool SnappyFile::rawRead(void *buffer, size_t length)
             memcpy((char*)buffer + offset, m_cachePtr, chunkSize);
             m_cachePtr += chunkSize;
             sizeToRead -= chunkSize;
-            if (sizeToRead > 0)
-                flushCache();
-            if (!m_cacheSize)
+            if (sizeToRead > 0) {
+                flushReadCache();
+            }
+            if (!m_cacheSize) {
                 break;
+            }
         }
     }
 
@@ -176,7 +178,9 @@ int SnappyFile::rawGetc()
 
 void SnappyFile::rawClose()
 {
-    flushCache();
+    if (m_mode == File::Write) {
+        flushWriteCache();
+    }
     m_stream.close();
     delete [] m_cache;
     m_cache = NULL;
@@ -185,42 +189,44 @@ void SnappyFile::rawClose()
 
 void SnappyFile::rawFlush()
 {
-    flushCache();
+    assert(m_mode == File::Write);
+    flushWriteCache();
     m_stream.flush();
 }
 
-void SnappyFile::flushCache()
+void SnappyFile::flushWriteCache()
 {
-    if (m_mode == File::Write) {
-        size_t inputLength = usedCacheSize();
+    size_t inputLength = usedCacheSize();
 
-        if (inputLength) {
-            size_t compressedLength;
+    if (inputLength) {
+        size_t compressedLength;
 
-            ::snappy::RawCompress(m_cache, inputLength,
-                                  m_compressedCache, &compressedLength);
+        ::snappy::RawCompress(m_cache, inputLength,
+                              m_compressedCache, &compressedLength);
 
-            writeCompressedLength(compressedLength);
-            m_stream.write(m_compressedCache, compressedLength);
-            m_cachePtr = m_cache;
-        }
-        assert(m_cachePtr == m_cache);
-    } else if (m_mode == File::Read) {
-        //assert(m_cachePtr == m_cache + m_cacheSize);
-        m_currentOffset.chunk = m_stream.tellg();
-        size_t compressedLength;
-        compressedLength = readCompressedLength();
-
-        if (compressedLength) {
-            m_stream.read((char*)m_compressedCache, compressedLength);
-            ::snappy::GetUncompressedLength(m_compressedCache, compressedLength,
-                                            &m_cacheSize);
-            createCache(m_cacheSize);
-            ::snappy::RawUncompress(m_compressedCache, compressedLength,
-                                    m_cache);
-        } else {
-            createCache(0);
-        }
+        writeCompressedLength(compressedLength);
+        m_stream.write(m_compressedCache, compressedLength);
+        m_cachePtr = m_cache;
+    }
+    assert(m_cachePtr == m_cache);
+}
+
+void SnappyFile::flushReadCache()
+{
+    //assert(m_cachePtr == m_cache + m_cacheSize);
+    m_currentOffset.chunk = m_stream.tellg();
+    size_t compressedLength;
+    compressedLength = readCompressedLength();
+
+    if (compressedLength) {
+        m_stream.read((char*)m_compressedCache, compressedLength);
+        ::snappy::GetUncompressedLength(m_compressedCache, compressedLength,
+                                        &m_cacheSize);
+        createCache(m_cacheSize);
+        ::snappy::RawUncompress(m_compressedCache, compressedLength,
+                                m_cache);
+    } else {
+        createCache(0);
     }
 }
 
@@ -287,7 +293,7 @@ void SnappyFile::setCurrentOffset(const File::Offset &offset)
     // seek to the start of a chunk
     m_stream.seekg(offset.chunk, std::ios::beg);
     // load the chunk
-    flushCache();
+    flushReadCache();
     assert(m_cacheSize >= offset.offsetInChunk);
     // seek within our cache to the correct location within the chunk
     m_cachePtr = m_cache + offset.offsetInChunk;
@@ -308,10 +314,12 @@ bool SnappyFile::rawSkip(unsigned length)
             size_t chunkSize = std::min(freeCacheSize(), sizeToRead);
             m_cachePtr += chunkSize;
             sizeToRead -= chunkSize;
-            if (sizeToRead > 0)
-                flushCache();
-            if (!m_cacheSize)
+            if (sizeToRead > 0) {
+                flushReadCache();
+            }
+            if (!m_cacheSize) {
                 break;
+            }
         }
     }
 

diff --git a/trace_snappyfile.hpp b/trace_snappyfile.hpp
index 398ff7900c335a4c7f3b55d8afe0e643c5651e49..f1623b9c737f11d800b16120df302b95bcda8279 100644 (file)
--- a/trace_snappyfile.hpp
+++ b/trace_snappyfile.hpp
@@ -83,7 +83,8 @@ private:
     {
         return m_stream.eof() && freeCacheSize() == 0;
     }
-    void flushCache();
+    void flushWriteCache();
+    void flushReadCache();
     void createCache(size_t size);
     void writeCompressedLength(size_t length);
     size_t readCompressedLength();