mirrors/tracy
1
0
Fork 0
mirror of https://github.com/wolfpld/tracy synced 2025-04-30 12:53:51 +00:00
Code Issues Releases Wiki Activity

Drop support for 0.7.x traces.

Browse Source
This commit is contained in:
Bartosz Taudul 2022-10-28 00:14:06 +02:00
parent 96c6898da3
commit bae7fb3e88
No known key found for this signature in database
GPG Key ID: B7FE2008B7575DF3
1 changed files with 103 additions and 328 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

431
server/TracyWorker.cpp
View File

@ -58,7 +58,7 @@ static bool SourceFileValid( const char* fn, uint64_t olderThan )
static const uint8_t FileHeader[8] { 't', 'r', 'a', 'c', 'y', Version::Major, Version::Minor, Version::Patch }; static const uint8_t FileHeader[8] { 't', 'r', 'a', 'c', 'y', Version::Major, Version::Minor, Version::Patch };
enum { FileHeaderMagic = 5 }; enum { FileHeaderMagic = 5 };
static const int CurrentVersion = FileVersion( Version::Major, Version::Minor, Version::Patch ); static const int CurrentVersion = FileVersion( Version::Major, Version::Minor, Version::Patch );
static const int MinSupportedVersion = FileVersion( 0, 7, 0 ); static const int MinSupportedVersion = FileVersion( 0, 8, 0 );
static void UpdateLockCountLockable( LockMap& lockmap, size_t pos ) static void UpdateLockCountLockable( LockMap& lockmap, size_t pos )
@ -606,14 +606,9 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
m_captureProgram = std::string( tmp, tmp+sz ); m_captureProgram = std::string( tmp, tmp+sz );
f.Read( m_captureTime ); f.Read( m_captureTime );
} }
if( fileVer >= FileVersion( 0, 7, 6 ) )
{ f.Read( m_executableTime );
f.Read( m_executableTime );
}
else
{
m_executableTime = 0;
}
{ {
f.Read( sz ); f.Read( sz );
assert( sz < 1024 ); assert( sz < 1024 );
@ -792,18 +787,15 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
status.first->second.zones.reserve( cnt ); status.first->second.zones.reserve( cnt );
} }
if( fileVer >= FileVersion( 0, 7, 15 ) ) f.Read( sz );
for( uint64_t i=0; i<sz; i++ )
{ {
f.Read( sz ); int16_t id;
for( uint64_t i=0; i<sz; i++ ) uint64_t cnt;
{ f.Read2( id, cnt );
int16_t id; auto status = m_data.gpuSourceLocationZones.emplace( id, GpuSourceLocationZones() );
uint64_t cnt; assert( status.second );
f.Read2( id, cnt ); status.first->second.zones.reserve( cnt );
auto status = m_data.gpuSourceLocationZones.emplace( id, GpuSourceLocationZones() );
assert( status.second );
status.first->second.zones.reserve( cnt );
}
} }
#else #else
f.Read( sz ); f.Read( sz );
@ -815,16 +807,13 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
m_data.sourceLocationZonesCnt.emplace( id, 0 ); m_data.sourceLocationZonesCnt.emplace( id, 0 );
} }
if( fileVer >= FileVersion( 0, 7, 15 ) ) f.Read( sz );
for( uint64_t i=0; i<sz; i++ )
{ {
f.Read( sz ); int16_t id;
for( uint64_t i=0; i<sz; i++ ) f.Read( id );
{ f.Skip( sizeof( uint64_t ) );
int16_t id; m_data.gpuSourceLocationZonesCnt.emplace( id, 0 );
f.Read( id );
f.Skip( sizeof( uint64_t ) );
m_data.gpuSourceLocationZonesCnt.emplace( id, 0 );
}
} }
#endif #endif
@ -929,25 +918,10 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
f.Skip( sz * ( sizeof( uint64_t ) + sizeof( MessageData::time ) + sizeof( MessageData::ref ) + sizeof( MessageData::color ) + sizeof( MessageData::callstack ) ) ); f.Skip( sz * ( sizeof( uint64_t ) + sizeof( MessageData::time ) + sizeof( MessageData::ref ) + sizeof( MessageData::color ) + sizeof( MessageData::callstack ) ) );
} }
if( fileVer >= FileVersion( 0, 7, 5 ) ) f.Read( sz );
{ assert( sz != 0 );
f.Read( sz ); m_data.zoneExtra.reserve_exact( sz, m_slab );
assert( sz != 0 ); f.Read( m_data.zoneExtra.data(), sz * sizeof( ZoneExtra ) );
m_data.zoneExtra.reserve_exact( sz, m_slab );
f.Read( m_data.zoneExtra.data(), sz * sizeof( ZoneExtra ) );
}
else
{
f.Read( sz );
assert( sz != 0 );
m_data.zoneExtra.reserve_exact( sz, m_slab );
for( uint64_t i=0; i<sz; i++ )
{
auto* zoneExtra = &m_data.zoneExtra[i];
f.Read3( zoneExtra->callstack, zoneExtra->text, zoneExtra->name );
zoneExtra->color = 0;
}
}
s_loadProgress.progress.store( LoadProgress::Zones, std::memory_order_relaxed ); s_loadProgress.progress.store( LoadProgress::Zones, std::memory_order_relaxed );
f.Read( sz ); f.Read( sz );
@ -963,21 +937,7 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
{ {
auto td = m_slab.AllocInit<ThreadData>(); auto td = m_slab.AllocInit<ThreadData>();
uint64_t tid; uint64_t tid;
if( fileVer >= FileVersion( 0, 7, 11 ) ) f.Read4( tid, td->count, td->kernelSampleCnt, td->isFiber );
{
f.Read4( tid, td->count, td->kernelSampleCnt, td->isFiber );
}
else if( fileVer >= FileVersion( 0, 7, 9 ) )
{
f.Read3( tid, td->count, td->kernelSampleCnt );
td->isFiber = 0;
}
else
{
f.Read2( tid, td->count );
td->kernelSampleCnt = 0;
td->isFiber = 0;
}
td->id = tid; td->id = tid;
m_data.zonesCnt += td->count; m_data.zonesCnt += td->count;
uint32_t tsz; uint32_t tsz;
@ -1005,31 +965,27 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
{ {
f.Skip( msz * sizeof( uint64_t ) ); f.Skip( msz * sizeof( uint64_t ) );
} }
if( fileVer >= FileVersion( 0, 7, 14 ) ) uint64_t ssz;
f.Read( ssz );
if( ssz != 0 )
{ {
uint64_t ssz; if( eventMask & EventType::Samples )
f.Read( ssz );
if( ssz != 0 )
{ {
if( eventMask & EventType::Samples ) int64_t refTime = 0;
td->ctxSwitchSamples.reserve_exact( ssz, m_slab );
auto ptr = td->ctxSwitchSamples.data();
for( uint64_t j=0; j<ssz; j++ )
{ {
int64_t refTime = 0; ptr->time.SetVal( ReadTimeOffset( f, refTime ) );
td->ctxSwitchSamples.reserve_exact( ssz, m_slab ); f.Read( &ptr->callstack, sizeof( ptr->callstack ) );
auto ptr = td->ctxSwitchSamples.data(); ptr++;
for( uint64_t j=0; j<ssz; j++ )
{
ptr->time.SetVal( ReadTimeOffset( f, refTime ) );
f.Read( &ptr->callstack, sizeof( ptr->callstack ) );
ptr++;
}
}
else
{
f.Skip( ssz * ( 8 + 3 ) );
} }
} }
else
{
f.Skip( ssz * ( 8 + 3 ) );
}
} }
uint64_t ssz;
f.Read( ssz ); f.Read( ssz );
if( ssz != 0 ) if( ssz != 0 )
{ {
@ -1068,33 +1024,9 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
for( uint64_t i=0; i<sz; i++ ) for( uint64_t i=0; i<sz; i++ )
{ {
auto ctx = m_slab.AllocInit<GpuCtxData>(); auto ctx = m_slab.AllocInit<GpuCtxData>();
if( fileVer >= FileVersion( 0, 7, 9 ) ) uint8_t calibration;
{ f.Read7( ctx->thread, calibration, ctx->count, ctx->period, ctx->type, ctx->name, ctx->overflow );
uint8_t calibration; ctx->hasCalibration = calibration;
f.Read7( ctx->thread, calibration, ctx->count, ctx->period, ctx->type, ctx->name, ctx->overflow );
ctx->hasCalibration = calibration;
}
else if( fileVer >= FileVersion( 0, 7, 6 ) )
{
uint8_t calibration;
f.Read6( ctx->thread, calibration, ctx->count, ctx->period, ctx->type, ctx->name );
ctx->hasCalibration = calibration;
ctx->overflow = 0;
}
else if( fileVer >= FileVersion( 0, 7, 1 ) )
{
uint8_t calibration;
f.Read5( ctx->thread, calibration, ctx->count, ctx->period, ctx->type );
ctx->hasCalibration = calibration;
ctx->overflow = 0;
}
else
{
uint8_t accuracy;
f.Read5( ctx->thread, accuracy, ctx->count, ctx->period, ctx->type );
ctx->hasCalibration = false;
ctx->overflow = 0;
}
ctx->hasPeriod = ctx->period != 1.f; ctx->hasPeriod = ctx->period != 1.f;
m_data.gpuCnt += ctx->count; m_data.gpuCnt += ctx->count;
uint64_t tdsz; uint64_t tdsz;
@ -1142,7 +1074,7 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
m_data.plots.Data().push_back_no_space_check( pd ); m_data.plots.Data().push_back_no_space_check( pd );
} }
} }
else if( fileVer >= FileVersion( 0, 7, 10 ) ) else
{ {
for( uint64_t i=0; i<sz; i++ ) for( uint64_t i=0; i<sz; i++ )
{ {
@ -1167,33 +1099,6 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
m_data.plots.Data().push_back_no_space_check( pd ); m_data.plots.Data().push_back_no_space_check( pd );
} }
} }
else
{
for( uint64_t i=0; i<sz; i++ )
{
s_loadProgress.subProgress.store( i, std::memory_order_relaxed );
auto pd = m_slab.AllocInit<PlotData>();
uint64_t psz;
f.Read6( pd->type, pd->format, pd->name, pd->min, pd->max, psz );
pd->sum = 0;
pd->showSteps = false;
pd->fill = true;
pd->color = 0;
pd->data.reserve_exact( psz, m_slab );
auto ptr = pd->data.data();
int64_t refTime = 0;
for( uint64_t j=0; j<psz; j++ )
{
int64_t t;
f.Read2( t, ptr->val );
pd->sum += ptr->val;
refTime += t;
ptr->time = refTime;
ptr++;
}
m_data.plots.Data().push_back_no_space_check( pd );
}
}
} }
else else
{ {
@ -1208,21 +1113,11 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
} }
} }
else if( fileVer >= FileVersion( 0, 7, 10 ) )
{
for( uint64_t i=0; i<sz; i++ )
{
f.Skip( sizeof( PlotData::name ) + sizeof( PlotData::min ) + sizeof( PlotData::max ) + sizeof( PlotData::sum ) + sizeof( PlotData::type ) + sizeof( PlotData::format ) );
uint64_t psz;
f.Read( psz );
f.Skip( psz * ( sizeof( uint64_t ) + sizeof( double ) ) );
}
}
else else
{ {
for( uint64_t i=0; i<sz; i++ ) for( uint64_t i=0; i<sz; i++ )
{ {
f.Skip( sizeof( PlotData::name ) + sizeof( PlotData::min ) + sizeof( PlotData::max ) + sizeof( PlotData::type ) + sizeof( PlotData::format ) ); f.Skip( sizeof( PlotData::name ) + sizeof( PlotData::min ) + sizeof( PlotData::max ) + sizeof( PlotData::sum ) + sizeof( PlotData::type ) + sizeof( PlotData::format ) );
uint64_t psz; uint64_t psz;
f.Read( psz ); f.Read( psz );
f.Skip( psz * ( sizeof( uint64_t ) + sizeof( double ) ) ); f.Skip( psz * ( sizeof( uint64_t ) + sizeof( double ) ) );
@ -1233,83 +1128,19 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
s_loadProgress.subTotal.store( 0, std::memory_order_relaxed ); s_loadProgress.subTotal.store( 0, std::memory_order_relaxed );
s_loadProgress.progress.store( LoadProgress::Memory, std::memory_order_relaxed ); s_loadProgress.progress.store( LoadProgress::Memory, std::memory_order_relaxed );
if( fileVer >= FileVersion( 0, 7, 3 ) ) uint64_t memcount, memtarget, memload = 0;
f.Read2( memcount, memtarget );
s_loadProgress.subTotal.store( memtarget, std::memory_order_relaxed );
for( uint64_t k=0; k<memcount; k++ )
{ {
uint64_t memcount, memtarget, memload = 0; uint64_t memname;
f.Read2( memcount, memtarget ); f.Read2( memname, sz );
s_loadProgress.subTotal.store( memtarget, std::memory_order_relaxed );
for( uint64_t k=0; k<memcount; k++ )
{
uint64_t memname;
f.Read2( memname, sz );
if( eventMask & EventType::Memory )
{
auto mit = m_data.memNameMap.emplace( memname, m_slab.AllocInit<MemData>() );
if( memname == 0 ) m_data.memory = mit.first->second;
auto& memdata = *mit.first->second;
memdata.data.reserve_exact( sz, m_slab );
uint64_t activeSz, freesSz;
f.Read2( activeSz, freesSz );
memdata.active.reserve( activeSz );
memdata.frees.reserve_exact( freesSz, m_slab );
auto mem = memdata.data.data();
s_loadProgress.subTotal.store( sz, std::memory_order_relaxed );
size_t fidx = 0;
int64_t refTime = 0;
auto& frees = memdata.frees;
auto& active = memdata.active;
for( uint64_t i=0; i<sz; i++ )
{
s_loadProgress.subProgress.store( memload+i, std::memory_order_relaxed );
uint64_t ptr, size;
Int24 csAlloc;
int64_t timeAlloc, timeFree;
uint16_t threadAlloc, threadFree;
f.Read8( ptr, size, csAlloc, mem->csFree, timeAlloc, timeFree, threadAlloc, threadFree );
mem->SetPtr( ptr );
mem->SetSize( size );
mem->SetCsAlloc( csAlloc.Val() );
refTime += timeAlloc;
mem->SetTimeThreadAlloc( refTime, threadAlloc );
if( timeFree >= 0 )
{
mem->SetTimeThreadFree( timeFree + refTime, threadFree );
frees[fidx++] = i;
}
else
{
mem->SetTimeThreadFree( timeFree, threadFree );
active.emplace( ptr, i );
}
mem++;
}
memload += sz;
f.Read4( memdata.high, memdata.low, memdata.usage, memdata.name );
if( sz != 0 )
{
memdata.reconstruct = true;
}
}
else
{
f.Skip( 2 * sizeof( uint64_t ) );
f.Skip( sz * ( sizeof( uint64_t ) + sizeof( uint64_t ) + sizeof( Int24 ) + sizeof( Int24 ) + sizeof( int64_t ) * 2 + sizeof( uint16_t ) * 2 ) );
f.Skip( sizeof( MemData::high ) + sizeof( MemData::low ) + sizeof( MemData::usage ) + sizeof( MemData::name ) );
}
}
}
else
{
m_data.memory = m_slab.AllocInit<MemData>();
m_data.memNameMap.emplace( 0, m_data.memory );
f.Read( sz );
if( eventMask & EventType::Memory ) if( eventMask & EventType::Memory )
{ {
auto& memdata = *m_data.memory; auto mit = m_data.memNameMap.emplace( memname, m_slab.AllocInit<MemData>() );
if( memname == 0 ) m_data.memory = mit.first->second;
auto& memdata = *mit.first->second;
memdata.data.reserve_exact( sz, m_slab ); memdata.data.reserve_exact( sz, m_slab );
uint64_t activeSz, freesSz; uint64_t activeSz, freesSz;
f.Read2( activeSz, freesSz ); f.Read2( activeSz, freesSz );
@ -1324,7 +1155,7 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
for( uint64_t i=0; i<sz; i++ ) for( uint64_t i=0; i<sz; i++ )
{ {
s_loadProgress.subProgress.store( i, std::memory_order_relaxed ); s_loadProgress.subProgress.store( memload+i, std::memory_order_relaxed );
uint64_t ptr, size; uint64_t ptr, size;
Int24 csAlloc; Int24 csAlloc;
int64_t timeAlloc, timeFree; int64_t timeAlloc, timeFree;
@ -1347,7 +1178,8 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
} }
mem++; mem++;
} }
f.Read3( memdata.high, memdata.low, memdata.usage ); memload += sz;
f.Read4( memdata.high, memdata.low, memdata.usage, memdata.name );
if( sz != 0 ) if( sz != 0 )
{ {
@ -1358,7 +1190,7 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
{ {
f.Skip( 2 * sizeof( uint64_t ) ); f.Skip( 2 * sizeof( uint64_t ) );
f.Skip( sz * ( sizeof( uint64_t ) + sizeof( uint64_t ) + sizeof( Int24 ) + sizeof( Int24 ) + sizeof( int64_t ) * 2 + sizeof( uint16_t ) * 2 ) ); f.Skip( sz * ( sizeof( uint64_t ) + sizeof( uint64_t ) + sizeof( Int24 ) + sizeof( Int24 ) + sizeof( int64_t ) * 2 + sizeof( uint16_t ) * 2 ) );
f.Skip( sizeof( MemData::high ) + sizeof( MemData::low ) + sizeof( MemData::usage ) ); f.Skip( sizeof( MemData::high ) + sizeof( MemData::low ) + sizeof( MemData::usage ) + sizeof( MemData::name ) );
} }
} }
@ -1411,16 +1243,13 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
if( eventMask & EventType::FrameImages ) if( eventMask & EventType::FrameImages )
{ {
ZSTD_CDict* cdict = nullptr; ZSTD_CDict* cdict = nullptr;
if( fileVer >= FileVersion( 0, 7, 8 ) ) uint32_t dsz;
{ f.Read( dsz );
uint32_t dsz; auto dict = new char[dsz];
f.Read( dsz ); f.Read( dict, dsz );
auto dict = new char[dsz]; cdict = ZSTD_createCDict( dict, dsz, 3 );
f.Read( dict, dsz ); m_texcomp.SetDict( ZSTD_createDDict( dict, dsz ) );
cdict = ZSTD_createCDict( dict, dsz, 3 ); delete[] dict;
m_texcomp.SetDict( ZSTD_createDDict( dict, dsz ) );
delete[] dict;
}
f.Read( sz ); f.Read( sz );
m_data.frameImage.reserve_exact( sz, m_slab ); m_data.frameImage.reserve_exact( sz, m_slab );
@ -1533,12 +1362,9 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
} }
else else
{ {
if( fileVer >= FileVersion( 0, 7, 8 ) ) uint32_t dsz;
{ f.Read( dsz );
uint32_t dsz; f.Skip( dsz );
f.Read( dsz );
f.Skip( dsz );
}
f.Read( sz ); f.Read( sz );
s_loadProgress.subTotal.store( sz, std::memory_order_relaxed ); s_loadProgress.subTotal.store( sz, std::memory_order_relaxed );
for( uint64_t i=0; i<sz; i++ ) for( uint64_t i=0; i<sz; i++ )
@ -1573,43 +1399,21 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
int64_t runningTime = 0; int64_t runningTime = 0;
int64_t refTime = 0; int64_t refTime = 0;
auto ptr = data->v.data(); auto ptr = data->v.data();
if( fileVer >= FileVersion( 0, 7, 12 ) ) for( uint64_t j=0; j<csz; j++ )
{ {
for( uint64_t j=0; j<csz; j++ ) int64_t deltaWakeup, deltaStart, diff, thread;
{ uint8_t cpu;
int64_t deltaWakeup, deltaStart, diff, thread; int8_t reason, state;
uint8_t cpu; f.Read7( deltaWakeup, deltaStart, diff, cpu, reason, state, thread );
int8_t reason, state; refTime += deltaWakeup;
f.Read7( deltaWakeup, deltaStart, diff, cpu, reason, state, thread ); ptr->SetWakeup( refTime );
refTime += deltaWakeup; refTime += deltaStart;
ptr->SetWakeup( refTime ); ptr->SetStartCpu( refTime, cpu );
refTime += deltaStart; if( diff > 0 ) runningTime += diff;
ptr->SetStartCpu( refTime, cpu ); refTime += diff;
if( diff > 0 ) runningTime += diff; ptr->SetEndReasonState( refTime, reason, state );
refTime += diff; ptr->SetThread( CompressThread( thread ) );
ptr->SetEndReasonState( refTime, reason, state ); ptr++;
ptr->SetThread( CompressThread( thread ) );
ptr++;
}
}
else
{
for( uint64_t j=0; j<csz; j++ )
{
int64_t deltaWakeup, deltaStart, diff;
uint8_t cpu;
int8_t reason, state;
f.Read6( deltaWakeup, deltaStart, diff, cpu, reason, state );
refTime += deltaWakeup;
ptr->SetWakeup( refTime );
refTime += deltaStart;
ptr->SetStartCpu( refTime, cpu );
if( diff > 0 ) runningTime += diff;
refTime += diff;
ptr->SetEndReasonState( refTime, reason, state );
ptr->SetThread( 0 );
ptr++;
}
} }
data->runningTime = runningTime; data->runningTime = runningTime;
m_data.ctxSwitch.emplace( thread, data ); m_data.ctxSwitch.emplace( thread, data );
@ -1625,14 +1429,7 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
f.Skip( sizeof( uint64_t ) ); f.Skip( sizeof( uint64_t ) );
uint64_t csz; uint64_t csz;
f.Read( csz ); f.Read( csz );
if( fileVer >= FileVersion( 0, 7, 12 ) ) f.Skip( csz * ( sizeof( int64_t ) * 4 + sizeof( int8_t ) * 3 ) );
{
f.Skip( csz * ( sizeof( int64_t ) * 4 + sizeof( int8_t ) * 3 ) );
}
else
{
f.Skip( csz * ( sizeof( int64_t ) * 3 + sizeof( int8_t ) * 3 ) );
}
} }
} }
@ -1697,14 +1494,7 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
f.Read( sz ); f.Read( sz );
m_data.symbolLoc.reserve_exact( sz, m_slab ); m_data.symbolLoc.reserve_exact( sz, m_slab );
f.Read( sz ); f.Read( sz );
if( fileVer < FileVersion( 0, 7, 2 ) ) m_data.symbolLocInline.reserve_exact( sz, m_slab );
{
m_data.symbolLocInline.reserve_exact( sz + 1, m_slab );
}
else
{
m_data.symbolLocInline.reserve_exact( sz, m_slab );
}
f.Read( sz ); f.Read( sz );
m_data.symbolMap.reserve( sz ); m_data.symbolMap.reserve( sz );
int symIdx = 0; int symIdx = 0;
@ -1727,10 +1517,6 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
m_data.symbolLoc[symIdx++] = SymbolLocation { symAddr, size.Val() }; m_data.symbolLoc[symIdx++] = SymbolLocation { symAddr, size.Val() };
} }
} }
if( fileVer < FileVersion( 0, 7, 2 ) )
{
m_data.symbolLocInline[symInlineIdx] = std::numeric_limits<uint64_t>::max();
}
#ifdef NO_PARALLEL_SORT #ifdef NO_PARALLEL_SORT
pdqsort_branchless( m_data.symbolLoc.begin(), m_data.symbolLoc.end(), [] ( const auto& l, const auto& r ) { return l.addr < r.addr; } ); pdqsort_branchless( m_data.symbolLoc.begin(), m_data.symbolLoc.end(), [] ( const auto& l, const auto& r ) { return l.addr < r.addr; } );
pdqsort_branchless( m_data.symbolLocInline.begin(), m_data.symbolLocInline.end() ); pdqsort_branchless( m_data.symbolLocInline.begin(), m_data.symbolLocInline.end() );
@ -1798,31 +1584,28 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
} }
} }
if( fileVer >= FileVersion( 0, 7, 9 ) ) f.Read( sz );
m_data.codeSymbolMap.reserve( sz );
for( uint64_t i=0; i<sz; i++ )
{ {
f.Read( sz ); uint64_t v1, v2;
m_data.codeSymbolMap.reserve( sz ); f.Read2( v1, v2 );
for( uint64_t i=0; i<sz; i++ ) m_data.codeSymbolMap.emplace( v1, v2 );
{ }
uint64_t v1, v2;
f.Read2( v1, v2 );
m_data.codeSymbolMap.emplace( v1, v2 );
}
f.Read( sz ); f.Read( sz );
m_data.hwSamples.reserve( sz ); m_data.hwSamples.reserve( sz );
for( uint64_t i=0; i<sz; i++ ) for( uint64_t i=0; i<sz; i++ )
{ {
uint64_t addr; uint64_t addr;
f.Read( addr ); f.Read( addr );
auto& data = m_data.hwSamples.emplace( addr, HwSampleData {} ).first->second; auto& data = m_data.hwSamples.emplace( addr, HwSampleData {} ).first->second;
ReadHwSampleVec( f, data.cycles, m_slab ); ReadHwSampleVec( f, data.cycles, m_slab );
ReadHwSampleVec( f, data.retired, m_slab ); ReadHwSampleVec( f, data.retired, m_slab );
ReadHwSampleVec( f, data.cacheRef, m_slab ); ReadHwSampleVec( f, data.cacheRef, m_slab );
ReadHwSampleVec( f, data.cacheMiss, m_slab ); ReadHwSampleVec( f, data.cacheMiss, m_slab );
if( ReadHwSampleVec( f, data.branchRetired, m_slab ) != 0 ) m_data.hasBranchRetirement = true; if( ReadHwSampleVec( f, data.branchRetired, m_slab ) != 0 ) m_data.hasBranchRetirement = true;
ReadHwSampleVec( f, data.branchMiss, m_slab ); ReadHwSampleVec( f, data.branchMiss, m_slab );
}
} }
f.Read( sz ); f.Read( sz );
@ -1865,14 +1648,6 @@ Worker::Worker( FileRead& f, EventType::Type eventMask, bool bgTasks )
{ {
m_backgroundDone.store( false, std::memory_order_relaxed ); m_backgroundDone.store( false, std::memory_order_relaxed );
#ifndef TRACY_NO_STATISTICS #ifndef TRACY_NO_STATISTICS
if( fileVer < FileVersion( 0, 7, 13 ) )
{
for( auto& t : m_data.threads )
{
pdqsort_branchless( t->samples.begin(), t->samples.end(), [] ( const auto& lhs, const auto& rhs ) { return lhs.time.Val() < rhs.time.Val(); } );
}
}
m_threadBackground = std::thread( [this, eventMask] { m_threadBackground = std::thread( [this, eventMask] {
std::vector<std::thread> jobs; std::vector<std::thread> jobs;