mirror of
https://github.com/wolfpld/tracy.git
synced 2024-12-01 17:34:36 +00:00
1009 lines
35 KiB
C++
1009 lines
35 KiB
C++
#include <algorithm>
|
|
#include <limits>
|
|
|
|
#include "TracyImGui.hpp"
|
|
#include "TracyLockHelpers.hpp"
|
|
#include "TracyMouse.hpp"
|
|
#include "TracyPrint.hpp"
|
|
#include "TracyTimelineContext.hpp"
|
|
#include "TracyTimelineItemThread.hpp"
|
|
#include "TracyView.hpp"
|
|
#include "TracyWorker.hpp"
|
|
|
|
namespace tracy
|
|
{
|
|
|
|
constexpr float MinVisSize = 3;
|
|
constexpr float MinCtxSize = 4;
|
|
|
|
|
|
TimelineItemThread::TimelineItemThread( View& view, Worker& worker, const ThreadData* thread )
|
|
: TimelineItem( view, worker, thread, true )
|
|
, m_thread( thread )
|
|
, m_ghost( false )
|
|
{
|
|
auto name = worker.GetThreadName( thread->id );
|
|
if( strncmp( name, "Tracy ", 6 ) == 0 )
|
|
{
|
|
m_showFull = false;
|
|
}
|
|
}
|
|
|
|
bool TimelineItemThread::IsEmpty() const
|
|
{
|
|
auto& crash = m_worker.GetCrashEvent();
|
|
return crash.thread != m_thread->id &&
|
|
m_thread->timeline.empty() &&
|
|
m_thread->messages.empty() &&
|
|
m_thread->ghostZones.empty();
|
|
}
|
|
|
|
uint32_t TimelineItemThread::HeaderColor() const
|
|
{
|
|
auto& crash = m_worker.GetCrashEvent();
|
|
if( crash.thread == m_thread->id ) return 0xFF2222FF;
|
|
if( m_thread->isFiber ) return 0xFF88FF88;
|
|
return 0xFFFFFFFF;
|
|
}
|
|
|
|
uint32_t TimelineItemThread::HeaderColorInactive() const
|
|
{
|
|
auto& crash = m_worker.GetCrashEvent();
|
|
if( crash.thread == m_thread->id ) return 0xFF111188;
|
|
if( m_thread->isFiber ) return 0xFF448844;
|
|
return 0xFF888888;
|
|
}
|
|
|
|
uint32_t TimelineItemThread::HeaderLineColor() const
|
|
{
|
|
return 0x33FFFFFF;
|
|
}
|
|
|
|
const char* TimelineItemThread::HeaderLabel() const
|
|
{
|
|
return m_worker.GetThreadName( m_thread->id );
|
|
}
|
|
|
|
int64_t TimelineItemThread::RangeBegin() const
|
|
{
|
|
int64_t first = std::numeric_limits<int64_t>::max();
|
|
const auto ctx = m_worker.GetContextSwitchData( m_thread->id );
|
|
if( ctx && !ctx->v.empty() )
|
|
{
|
|
first = ctx->v.begin()->Start();
|
|
}
|
|
if( !m_thread->timeline.empty() )
|
|
{
|
|
if( m_thread->timeline.is_magic() )
|
|
{
|
|
auto& tl = *((Vector<ZoneEvent>*)&m_thread->timeline);
|
|
first = std::min( first, tl.front().Start() );
|
|
}
|
|
else
|
|
{
|
|
first = std::min( first, m_thread->timeline.front()->Start() );
|
|
}
|
|
}
|
|
if( !m_thread->messages.empty() )
|
|
{
|
|
first = std::min( first, m_thread->messages.front()->time );
|
|
}
|
|
for( const auto& lock : m_worker.GetLockMap() )
|
|
{
|
|
const auto& lockmap = *lock.second;
|
|
if( !lockmap.valid ) continue;
|
|
auto it = lockmap.threadMap.find( m_thread->id );
|
|
if( it == lockmap.threadMap.end() ) continue;
|
|
const auto thread = it->second;
|
|
auto lptr = lockmap.timeline.data();
|
|
while( lptr->ptr->thread != thread ) lptr++;
|
|
if( lptr->ptr->Time() < first ) first = lptr->ptr->Time();
|
|
}
|
|
return first;
|
|
}
|
|
|
|
int64_t TimelineItemThread::RangeEnd() const
|
|
{
|
|
int64_t last = -1;
|
|
const auto ctx = m_worker.GetContextSwitchData( m_thread->id );
|
|
if( ctx && !ctx->v.empty() )
|
|
{
|
|
const auto& back = ctx->v.back();
|
|
last = back.IsEndValid() ? back.End() : back.Start();
|
|
}
|
|
if( !m_thread->timeline.empty() )
|
|
{
|
|
if( m_thread->timeline.is_magic() )
|
|
{
|
|
auto& tl = *((Vector<ZoneEvent>*)&m_thread->timeline);
|
|
last = std::max( last, m_worker.GetZoneEnd( tl.back() ) );
|
|
}
|
|
else
|
|
{
|
|
last = std::max( last, m_worker.GetZoneEnd( *m_thread->timeline.back() ) );
|
|
}
|
|
}
|
|
if( !m_thread->messages.empty() )
|
|
{
|
|
last = std::max( last, m_thread->messages.back()->time );
|
|
}
|
|
for( const auto& lock : m_worker.GetLockMap() )
|
|
{
|
|
const auto& lockmap = *lock.second;
|
|
if( !lockmap.valid ) continue;
|
|
auto it = lockmap.threadMap.find( m_thread->id );
|
|
if( it == lockmap.threadMap.end() ) continue;
|
|
const auto thread = it->second;
|
|
auto eptr = lockmap.timeline.data() + lockmap.timeline.size() - 1;
|
|
while( eptr->ptr->thread != thread ) eptr--;
|
|
if( eptr->ptr->Time() > last ) last = eptr->ptr->Time();
|
|
}
|
|
return last;
|
|
}
|
|
|
|
void TimelineItemThread::HeaderTooltip( const char* label ) const
|
|
{
|
|
m_view.HighlightThread( m_thread->id );
|
|
|
|
ImGui::BeginTooltip();
|
|
SmallColorBox( GetThreadColor( m_thread->id, 0, m_view.GetViewData().dynamicColors ) );
|
|
ImGui::SameLine();
|
|
ImGui::TextUnformatted( m_worker.GetThreadName( m_thread->id ) );
|
|
ImGui::SameLine();
|
|
ImGui::TextDisabled( "(%s)", RealToString( m_thread->id ) );
|
|
auto& crash = m_worker.GetCrashEvent();
|
|
if( crash.thread == m_thread->id )
|
|
{
|
|
ImGui::SameLine();
|
|
TextColoredUnformatted( ImVec4( 1.f, 0.2f, 0.2f, 1.f ), ICON_FA_SKULL " Crashed" );
|
|
}
|
|
if( m_thread->isFiber )
|
|
{
|
|
ImGui::SameLine();
|
|
TextColoredUnformatted( ImVec4( 0.2f, 0.6f, 0.2f, 1.f ), "Fiber" );
|
|
}
|
|
|
|
const auto ctx = m_worker.GetContextSwitchData( m_thread->id );
|
|
const auto first = RangeBegin();
|
|
const auto last = RangeEnd();
|
|
|
|
ImGui::Separator();
|
|
|
|
size_t lockCnt = 0;
|
|
for( const auto& lock : m_worker.GetLockMap() )
|
|
{
|
|
const auto& lockmap = *lock.second;
|
|
if( !lockmap.valid ) continue;
|
|
auto it = lockmap.threadMap.find( m_thread->id );
|
|
if( it == lockmap.threadMap.end() ) continue;
|
|
lockCnt++;
|
|
}
|
|
|
|
if( last >= 0 )
|
|
{
|
|
const auto lifetime = last - first;
|
|
const auto traceLen = m_worker.GetLastTime() - m_worker.GetFirstTime();
|
|
|
|
TextFocused( "Appeared at", TimeToString( first ) );
|
|
TextFocused( "Last event at", TimeToString( last ) );
|
|
TextFocused( "Lifetime:", TimeToString( lifetime ) );
|
|
ImGui::SameLine();
|
|
char buf[64];
|
|
PrintStringPercent( buf, lifetime / double( traceLen ) * 100 );
|
|
TextDisabledUnformatted( buf );
|
|
|
|
if( ctx )
|
|
{
|
|
TextFocused( "Time in running state:", TimeToString( ctx->runningTime ) );
|
|
ImGui::SameLine();
|
|
PrintStringPercent( buf, ctx->runningTime / double( lifetime ) * 100 );
|
|
TextDisabledUnformatted( buf );
|
|
}
|
|
}
|
|
|
|
ImGui::Separator();
|
|
if( !m_thread->timeline.empty() )
|
|
{
|
|
TextFocused( "Zone count:", RealToString( m_thread->count ) );
|
|
TextFocused( "Top-level zones:", RealToString( m_thread->timeline.size() ) );
|
|
}
|
|
if( !m_thread->messages.empty() )
|
|
{
|
|
TextFocused( "Messages:", RealToString( m_thread->messages.size() ) );
|
|
}
|
|
if( lockCnt != 0 )
|
|
{
|
|
TextFocused( "Locks:", RealToString( lockCnt ) );
|
|
}
|
|
if( ctx )
|
|
{
|
|
TextFocused( "Running state regions:", RealToString( ctx->v.size() ) );
|
|
}
|
|
if( !m_thread->samples.empty() )
|
|
{
|
|
TextFocused( "Call stack samples:", RealToString( m_thread->samples.size() ) );
|
|
if( m_thread->kernelSampleCnt != 0 )
|
|
{
|
|
TextFocused( "Kernel samples:", RealToString( m_thread->kernelSampleCnt ) );
|
|
ImGui::SameLine();
|
|
ImGui::TextDisabled( "(%.2f%%)", 100.f * m_thread->kernelSampleCnt / m_thread->samples.size() );
|
|
}
|
|
}
|
|
ImGui::EndTooltip();
|
|
}
|
|
|
|
void TimelineItemThread::HeaderExtraContents( const TimelineContext& ctx, int offset, float labelWidth )
|
|
{
|
|
m_view.DrawThreadMessagesList( ctx, m_msgDraw, offset, m_thread->id );
|
|
|
|
#ifndef TRACY_NO_STATISTICS
|
|
const bool hasGhostZones = m_worker.AreGhostZonesReady() && !m_thread->ghostZones.empty();
|
|
if( hasGhostZones && !m_thread->timeline.empty() )
|
|
{
|
|
auto draw = ImGui::GetWindowDrawList();
|
|
const auto ty = ImGui::GetTextLineHeight();
|
|
|
|
const auto color = m_ghost ? 0xFFAA9999 : 0x88AA7777;
|
|
draw->AddText( ctx.wpos + ImVec2( 1.5f * ty + labelWidth, offset ), color, ICON_FA_GHOST );
|
|
float ghostSz = ImGui::CalcTextSize( ICON_FA_GHOST ).x;
|
|
|
|
if( ctx.hover && ImGui::IsMouseHoveringRect( ctx.wpos + ImVec2( 1.5f * ty + labelWidth, offset ), ctx.wpos + ImVec2( 1.5f * ty + labelWidth + ghostSz, offset + ty ) ) )
|
|
{
|
|
if( IsMouseClicked( 0 ) )
|
|
{
|
|
m_ghost = !m_ghost;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
bool TimelineItemThread::DrawContents( const TimelineContext& ctx, int& offset )
|
|
{
|
|
m_view.DrawThread( ctx, *m_thread, m_draw, m_ctxDraw, m_samplesDraw, m_lockDraw, offset, m_depth, m_hasCtxSwitch, m_hasSamples );
|
|
if( m_depth == 0 && !m_hasMessages )
|
|
{
|
|
auto& crash = m_worker.GetCrashEvent();
|
|
return crash.thread == m_thread->id;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void TimelineItemThread::DrawOverlay( const ImVec2& ul, const ImVec2& dr )
|
|
{
|
|
m_view.DrawThreadOverlays( *m_thread, ul, dr );
|
|
}
|
|
|
|
void TimelineItemThread::DrawFinished()
|
|
{
|
|
m_samplesDraw.clear();
|
|
m_ctxDraw.clear();
|
|
m_draw.clear();
|
|
m_msgDraw.clear();
|
|
m_lockDraw.clear();
|
|
}
|
|
|
|
void TimelineItemThread::Preprocess( const TimelineContext& ctx, TaskDispatch& td, bool visible, int yPos )
|
|
{
|
|
assert( m_samplesDraw.empty() );
|
|
assert( m_ctxDraw.empty() );
|
|
assert( m_draw.empty() );
|
|
assert( m_msgDraw.empty() );
|
|
assert( m_lockDraw.empty() );
|
|
|
|
td.Queue( [this, &ctx, visible] {
|
|
#ifndef TRACY_NO_STATISTICS
|
|
if( m_worker.AreGhostZonesReady() && ( m_ghost || ( m_view.GetViewData().ghostZones && m_thread->timeline.empty() ) ) )
|
|
{
|
|
m_depth = PreprocessGhostLevel( ctx, m_thread->ghostZones, 0, visible );
|
|
}
|
|
else
|
|
#endif
|
|
{
|
|
m_depth = PreprocessZoneLevel( ctx, m_thread->timeline, 0, visible );
|
|
}
|
|
} );
|
|
|
|
const auto& vd = m_view.GetViewData();
|
|
|
|
m_hasCtxSwitch = false;
|
|
if( vd.drawContextSwitches )
|
|
{
|
|
auto ctxSwitch = m_worker.GetContextSwitchData( m_thread->id );
|
|
if( ctxSwitch )
|
|
{
|
|
// There is no yPos passed here to enable more granular visibility check,
|
|
// as context switch shadows will usually be projected down onto zones.
|
|
td.Queue( [this, &ctx, ctxSwitch, visible] {
|
|
PreprocessContextSwitches( ctx, *ctxSwitch, visible );
|
|
} );
|
|
}
|
|
}
|
|
|
|
m_hasSamples = false;
|
|
if( vd.drawSamples && !m_thread->samples.empty() )
|
|
{
|
|
td.Queue( [this, &ctx, visible, yPos] {
|
|
PreprocessSamples( ctx, m_thread->samples, visible, yPos );
|
|
} );
|
|
}
|
|
|
|
m_hasMessages = false;
|
|
td.Queue( [this, &ctx, visible, yPos] {
|
|
PreprocessMessages( ctx, m_thread->messages, m_thread->id, visible, yPos );
|
|
} );
|
|
|
|
if( vd.drawLocks )
|
|
{
|
|
const auto& locks = m_worker.GetLockMap();
|
|
if( !locks.empty() )
|
|
{
|
|
PreprocessLocks( ctx, locks, m_thread->id, td, visible );
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifndef TRACY_NO_STATISTICS
|
|
int TimelineItemThread::PreprocessGhostLevel( const TimelineContext& ctx, const Vector<GhostZone>& vec, int depth, bool visible )
|
|
{
|
|
const auto nspx = ctx.nspx;
|
|
const auto vStart = ctx.vStart;
|
|
const auto vEnd = ctx.vEnd;
|
|
|
|
const auto MinVisNs = int64_t( round( GetScale() * MinVisSize * nspx ) );
|
|
|
|
auto it = std::lower_bound( vec.begin(), vec.end(), std::max<int64_t>( 0, vStart - 2 * MinVisNs ), [] ( const auto& l, const auto& r ) { return l.end.Val() < r; } );
|
|
if( it == vec.end() ) return depth;
|
|
|
|
const auto zitend = std::lower_bound( it, vec.end(), vEnd, [] ( const auto& l, const auto& r ) { return l.start.Val() < r; } );
|
|
if( it == zitend ) return depth;
|
|
if( (zitend-1)->end.Val() < vStart ) return depth;
|
|
|
|
int maxdepth = depth + 1;
|
|
|
|
while( it < zitend )
|
|
{
|
|
auto& ev = *it;
|
|
const auto end = ev.end.Val();
|
|
const auto zsz = end - ev.start.Val();
|
|
if( zsz < MinVisNs )
|
|
{
|
|
auto nextTime = end + MinVisNs;
|
|
auto next = it + 1;
|
|
for(;;)
|
|
{
|
|
next = std::lower_bound( next, zitend, nextTime, [] ( const auto& l, const auto& r ) { return l.end.Val() < r; } );
|
|
if( next == zitend ) break;
|
|
auto prev = next - 1;
|
|
const auto pt = prev->end.Val();
|
|
const auto nt = next->end.Val();
|
|
if( nt - pt >= MinVisNs ) break;
|
|
nextTime = nt + MinVisNs;
|
|
}
|
|
if( visible ) m_draw.emplace_back( TimelineDraw { TimelineDrawType::GhostFolded, uint16_t( depth ), (void**)&ev, (next-1)->end } );
|
|
it = next;
|
|
}
|
|
else
|
|
{
|
|
if( ev.child >= 0 )
|
|
{
|
|
const auto d = PreprocessGhostLevel( ctx, m_worker.GetGhostChildren( ev.child ), depth + 1, visible );
|
|
if( d > maxdepth ) maxdepth = d;
|
|
}
|
|
if( visible ) m_draw.emplace_back( TimelineDraw { TimelineDrawType::Ghost, uint16_t( depth ), (void**)&ev } );
|
|
++it;
|
|
}
|
|
}
|
|
|
|
return maxdepth;
|
|
}
|
|
#endif
|
|
|
|
int TimelineItemThread::PreprocessZoneLevel( const TimelineContext& ctx, const Vector<short_ptr<ZoneEvent>>& vec, int depth, bool visible )
|
|
{
|
|
if( vec.is_magic() )
|
|
{
|
|
return PreprocessZoneLevel<VectorAdapterDirect<ZoneEvent>>( ctx, *(Vector<ZoneEvent>*)( &vec ), depth, visible );
|
|
}
|
|
else
|
|
{
|
|
return PreprocessZoneLevel<VectorAdapterPointer<ZoneEvent>>( ctx, vec, depth, visible );
|
|
}
|
|
}
|
|
|
|
template<typename Adapter, typename V>
|
|
int TimelineItemThread::PreprocessZoneLevel( const TimelineContext& ctx, const V& vec, int depth, bool visible )
|
|
{
|
|
const auto vStart = ctx.vStart;
|
|
const auto vEnd = ctx.vEnd;
|
|
const auto nspx = ctx.nspx;
|
|
|
|
const auto MinVisNs = int64_t( round( GetScale() * MinVisSize * nspx ) );
|
|
|
|
auto it = std::lower_bound( vec.begin(), vec.end(), vStart, [this] ( const auto& l, const auto& r ) { Adapter a; return m_worker.GetZoneEnd( a(l) ) < r; } );
|
|
if( it == vec.end() ) return depth;
|
|
|
|
const auto zitend = std::lower_bound( it, vec.end(), vEnd, [] ( const auto& l, const auto& r ) { Adapter a; return a(l).Start() < r; } );
|
|
if( it == zitend ) return depth;
|
|
Adapter a;
|
|
if( !a(*it).IsEndValid() && m_worker.GetZoneEnd( a(*it) ) < vStart ) return depth;
|
|
if( m_worker.GetZoneEnd( a(*(zitend-1)) ) < vStart ) return depth;
|
|
|
|
int maxdepth = depth + 1;
|
|
|
|
while( it < zitend )
|
|
{
|
|
auto& ev = a(*it);
|
|
const auto end = m_worker.GetZoneEnd( ev );
|
|
const auto zsz = end - ev.Start();
|
|
if( zsz < MinVisNs )
|
|
{
|
|
auto nextTime = end + MinVisNs;
|
|
auto next = it + 1;
|
|
for(;;)
|
|
{
|
|
next = std::lower_bound( next, zitend, nextTime, [this] ( const auto& l, const auto& r ) { Adapter a; return m_worker.GetZoneEnd( a(l) ) < r; } );
|
|
if( next == zitend ) break;
|
|
auto prev = next - 1;
|
|
const auto pt = m_worker.GetZoneEnd( a(*prev) );
|
|
const auto nt = m_worker.GetZoneEnd( a(*next) );
|
|
if( nt - pt >= MinVisNs ) break;
|
|
nextTime = nt + MinVisNs;
|
|
}
|
|
if( visible ) m_draw.emplace_back( TimelineDraw { TimelineDrawType::Folded, uint16_t( depth ), (void**)&ev, m_worker.GetZoneEnd( a(*(next-1)) ), uint32_t( next - it ) } );
|
|
it = next;
|
|
}
|
|
else
|
|
{
|
|
if( ev.HasChildren() )
|
|
{
|
|
const auto d = PreprocessZoneLevel( ctx, m_worker.GetZoneChildren( ev.Child() ), depth + 1, visible );
|
|
if( d > maxdepth ) maxdepth = d;
|
|
}
|
|
if( visible ) m_draw.emplace_back( TimelineDraw { TimelineDrawType::Zone, uint16_t( depth ), (void**)&ev } );
|
|
++it;
|
|
}
|
|
}
|
|
|
|
return maxdepth;
|
|
}
|
|
|
|
void TimelineItemThread::PreprocessContextSwitches( const TimelineContext& ctx, const ContextSwitch& ctxSwitch, bool visible )
|
|
{
|
|
const auto nspx = ctx.nspx;
|
|
const auto vStart = ctx.vStart;
|
|
const auto vEnd = ctx.vEnd;
|
|
|
|
auto& vec = ctxSwitch.v;
|
|
auto it = std::lower_bound( vec.begin(), vec.end(), std::max<int64_t>( 0, vStart ), [] ( const auto& l, const auto& r ) { return ( l.IsEndValid() ? l.End() : l.Start() ) < r; } );
|
|
if( it == vec.end() ) return;
|
|
if( it != vec.begin() ) --it;
|
|
|
|
auto citend = std::lower_bound( it, vec.end(), vEnd, [] ( const auto& l, const auto& r ) { return l.Start() < r; } );
|
|
if( it == citend ) return;
|
|
if( citend != vec.end() ) ++citend;
|
|
|
|
m_hasCtxSwitch = true;
|
|
if( !visible ) return;
|
|
|
|
const auto MinCtxNs = int64_t( round( GetScale() * MinCtxSize * nspx ) );
|
|
const auto& sampleData = m_thread->samples;
|
|
|
|
bool first = true;
|
|
while( it < citend )
|
|
{
|
|
auto& ev = *it;
|
|
if( first )
|
|
{
|
|
first = false;
|
|
}
|
|
else
|
|
{
|
|
uint32_t waitStack = 0;
|
|
if( !sampleData.empty() )
|
|
{
|
|
auto sdit = std::lower_bound( sampleData.begin(), sampleData.end(), ev.Start(), [] ( const auto& l, const auto& r ) { return l.time.Val() < r; } );
|
|
bool found = sdit != sampleData.end() && sdit->time.Val() == ev.Start();
|
|
if( !found && it != vec.begin() )
|
|
{
|
|
auto eit = it;
|
|
--eit;
|
|
sdit = std::lower_bound( sampleData.begin(), sampleData.end(), eit->End(), [] ( const auto& l, const auto& r ) { return l.time.Val() < r; } );
|
|
found = sdit != sampleData.end() && sdit->time.Val() == eit->End();
|
|
}
|
|
if( found ) waitStack = sdit->callstack.Val();
|
|
}
|
|
m_ctxDraw.emplace_back( ContextSwitchDraw { ContextSwitchDrawType::Waiting, uint32_t( it - vec.begin() ), waitStack } );
|
|
}
|
|
|
|
const auto end = ev.IsEndValid() ? ev.End() : ev.Start();
|
|
const auto zsz = end - ev.Start();
|
|
if( zsz < MinCtxNs )
|
|
{
|
|
auto nextTime = end + MinCtxNs;
|
|
auto next = it + 1;
|
|
for(;;)
|
|
{
|
|
next = std::lower_bound( next, citend, nextTime, [] ( const auto& l, const auto& r ) { return ( l.IsEndValid() ? l.End() : l.Start() ) < r; } );
|
|
if( next == citend ) break;
|
|
auto prev = next - 1;
|
|
const auto pt = prev->IsEndValid() ? prev->End() : prev->Start();
|
|
const auto nt = next->IsEndValid() ? next->End() : next->Start();
|
|
if( nt - pt >= MinCtxNs ) break;
|
|
nextTime = nt + MinCtxNs;
|
|
}
|
|
m_ctxDraw.emplace_back( ContextSwitchDraw { ContextSwitchDrawType::Folded, uint32_t( it - vec.begin() ), uint32_t( next - it ) } );
|
|
it = next;
|
|
}
|
|
else
|
|
{
|
|
m_ctxDraw.emplace_back( ContextSwitchDraw { ContextSwitchDrawType::Running, uint32_t( it - vec.begin() ) } );
|
|
++it;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TimelineItemThread::PreprocessSamples( const TimelineContext& ctx, const Vector<SampleData>& vec, bool visible, int yPos )
|
|
{
|
|
const auto vStart = ctx.vStart;
|
|
const auto vEnd = ctx.vEnd;
|
|
const auto nspx = ctx.nspx;
|
|
const auto ty = ctx.ty;
|
|
const auto ostep = ty + 1;
|
|
const auto pos = yPos + ostep;
|
|
|
|
const auto MinVis = 5 * GetScale();
|
|
const auto MinVisNs = int64_t( round( MinVis * nspx ) );
|
|
|
|
auto it = std::lower_bound( vec.begin(), vec.end(), vStart - MinVisNs, [] ( const auto& l, const auto& r ) { return l.time.Val() < r; } );
|
|
if( it == vec.end() ) return;
|
|
const auto itend = std::lower_bound( it, vec.end(), vEnd, [] ( const auto& l, const auto& r ) { return l.time.Val() < r; } );
|
|
if( it == itend ) return;
|
|
|
|
m_hasSamples = true;
|
|
if( !visible ) return;
|
|
|
|
const auto ty0375 = pos + round( ty * 0.375f );
|
|
const auto ty02 = round( ty * 0.2f );
|
|
const auto y0 = ty0375 - ty02 - 3;
|
|
const auto y1 = ty0375 + ty02 - 1;
|
|
if( y0 > ctx.yMax || y1 < ctx.yMin ) return;
|
|
|
|
while( it < itend )
|
|
{
|
|
auto next = it + 1;
|
|
if( next != itend )
|
|
{
|
|
const auto t0 = it->time.Val();
|
|
auto nextTime = t0 + MinVisNs;
|
|
for(;;)
|
|
{
|
|
next = std::lower_bound( next, itend, nextTime, [] ( const auto& l, const auto& r ) { return l.time.Val() < r; } );
|
|
if( next == itend ) break;
|
|
auto prev = next - 1;
|
|
const auto pt = prev->time.Val();
|
|
const auto nt = next->time.Val();
|
|
if( nt - pt >= MinVisNs ) break;
|
|
nextTime = nt + MinVisNs;
|
|
}
|
|
}
|
|
m_samplesDraw.emplace_back( SamplesDraw { uint32_t( next - it - 1 ), uint32_t( it - vec.begin() ) } );
|
|
it = next;
|
|
}
|
|
}
|
|
|
|
void TimelineItemThread::PreprocessMessages( const TimelineContext& ctx, const Vector<short_ptr<MessageData>>& vec, uint64_t tid, bool visible, int yPos )
|
|
{
|
|
const auto vStart = ctx.vStart;
|
|
const auto vEnd = ctx.vEnd;
|
|
const auto nspx = ctx.nspx;
|
|
|
|
const auto MinVisNs = int64_t( round( GetScale() * MinVisSize * nspx ) );
|
|
|
|
auto it = std::lower_bound( vec.begin(), vec.end(), vStart, [] ( const auto& lhs, const auto& rhs ) { return lhs->time < rhs; } );
|
|
if( it == vec.end() ) return;
|
|
auto end = std::lower_bound( it, vec.end(), vEnd+1, [] ( const auto& lhs, const auto& rhs ) { return lhs->time < rhs; } );
|
|
if( it == end ) return;
|
|
|
|
m_hasMessages = true;
|
|
if( !visible ) return;
|
|
if( yPos > ctx.yMax || yPos + ctx.ty < ctx.yMin ) return;
|
|
|
|
const auto hMsg = m_view.GetMessageHighlight();
|
|
const auto hThread = hMsg ? m_worker.DecompressThread( hMsg->thread ) : 0;
|
|
|
|
while( it < end )
|
|
{
|
|
const auto msgTime = (*it)->time;
|
|
const auto nextTime = msgTime + MinVisNs;
|
|
const auto next = std::upper_bound( it, vec.end(), nextTime, [] ( const auto& lhs, const auto& rhs ) { return lhs < rhs->time; } );
|
|
const auto num = next - it;
|
|
bool hilite;
|
|
if( num == 1 )
|
|
{
|
|
hilite = hMsg == *it;
|
|
}
|
|
else
|
|
{
|
|
if( hMsg && hThread == tid )
|
|
{
|
|
const auto hTime = hMsg->time;
|
|
hilite = (*it)->time <= hTime && ( next == vec.end() || (*next)->time > hTime );
|
|
}
|
|
else
|
|
{
|
|
hilite = false;
|
|
}
|
|
}
|
|
m_msgDraw.emplace_back( MessagesDraw { *it, hilite, uint32_t( num ) } );
|
|
it = next;
|
|
}
|
|
}
|
|
|
|
static Vector<LockEventPtr>::const_iterator GetNextLockEvent( const Vector<LockEventPtr>::const_iterator& it, const Vector<LockEventPtr>::const_iterator& end, LockState::Type& nextState, uint64_t threadBit )
|
|
{
|
|
auto next = it;
|
|
next++;
|
|
|
|
switch( nextState )
|
|
{
|
|
case LockState::Nothing:
|
|
while( next < end )
|
|
{
|
|
if( next->lockCount != 0 )
|
|
{
|
|
if( GetThreadBit( next->lockingThread ) == threadBit )
|
|
{
|
|
nextState = AreOtherWaiting( next->waitList, threadBit ) ? LockState::HasBlockingLock : LockState::HasLock;
|
|
break;
|
|
}
|
|
else if( IsThreadWaiting( next->waitList, threadBit ) )
|
|
{
|
|
nextState = LockState::WaitLock;
|
|
break;
|
|
}
|
|
}
|
|
next++;
|
|
}
|
|
break;
|
|
case LockState::HasLock:
|
|
while( next < end )
|
|
{
|
|
if( next->lockCount == 0 )
|
|
{
|
|
nextState = LockState::Nothing;
|
|
break;
|
|
}
|
|
if( next->waitList != 0 )
|
|
{
|
|
if( AreOtherWaiting( next->waitList, threadBit ) )
|
|
{
|
|
nextState = LockState::HasBlockingLock;
|
|
}
|
|
break;
|
|
}
|
|
if( next->waitList != it->waitList || next->lockCount != it->lockCount )
|
|
{
|
|
break;
|
|
}
|
|
next++;
|
|
}
|
|
break;
|
|
case LockState::HasBlockingLock:
|
|
while( next < end )
|
|
{
|
|
if( next->lockCount == 0 )
|
|
{
|
|
nextState = LockState::Nothing;
|
|
break;
|
|
}
|
|
if( next->waitList != it->waitList || next->lockCount != it->lockCount )
|
|
{
|
|
break;
|
|
}
|
|
next++;
|
|
}
|
|
break;
|
|
case LockState::WaitLock:
|
|
while( next < end )
|
|
{
|
|
if( GetThreadBit( next->lockingThread ) == threadBit )
|
|
{
|
|
nextState = AreOtherWaiting( next->waitList, threadBit ) ? LockState::HasBlockingLock : LockState::HasLock;
|
|
break;
|
|
}
|
|
if( next->lockingThread != it->lockingThread )
|
|
{
|
|
break;
|
|
}
|
|
if( next->lockCount == 0 )
|
|
{
|
|
break;
|
|
}
|
|
next++;
|
|
}
|
|
break;
|
|
default:
|
|
assert( false );
|
|
break;
|
|
}
|
|
|
|
return next;
|
|
}
|
|
|
|
static LockState::Type CombineLockState( LockState::Type state, LockState::Type next )
|
|
{
|
|
return std::max( state, next );
|
|
}
|
|
|
|
static Vector<LockEventPtr>::const_iterator GetNextLockEventShared( const Vector<LockEventPtr>::const_iterator& it, const Vector<LockEventPtr>::const_iterator& end, LockState::Type& nextState, uint64_t threadBit )
|
|
{
|
|
const auto itptr = (const LockEventShared*)(const LockEvent*)it->ptr;
|
|
auto next = it;
|
|
next++;
|
|
|
|
switch( nextState )
|
|
{
|
|
case LockState::Nothing:
|
|
while( next < end )
|
|
{
|
|
const auto ptr = (const LockEventShared*)(const LockEvent*)next->ptr;
|
|
if( next->lockCount != 0 )
|
|
{
|
|
const auto wait = next->waitList | ptr->waitShared;
|
|
if( GetThreadBit( next->lockingThread ) == threadBit )
|
|
{
|
|
nextState = AreOtherWaiting( wait, threadBit ) ? LockState::HasBlockingLock : LockState::HasLock;
|
|
break;
|
|
}
|
|
else if( IsThreadWaiting( wait, threadBit ) )
|
|
{
|
|
nextState = LockState::WaitLock;
|
|
break;
|
|
}
|
|
}
|
|
else if( IsThreadWaiting( ptr->sharedList, threadBit ) )
|
|
{
|
|
nextState = ( next->waitList != 0 ) ? LockState::HasBlockingLock : LockState::HasLock;
|
|
break;
|
|
}
|
|
else if( ptr->sharedList != 0 && IsThreadWaiting( next->waitList, threadBit ) )
|
|
{
|
|
nextState = LockState::WaitLock;
|
|
break;
|
|
}
|
|
next++;
|
|
}
|
|
break;
|
|
case LockState::HasLock:
|
|
while( next < end )
|
|
{
|
|
const auto ptr = (const LockEventShared*)(const LockEvent*)next->ptr;
|
|
if( next->lockCount == 0 && !IsThreadWaiting( ptr->sharedList, threadBit ) )
|
|
{
|
|
nextState = LockState::Nothing;
|
|
break;
|
|
}
|
|
if( next->waitList != 0 )
|
|
{
|
|
if( AreOtherWaiting( next->waitList, threadBit ) )
|
|
{
|
|
nextState = LockState::HasBlockingLock;
|
|
}
|
|
break;
|
|
}
|
|
else if( !IsThreadWaiting( ptr->sharedList, threadBit ) && ptr->waitShared != 0 )
|
|
{
|
|
nextState = LockState::HasBlockingLock;
|
|
break;
|
|
}
|
|
if( next->waitList != it->waitList || ptr->waitShared != itptr->waitShared || next->lockCount != it->lockCount || ptr->sharedList != itptr->sharedList )
|
|
{
|
|
break;
|
|
}
|
|
next++;
|
|
}
|
|
break;
|
|
case LockState::HasBlockingLock:
|
|
while( next < end )
|
|
{
|
|
const auto ptr = (const LockEventShared*)(const LockEvent*)next->ptr;
|
|
if( next->lockCount == 0 && !IsThreadWaiting( ptr->sharedList, threadBit ) )
|
|
{
|
|
nextState = LockState::Nothing;
|
|
break;
|
|
}
|
|
if( next->waitList != it->waitList || ptr->waitShared != itptr->waitShared || next->lockCount != it->lockCount || ptr->sharedList != itptr->sharedList )
|
|
{
|
|
break;
|
|
}
|
|
next++;
|
|
}
|
|
break;
|
|
case LockState::WaitLock:
|
|
while( next < end )
|
|
{
|
|
const auto ptr = (const LockEventShared*)(const LockEvent*)next->ptr;
|
|
if( GetThreadBit( next->lockingThread ) == threadBit )
|
|
{
|
|
const auto wait = next->waitList | ptr->waitShared;
|
|
nextState = AreOtherWaiting( wait, threadBit ) ? LockState::HasBlockingLock : LockState::HasLock;
|
|
break;
|
|
}
|
|
if( IsThreadWaiting( ptr->sharedList, threadBit ) )
|
|
{
|
|
nextState = ( next->waitList != 0 ) ? LockState::HasBlockingLock : LockState::HasLock;
|
|
break;
|
|
}
|
|
if( next->lockingThread != it->lockingThread )
|
|
{
|
|
break;
|
|
}
|
|
if( next->lockCount == 0 && !IsThreadWaiting( ptr->waitShared, threadBit ) )
|
|
{
|
|
break;
|
|
}
|
|
next++;
|
|
}
|
|
break;
|
|
default:
|
|
assert( false );
|
|
break;
|
|
}
|
|
|
|
return next;
|
|
}
|
|
|
|
void TimelineItemThread::PreprocessLocks( const TimelineContext& ctx, const unordered_flat_map<uint32_t, LockMap*>& locks, uint32_t tid, TaskDispatch& td, bool visible )
|
|
{
|
|
const auto vStart = ctx.vStart;
|
|
const auto vEnd = ctx.vEnd;
|
|
const auto nspx = ctx.nspx;
|
|
|
|
const auto& vd = m_view.GetViewData();
|
|
const auto lockInfoWindow = m_view.GetLockInfoWindow();
|
|
|
|
const auto MinVisNs = int64_t( round( GetScale() * MinVisSize * nspx ) );
|
|
|
|
for( auto& v : locks )
|
|
{
|
|
const auto& lockmap = *v.second;
|
|
if( !lockmap.valid ) continue;
|
|
if( !m_view.Vis( &lockmap ) ) continue;
|
|
if( vd.onlyContendedLocks && lockInfoWindow != v.first && ( lockmap.threadList.size() == 1 || !lockmap.isContended ) ) continue;
|
|
|
|
auto it = lockmap.threadMap.find( tid );
|
|
if( it == lockmap.threadMap.end() ) continue;
|
|
|
|
assert( !lockmap.timeline.empty() );
|
|
const auto& range = lockmap.range[it->second];
|
|
if( range.start > vEnd || range.end < vStart )
|
|
{
|
|
if( lockInfoWindow == v.first )
|
|
{
|
|
m_lockDraw.emplace_back( std::make_unique<LockDraw>( LockDraw { v.first, true, it->second } ) );
|
|
}
|
|
continue;
|
|
}
|
|
|
|
auto drawData = std::make_unique<LockDraw>( LockDraw { v.first, false, it->second } );
|
|
auto drawPtr = drawData.get();
|
|
m_lockDraw.emplace_back( std::move( drawData ) );
|
|
|
|
td.Queue( [this, it, &lockmap, &ctx, &range, &vd, visible, drawPtr, MinVisNs] {
|
|
const auto vStart = ctx.vStart;
|
|
const auto vEnd = ctx.vEnd;
|
|
|
|
auto GetNextLockFunc = lockmap.type == LockType::Lockable ? GetNextLockEvent : GetNextLockEventShared;
|
|
const auto thread = it->second;
|
|
const auto threadBit = GetThreadBit( thread );
|
|
const auto& tl = lockmap.timeline;
|
|
|
|
auto vbegin = std::lower_bound( tl.begin(), tl.end(), std::max( range.start, vStart ), [] ( const auto& l, const auto& r ) { return l.ptr->Time() < r; } );
|
|
const auto vend = std::lower_bound( vbegin, tl.end(), std::min( range.end, vEnd ), [] ( const auto& l, const auto& r ) { return l.ptr->Time() < r; } );
|
|
|
|
if( vbegin > tl.begin() ) vbegin--;
|
|
|
|
LockState::Type state = LockState::Nothing;
|
|
if( lockmap.type == LockType::Lockable )
|
|
{
|
|
if( vbegin->lockCount != 0 )
|
|
{
|
|
if( vbegin->lockingThread == thread )
|
|
{
|
|
state = AreOtherWaiting( vbegin->waitList, threadBit ) ? LockState::HasBlockingLock : LockState::HasLock;
|
|
}
|
|
else if( IsThreadWaiting( vbegin->waitList, threadBit ) )
|
|
{
|
|
state = LockState::WaitLock;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
auto ptr = (const LockEventShared*)(const LockEvent*)vbegin->ptr;
|
|
if( vbegin->lockCount != 0 )
|
|
{
|
|
if( vbegin->lockingThread == thread )
|
|
{
|
|
state = ( AreOtherWaiting( vbegin->waitList, threadBit ) || AreOtherWaiting( ptr->waitShared, threadBit ) ) ? LockState::HasBlockingLock : LockState::HasLock;
|
|
}
|
|
else if( IsThreadWaiting( vbegin->waitList, threadBit ) || IsThreadWaiting( ptr->waitShared, threadBit ) )
|
|
{
|
|
state = LockState::WaitLock;
|
|
}
|
|
}
|
|
else if( IsThreadWaiting( ptr->sharedList, threadBit ) )
|
|
{
|
|
state = vbegin->waitList != 0 ? LockState::HasBlockingLock : LockState::HasLock;
|
|
}
|
|
else if( ptr->sharedList != 0 && IsThreadWaiting( vbegin->waitList, threadBit ) )
|
|
{
|
|
state = LockState::WaitLock;
|
|
}
|
|
}
|
|
|
|
const uint8_t mask = vd.onlyContendedLocks ? ( LockState::Nothing | LockState::HasLock ) : LockState::Nothing;
|
|
if( !visible )
|
|
{
|
|
while( vbegin < vend && ( state & mask ) != 0 )
|
|
{
|
|
vbegin = GetNextLockFunc( vbegin, vend, state, threadBit );
|
|
}
|
|
drawPtr->forceDraw = vbegin < vend;
|
|
return;
|
|
}
|
|
|
|
auto& dst = drawPtr->data;
|
|
for(;;)
|
|
{
|
|
while( vbegin < vend && ( state & mask ) != 0 )
|
|
{
|
|
vbegin = GetNextLockFunc( vbegin, vend, state, threadBit );
|
|
}
|
|
if( vbegin >= vend ) break;
|
|
assert( ( state & mask ) == 0 );
|
|
|
|
LockState::Type drawState = state;
|
|
auto next = GetNextLockFunc( vbegin, vend, state, threadBit );
|
|
|
|
const auto tStart = vbegin->ptr->Time();
|
|
int64_t t0 = tStart;
|
|
int64_t t1 = next == tl.end() ? m_worker.GetLastTime() : next->ptr->Time();
|
|
uint32_t condensed = 0;
|
|
|
|
for(;;)
|
|
{
|
|
if( next >= vend || t1 - t0 > MinVisNs ) break;
|
|
auto n = next;
|
|
auto ns = state;
|
|
while( n < vend && ( ns & mask ) != 0 )
|
|
{
|
|
n = GetNextLockFunc( n, vend, ns, threadBit );
|
|
}
|
|
if( n >= vend ) break;
|
|
if( n == next )
|
|
{
|
|
n = GetNextLockFunc( n, vend, ns, threadBit );
|
|
}
|
|
drawState = CombineLockState( drawState, state );
|
|
condensed++;
|
|
const auto t2 = n == tl.end() ? m_worker.GetLastTime() : n->ptr->Time();
|
|
if( t2 - t1 > MinVisNs ) break;
|
|
if( drawState != ns && t2 - tStart > MinVisNs && ( ns & mask ) == 0 ) break;
|
|
t0 = t1;
|
|
t1 = t2;
|
|
next = n;
|
|
state = ns;
|
|
}
|
|
|
|
dst.emplace_back( LockDrawItem { t1, drawState, condensed, vbegin, next } );
|
|
|
|
vbegin = next;
|
|
}
|
|
} );
|
|
}
|
|
}
|
|
|
|
}
|