From: José Fonseca Date: Wed, 24 Aug 2011 18:58:47 +0000 (+0100) Subject: Merge branch 'master' into compression X-Git-Url: https://git.cworth.org/git?p=apitrace;a=commitdiff_plain;h=1035b94bc86d70dc0f6af1adcf7f20fd5d2bdca3 Merge branch 'master' into compression Conflicts: os.hpp os_posix.cpp os_win32.cpp trace_writer.cpp --- 1035b94bc86d70dc0f6af1adcf7f20fd5d2bdca3 diff --cc trace_file.cpp index 74cc382,0000000..2a9705c mode 100644,000000..100644 --- a/trace_file.cpp +++ b/trace_file.cpp @@@ -1,387 -1,0 +1,339 @@@ +#include "trace_file.hpp" + +#include +#include + +#include +#include + +#include "os.hpp" + +#include - #include + +using namespace Trace; + +#define SNAPPY_BYTE1 'a' +#define SNAPPY_BYTE2 't' + - static void cleanupHandler(int sig); - - class FileCleanup - { - public: - FileCleanup() - { - OS::CatchInterrupts(cleanupHandler); - } - - ~FileCleanup() - { - flush(); - m_files.clear(); - } - - void addFile(Trace::File *file) - { - m_files.insert(file); - } - void removeFile(Trace::File *file) - { - m_files.erase(file); - } - - void flush() - { - std::set::const_iterator itr; - for (itr = m_files.begin(); itr != m_files.end(); ++itr) { - (*itr)->flush(File::FlushDeep); - } - } - - private: - std::set m_files; - }; - static FileCleanup s_cleaner; - - static void cleanupHandler(int sig) - { - s_cleaner.flush(); - } - +File::File(const std::string &filename, + File::Mode mode) + : m_filename(filename), + m_mode(mode), + m_isOpened(false) +{ + if (!m_filename.empty()) { + open(m_filename, m_mode); + } +} + + +File::~File() +{ + close(); +} + +bool File::isOpened() const +{ + return m_isOpened; +} + +File::Mode File::mode() const +{ + return m_mode; +} + +std::string File::filename() const +{ + return m_filename; +} + +bool File::open(const std::string &filename, File::Mode mode) +{ + if (m_isOpened) { + close(); + } + m_isOpened = rawOpen(filename, mode); + m_mode = mode; + - if (m_isOpened) { - s_cleaner.addFile(this); - } + return m_isOpened; +} + +bool File::write(const void *buffer, int length) +{ + if (!m_isOpened || m_mode != File::Write) { + return false; + } + return rawWrite(buffer, length); +} + +bool File::read(void *buffer, int length) +{ + if (!m_isOpened || m_mode != File::Read) { + return false; + } + return rawRead(buffer, length); +} + +void File::close() +{ + if (m_isOpened) { + rawClose(); + m_isOpened = false; - s_cleaner.removeFile(this); + } +} + +void File::flush(FlushType type) +{ + rawFlush(type); +} + +int File::getc() +{ + if (!m_isOpened || m_mode != File::Read) { + return 0; + } + 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), + m_gzFile(NULL) +{ +} + +ZLibFile::~ZLibFile() +{ +} + +bool ZLibFile::rawOpen(const std::string &filename, File::Mode mode) +{ + m_gzFile = gzopen(filename.c_str(), + (mode == File::Write) ? "wb" : "rb"); + return m_gzFile != NULL; +} + +bool ZLibFile::rawWrite(const void *buffer, int length) +{ + return gzwrite(m_gzFile, buffer, length) != -1; +} + +bool ZLibFile::rawRead(void *buffer, int length) +{ + return gzread(m_gzFile, buffer, length) != -1; +} + +int ZLibFile::rawGetc() +{ + return gzgetc(m_gzFile); +} + +void ZLibFile::rawClose() +{ + if (m_gzFile) { + gzclose(m_gzFile); + m_gzFile = NULL; + } +} + +void ZLibFile::rawFlush(FlushType type) +{ + gzflush(m_gzFile, Z_SYNC_FLUSH); +} + +SnappyFile::SnappyFile(const std::string &filename, + File::Mode mode) + : File(), + m_cache(0), + m_cachePtr(0), + m_cacheSize(0) +{ + m_compressedCache = new char[SNAPPY_CHUNK_SIZE]; +} + +SnappyFile::~SnappyFile() +{ + delete [] m_compressedCache; +} + +bool SnappyFile::rawOpen(const std::string &filename, File::Mode mode) +{ + std::ios_base::openmode fmode = std::fstream::binary; + if (mode == File::Write) { + fmode |= (std::fstream::out | std::fstream::trunc); + createCache(SNAPPY_CHUNK_SIZE); + } else if (mode == File::Read) { + fmode |= std::fstream::in; + } + + m_stream.open(filename.c_str(), fmode); + + //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) +{ + if (freeCacheSize() > length) { + memcpy(m_cachePtr, buffer, length); + m_cachePtr += length; + } else if (freeCacheSize() == length) { + memcpy(m_cachePtr, buffer, length); + m_cachePtr += length; + flushCache(); + } else { + int sizeToWrite = length; + + while (sizeToWrite >= freeCacheSize()) { + int endSize = freeCacheSize(); + int offset = length - sizeToWrite; + memcpy(m_cachePtr, (char*)buffer + offset, endSize); + sizeToWrite -= endSize; + m_cachePtr += endSize; + flushCache(); + } + if (sizeToWrite) { + int offset = length - sizeToWrite; + memcpy(m_cachePtr, (char*)buffer + offset, sizeToWrite); + m_cachePtr += sizeToWrite; + } + } + + return true; +} + +bool SnappyFile::rawRead(void *buffer, int length) +{ + 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; + flushCache(); + } else { + int sizeToRead = length; + int offset = 0; + while (sizeToRead) { + int chunkSize = std::min(freeCacheSize(), sizeToRead); + offset = length - sizeToRead; + memcpy((char*)buffer + offset, m_cachePtr, chunkSize); + m_cachePtr += chunkSize; + sizeToRead -= chunkSize; + if (sizeToRead > 0) + flushCache(); + if (!m_cacheSize) + break; + } + } + + return true; +} + +int SnappyFile::rawGetc() +{ + int c = 0; + if (!rawRead(&c, 1)) + return -1; + return c; +} + +void SnappyFile::rawClose() +{ + flushCache(); + m_stream.close(); + delete [] m_cache; + m_cache = NULL; + m_cachePtr = NULL; +} + +void SnappyFile::rawFlush(FlushType type) +{ + if (type == FlushDeep) { + flushCache(); + } + m_stream.flush(); +} + +void SnappyFile::flushCache() +{ + if (m_mode == File::Write) { + size_t compressedLength; + + ::snappy::RawCompress(m_cache, SNAPPY_CHUNK_SIZE - freeCacheSize(), + m_compressedCache, &compressedLength); + + m_stream << compressedLength; + m_stream.write(m_compressedCache, compressedLength); + m_cachePtr = m_cache; + } else if (m_mode == File::Read) { + if (m_stream.eof()) + return; + //assert(m_cachePtr == m_cache + m_cacheSize); + size_t compressedLength; + m_stream >> compressedLength; + m_stream.read((char*)m_compressedCache, compressedLength); + ::snappy::GetUncompressedLength(m_compressedCache, compressedLength, + &m_cacheSize); + if (m_cache) + delete [] m_cache; + createCache(m_cacheSize); + ::snappy::RawUncompress(m_compressedCache, compressedLength, + m_cache); + } +} + +void SnappyFile::createCache(size_t size) +{ + m_cache = new char[size]; + m_cachePtr = m_cache; + m_cacheSize = size; +} diff --cc trace_local_writer.cpp index 0000000,ae6a6b6..ea6c111 mode 000000,100644..100644 --- a/trace_local_writer.cpp +++ b/trace_local_writer.cpp @@@ -1,0 -1,157 +1,156 @@@ + /************************************************************************** + * + * Copyright 2007-2011 VMware, Inc. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + * THE SOFTWARE. + * + **************************************************************************/ + + + #include + #include + #include + #include + #include + -#include - + #include "os.hpp" ++#include "trace_file.hpp" + #include "trace_writer.hpp" + #include "trace_format.hpp" + + + namespace Trace { + + + static void exceptionCallback(void) + { + OS::DebugMessage("apitrace: flushing trace due to an exception\n"); + localWriter.flush(); + } + + + LocalWriter::LocalWriter() : + acquired(0) + {} + + LocalWriter::~LocalWriter() + { + OS::ResetExceptionCallback(); + } + + void + LocalWriter::open(void) { + + static unsigned dwCounter = 0; + + const char *szExtension = "trace"; + char szFileName[PATH_MAX]; + const char *lpFileName; + + lpFileName = getenv("TRACE_FILE"); + if (lpFileName) { + strncpy(szFileName, lpFileName, PATH_MAX); + } + else { + char szProcessName[PATH_MAX]; + char szCurrentDir[PATH_MAX]; + OS::GetProcessName(szProcessName, PATH_MAX); + OS::GetCurrentDir(szCurrentDir, PATH_MAX); + + for (;;) { + FILE *file; + + if (dwCounter) + snprintf(szFileName, PATH_MAX, "%s%c%s.%u.%s", szCurrentDir, PATH_SEP, szProcessName, dwCounter, szExtension); + else + snprintf(szFileName, PATH_MAX, "%s%c%s.%s", szCurrentDir, PATH_SEP, szProcessName, szExtension); + + file = fopen(szFileName, "rb"); + if (file == NULL) + break; + + fclose(file); + + ++dwCounter; + } + } + + OS::DebugMessage("apitrace: tracing to %s\n", szFileName); + + Writer::open(szFileName); + + OS::SetExceptionCallback(exceptionCallback); + + #if 0 + // For debugging the exception handler + *((int *)0) = 0; + #endif + } + + unsigned LocalWriter::beginEnter(const FunctionSig *sig) { + OS::AcquireMutex(); + ++acquired; + - if (!g_gzFile) { ++ if (!m_file->isOpened()) { + open(); + } + + return Writer::beginEnter(sig); + } + + void LocalWriter::endEnter(void) { + Writer::endEnter(); + --acquired; + OS::ReleaseMutex(); + } + + void LocalWriter::beginLeave(unsigned call) { + OS::AcquireMutex(); + ++acquired; + Writer::beginLeave(call); + } + + void LocalWriter::endLeave(void) { + Writer::endLeave(); + --acquired; + OS::ReleaseMutex(); + } + + void LocalWriter::flush(void) { + /* + * Do nothing if the mutex is already acquired (e.g., if a segfault happen + * while writing the file) to prevent dead-lock. + */ + + if (!acquired) { + OS::AcquireMutex(); - if (g_gzFile) { - gzflush(g_gzFile, Z_SYNC_FLUSH); - } ++ if (m_file->isOpened()) { ++ m_file->flush(); ++ } + OS::ReleaseMutex(); + } + } + + + LocalWriter localWriter; + + + } /* namespace Trace */ +