Allow partial load of data from dump.

server/TracyWorker.cpp

@@ -38,7 +38,7 @@ Worker::Worker( const char* addr )
     SetThreadName( m_thread, "Tracy Worker" );
 }
 
-Worker::Worker( FileRead& f )
+Worker::Worker( FileRead& f, EventType::Type eventMask )
     : m_connected( false )
     , m_hasData( true )
     , m_shutdown( false )
@@ -136,6 +136,8 @@ Worker::Worker( FileRead& f )
 #endif
 
     f.Read( &sz, sizeof( sz ) );
+    if( eventMask & EventType::Locks )
+    {
         for( uint64_t i=0; i<sz; i++ )
         {
             LockMap lockmap;
@@ -175,9 +177,27 @@ Worker::Worker( FileRead& f )
             }
             m_data.lockMap.emplace( id, std::move( lockmap ) );
         }
+    }
+    else
+    {
+        for( uint64_t i=0; i<sz; i++ )
+        {
+            LockType type;
+            uint64_t tsz;
+            f.Skip( sizeof( uint32_t ) + sizeof( LockMap::srcloc ) );
+            f.Read( &type, sizeof( type ) );
+            f.Skip( sizeof( LockMap::valid ) );
+            f.Read( &tsz, sizeof( tsz ) );
+            f.Skip( tsz * sizeof( uint64_t ) );
+            f.Read( &tsz, sizeof( tsz ) );
+            f.Skip( tsz * ( type == LockType::Lockable ? sizeof( LockEvent ) : sizeof( LockEventShared ) ) );
+        }
+    }
 
     flat_hash_map<uint64_t, MessageData*, nohash<uint64_t>> msgMap;
     f.Read( &sz, sizeof( sz ) );
+    if( eventMask & EventType::Messages )
+    {
         m_data.messages.reserve( sz );
         for( uint64_t i=0; i<sz; i++ )
         {
@@ -188,6 +208,11 @@ Worker::Worker( FileRead& f )
             m_data.messages.push_back_no_space_check( msgdata );
             msgMap.emplace( ptr, msgdata );
         }
+    }
+    else
+    {
+        f.Skip( sz * ( sizeof( uint64_t ) + sizeof( MessageData ) ) );
+    }
 
     f.Read( &sz, sizeof( sz ) );
     m_data.threads.reserve( sz );
@@ -199,6 +224,8 @@ Worker::Worker( FileRead& f )
         ReadTimeline( f, td->timeline, CompressThread( td->id ) );
         uint64_t msz;
         f.Read( &msz, sizeof( msz ) );
+        if( eventMask & EventType::Messages )
+        {
             td->messages.reserve( msz );
             for( uint64_t j=0; j<msz; j++ )
             {
@@ -206,6 +233,11 @@ Worker::Worker( FileRead& f )
                 f.Read( &ptr, sizeof( ptr ) );
                 td->messages.push_back_no_space_check( msgMap[ptr] );
             }
+        }
+        else
+        {
+            f.Skip( msz * sizeof( uint64_t ) );
+        }
         m_data.threads.push_back_no_space_check( td );
     }
 
@@ -230,6 +262,8 @@ Worker::Worker( FileRead& f )
     }
 
     f.Read( &sz, sizeof( sz ) );
+    if( eventMask & EventType::Plots )
+    {
         m_data.plots.reserve( sz );
         for( uint64_t i=0; i<sz; i++ )
         {
@@ -243,11 +277,24 @@ Worker::Worker( FileRead& f )
             f.Read( pd->data.data(), psz * sizeof( PlotItem ) );
             m_data.plots.push_back_no_space_check( pd );
         }
+    }
+    else
+    {
+        for( uint64_t i=0; i<sz; i++ )
+        {
+            f.Skip( sizeof( PlotData::name ) + sizeof( PlotData::min ) + sizeof( PlotData::max ) );
+            uint64_t psz;
+            f.Read( &psz, sizeof( psz ) );
+            f.Skip( psz * sizeof( PlotItem ) );
+        }
+    }
 
     // Support pre-0.3 traces
     if( f.IsEOF() ) return;
 
     f.Read( &sz, sizeof( sz ) );
+    if( eventMask & EventType::Memory )
+    {
         m_data.memory.data.reserve_and_use( sz );
         auto mem = m_data.memory.data.data();
         for( uint64_t i=0; i<sz; i++ )
@@ -273,6 +320,18 @@ Worker::Worker( FileRead& f )
         f.Read( &m_data.memory.low, sizeof( m_data.memory.low ) );
         f.Read( &m_data.memory.usage, sizeof( m_data.memory.usage ) );
     }
+    else
+    {
+        f.Skip( sz * (
+            sizeof( MemEvent::ptr ) +
+            sizeof( MemEvent::size ) +
+            sizeof( MemEvent::timeAlloc ) +
+            sizeof( MemEvent::timeFree ) +
+            sizeof( uint64_t ) +
+            sizeof( uint64_t ) ) );
+        f.Skip( sizeof( MemData::high ) + sizeof( MemData::low ) + sizeof( MemData::usage ) );
+    }
+}
 
 Worker::~Worker()
 {

server/TracyWorker.hpp

@@ -23,6 +23,20 @@ namespace tracy
 class FileRead;
 class FileWrite;
 
+namespace EventType
+{
+    enum Type : uint32_t
+    {
+        Locks       = 1 << 0,
+        Messages    = 1 << 1,
+        Plots       = 1 << 2,
+        Memory      = 1 << 3,
+
+        None        = 0,
+        All         = std::numeric_limits<uint32_t>::max()
+    };
+}
+
 class Worker
 {
 #pragma pack( 1 )
@@ -91,7 +105,7 @@ class Worker
 
 public:
     Worker( const char* addr );
-    Worker( FileRead& f );
+    Worker( FileRead& f, EventType::Type eventMask = EventType::All );
     ~Worker();
 
     const std::string& GetAddr() const { return m_addr; }