2022-07-02 15:13:20 +00:00
|
|
|
#include <numeric>
|
2022-12-23 17:48:05 +00:00
|
|
|
#include <sstream>
|
|
|
|
|
|
|
|
#include "../dtl/dtl.hpp"
|
2022-07-02 15:13:20 +00:00
|
|
|
|
2022-07-02 15:00:08 +00:00
|
|
|
#include "TracyImGui.hpp"
|
2022-07-02 11:48:54 +00:00
|
|
|
#include "TracyFileRead.hpp"
|
2022-10-05 20:50:17 +00:00
|
|
|
#include "TracyFileselector.hpp"
|
2022-07-02 11:48:54 +00:00
|
|
|
#include "TracyPrint.hpp"
|
|
|
|
#include "TracyView.hpp"
|
|
|
|
|
|
|
|
namespace tracy
|
|
|
|
{
|
|
|
|
|
|
|
|
extern double s_time;
|
|
|
|
|
|
|
|
#ifndef TRACY_NO_STATISTICS
|
|
|
|
void View::FindZonesCompare()
|
|
|
|
{
|
|
|
|
m_compare.match[0] = m_worker.GetMatchingSourceLocation( m_compare.pattern, m_compare.ignoreCase );
|
|
|
|
if( !m_compare.match[0].empty() )
|
|
|
|
{
|
|
|
|
auto it = m_compare.match[0].begin();
|
|
|
|
while( it != m_compare.match[0].end() )
|
|
|
|
{
|
|
|
|
if( m_worker.GetZonesForSourceLocation( *it ).zones.empty() )
|
|
|
|
{
|
|
|
|
it = m_compare.match[0].erase( it );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
m_compare.match[1] = m_compare.second->GetMatchingSourceLocation( m_compare.pattern, m_compare.ignoreCase );
|
|
|
|
if( !m_compare.match[1].empty() )
|
|
|
|
{
|
|
|
|
auto it = m_compare.match[1].begin();
|
|
|
|
while( it != m_compare.match[1].end() )
|
|
|
|
{
|
|
|
|
if( m_compare.second->GetZonesForSourceLocation( *it ).zones.empty() )
|
|
|
|
{
|
|
|
|
it = m_compare.match[1].erase( it );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
++it;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
bool View::FindMatchingZone( int prev0, int prev1, int flags )
|
|
|
|
{
|
|
|
|
int idx = 0;
|
|
|
|
bool found = false;
|
|
|
|
auto& srcloc0 = m_worker.GetSourceLocation( m_compare.match[0][m_compare.selMatch[0]] );
|
|
|
|
auto& srcloc1 = m_compare.second->GetSourceLocation( m_compare.match[1][m_compare.selMatch[1]] );
|
|
|
|
auto string0 = m_worker.GetString( srcloc0.name.active ? srcloc0.name : srcloc0.function );
|
|
|
|
auto string1 = m_compare.second->GetString( srcloc1.name.active ? srcloc1.name : srcloc1.function );
|
|
|
|
auto file0 = m_worker.GetString( srcloc0.file );
|
|
|
|
auto file1 = m_compare.second->GetString( srcloc1.file );
|
|
|
|
bool wrongFile = false;
|
|
|
|
bool wrongLine = false;
|
|
|
|
if( flags & FindMatchingZoneFlagSourceFile )
|
|
|
|
{
|
|
|
|
wrongFile = strcmp( file0, file1 ) != 0;
|
|
|
|
}
|
|
|
|
if( flags & FindMatchingZoneFlagLineNum )
|
|
|
|
{
|
|
|
|
wrongLine = srcloc0.line != srcloc1.line;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( strcmp( string0, string1 ) != 0 || wrongFile || wrongLine )
|
|
|
|
{
|
|
|
|
if( prev0 != m_compare.selMatch[0] )
|
|
|
|
{
|
|
|
|
for( auto& v : m_compare.match[1] )
|
|
|
|
{
|
|
|
|
auto& srcloc = m_compare.second->GetSourceLocation( v );
|
|
|
|
auto string = m_compare.second->GetString( srcloc.name.active ? srcloc.name : srcloc.function );
|
|
|
|
auto file = m_compare.second->GetString( srcloc.file );
|
|
|
|
bool sameFile = true;
|
|
|
|
bool sameLine = true;
|
|
|
|
if( flags & FindMatchingZoneFlagSourceFile )
|
|
|
|
{
|
|
|
|
sameFile = strcmp( file0, file ) == 0;
|
|
|
|
}
|
|
|
|
if( flags & FindMatchingZoneFlagLineNum )
|
|
|
|
{
|
|
|
|
sameLine = srcloc0.line == srcloc.line;
|
|
|
|
}
|
|
|
|
if( strcmp( string0, string ) == 0 && sameFile && sameLine )
|
|
|
|
{
|
|
|
|
m_compare.selMatch[1] = idx;
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
assert( prev1 != m_compare.selMatch[1] );
|
|
|
|
for( auto& v : m_compare.match[0] )
|
|
|
|
{
|
|
|
|
auto& srcloc = m_worker.GetSourceLocation( v );
|
|
|
|
auto string = m_worker.GetString( srcloc.name.active ? srcloc.name : srcloc.function );
|
|
|
|
auto file = m_worker.GetString( srcloc.file );
|
|
|
|
bool sameFile = true;
|
|
|
|
bool sameLine = true;
|
|
|
|
if( flags & FindMatchingZoneFlagSourceFile )
|
|
|
|
{
|
|
|
|
sameFile = strcmp( file1, file ) == 0;
|
|
|
|
}
|
|
|
|
if( flags & FindMatchingZoneFlagLineNum )
|
|
|
|
{
|
|
|
|
sameLine = srcloc1.line == srcloc.line;
|
|
|
|
}
|
|
|
|
if( strcmp( string1, string ) == 0 && sameFile && sameLine )
|
|
|
|
{
|
|
|
|
m_compare.selMatch[0] = idx;
|
|
|
|
found = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return found;
|
|
|
|
}
|
|
|
|
|
2022-12-23 17:47:26 +00:00
|
|
|
static std::vector<std::string> SplitLines( const char* data, size_t sz )
|
|
|
|
{
|
|
|
|
std::vector<std::string> ret;
|
|
|
|
auto txt = data;
|
|
|
|
for(;;)
|
|
|
|
{
|
|
|
|
auto end = txt;
|
|
|
|
while( *end != '\n' && *end != '\r' && end - data < sz ) end++;
|
|
|
|
ret.emplace_back( std::string { txt, end } );
|
|
|
|
if( end - data == sz ) break;
|
|
|
|
if( *end == '\n' )
|
|
|
|
{
|
|
|
|
end++;
|
|
|
|
if( end - data < sz && *end == '\r' ) end++;
|
|
|
|
}
|
|
|
|
else if( *end == '\r' )
|
|
|
|
{
|
|
|
|
end++;
|
|
|
|
if( end - data < sz && *end == '\n' ) end++;
|
|
|
|
}
|
|
|
|
if( end - data == sz ) break;
|
|
|
|
txt = end;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2022-12-23 18:14:18 +00:00
|
|
|
static void PrintFile( const char* data, size_t sz, uint32_t color )
|
|
|
|
{
|
|
|
|
auto lines = SplitLines( data, sz );
|
|
|
|
for( auto& v : lines )
|
|
|
|
{
|
|
|
|
TextColoredUnformatted( color, v.c_str() );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void PrintDiff( const std::string& diff )
|
|
|
|
{
|
|
|
|
auto lines = SplitLines( diff.data(), diff.size() );
|
|
|
|
for( auto& v : lines )
|
|
|
|
{
|
|
|
|
assert( !v.empty() );
|
|
|
|
switch( v[0] )
|
|
|
|
{
|
|
|
|
case '@': TextColoredUnformatted( 0xFFFFAAAA, v.c_str() ); break;
|
|
|
|
case '-': TextColoredUnformatted( 0xFF6666FF, v.c_str() ); break;
|
|
|
|
case '+': TextColoredUnformatted( 0xFF66DD66, v.c_str() ); break;
|
|
|
|
default: TextDisabledUnformatted( v.c_str() ); break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-02 11:48:54 +00:00
|
|
|
void View::DrawCompare()
|
|
|
|
{
|
|
|
|
const auto scale = GetScale();
|
|
|
|
ImGui::SetNextWindowSize( ImVec2( 590 * scale, 800 * scale ), ImGuiCond_FirstUseEver );
|
|
|
|
ImGui::Begin( "Compare traces", &m_compare.show, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse );
|
|
|
|
if( ImGui::GetCurrentWindowRead()->SkipItems ) { ImGui::End(); return; }
|
|
|
|
#ifdef TRACY_NO_STATISTICS
|
|
|
|
ImGui::TextWrapped( "Collection of statistical data is disabled in this build." );
|
|
|
|
ImGui::TextWrapped( "Rebuild without the TRACY_NO_STATISTICS macro to enable trace comparison." );
|
|
|
|
#elif defined TRACY_NO_FILESELECTOR
|
|
|
|
ImGui::TextWrapped( "File selector is disabled in this build." );
|
|
|
|
ImGui::TextWrapped( "Rebuild without the TRACY_NO_FILESELECTOR macro to enable trace comparison." );
|
|
|
|
#else
|
|
|
|
if( !m_compare.second )
|
|
|
|
{
|
|
|
|
ImGui::TextWrapped( "Please load a second trace to compare results." );
|
|
|
|
if( ImGui::Button( ICON_FA_FOLDER_OPEN " Open second trace" ) && !m_compare.loadThread.joinable() )
|
|
|
|
{
|
2022-10-06 15:35:07 +00:00
|
|
|
Fileselector::OpenFile( "tracy", "Tracy Profiler trace file", [this]( const char* fn ) {
|
2022-07-02 11:48:54 +00:00
|
|
|
try
|
|
|
|
{
|
2022-10-06 15:35:07 +00:00
|
|
|
auto f = std::shared_ptr<tracy::FileRead>( tracy::FileRead::Open( fn ) );
|
2022-07-02 11:48:54 +00:00
|
|
|
if( f )
|
|
|
|
{
|
|
|
|
m_compare.loadThread = std::thread( [this, f] {
|
|
|
|
try
|
|
|
|
{
|
2022-12-23 16:10:21 +00:00
|
|
|
m_compare.second = std::make_unique<Worker>( *f, EventType::SourceCache );
|
2022-07-02 11:48:54 +00:00
|
|
|
m_compare.userData = std::make_unique<UserData>( m_compare.second->GetCaptureProgram().c_str(), m_compare.second->GetCaptureTime() );
|
2022-12-30 19:33:17 +00:00
|
|
|
m_compare.diffDirection = m_worker.GetCaptureTime() < m_compare.second->GetCaptureTime();
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
catch( const tracy::UnsupportedVersion& e )
|
|
|
|
{
|
|
|
|
m_compare.badVer.state = BadVersionState::UnsupportedVersion;
|
|
|
|
m_compare.badVer.version = e.version;
|
|
|
|
}
|
2022-10-06 15:35:07 +00:00
|
|
|
} );
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
catch( const tracy::NotTracyDump& )
|
|
|
|
{
|
|
|
|
m_compare.badVer.state = BadVersionState::BadFile;
|
|
|
|
}
|
|
|
|
catch( const tracy::FileReadError& )
|
|
|
|
{
|
|
|
|
m_compare.badVer.state = BadVersionState::ReadError;
|
|
|
|
}
|
2022-10-06 15:35:07 +00:00
|
|
|
} );
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
tracy::BadVersion( m_compare.badVer, m_bigFont );
|
|
|
|
ImGui::End();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( m_compare.loadThread.joinable() ) m_compare.loadThread.join();
|
|
|
|
|
|
|
|
if( !m_worker.AreSourceLocationZonesReady() || !m_compare.second->AreSourceLocationZonesReady() )
|
|
|
|
{
|
|
|
|
ImGui::TextWrapped( "Please wait, computing data..." );
|
|
|
|
DrawWaitingDots( s_time );
|
|
|
|
ImGui::End();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/255.f, 0xDD/255.f, 0x22/255.f, 1.f ), ICON_FA_LEMON );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextDisabledUnformatted( "This trace:" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
const auto& desc0 = m_userData.GetDescription();
|
|
|
|
if( desc0.empty() )
|
|
|
|
{
|
|
|
|
ImGui::TextUnformatted( m_worker.GetCaptureName().c_str() );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ImGui::TextUnformatted( desc0.c_str() );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%s)", m_worker.GetCaptureName().c_str() );
|
|
|
|
}
|
|
|
|
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/255.f, 0x22/255.f, 0x22/255.f, 1.f ), ICON_FA_GEM );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextDisabledUnformatted( "External trace:" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
const auto& desc1 = m_compare.userData->GetDescription();
|
|
|
|
if( desc1.empty() )
|
|
|
|
{
|
|
|
|
ImGui::TextUnformatted( m_compare.second->GetCaptureName().c_str() );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ImGui::TextUnformatted( desc1.c_str() );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%s)", m_compare.second->GetCaptureName().c_str() );
|
|
|
|
}
|
|
|
|
|
2022-08-17 10:07:38 +00:00
|
|
|
if( ImGui::Button( ICON_FA_TRASH_CAN " Unload" ) )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
|
|
|
m_compare.Reset();
|
|
|
|
m_compare.second.reset();
|
|
|
|
m_compare.userData.reset();
|
|
|
|
ImGui::End();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Spacing();
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Text( "Compare mode: " );
|
|
|
|
ImGui::SameLine();
|
|
|
|
const auto oldMode = m_compare.compareMode;
|
|
|
|
ImGui::RadioButton( "Zones", &m_compare.compareMode, 0 );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::RadioButton( "Frames", &m_compare.compareMode, 1 );
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::RadioButton( "Source diff", &m_compare.compareMode, 2 );
|
2022-07-02 11:48:54 +00:00
|
|
|
if( oldMode != m_compare.compareMode )
|
|
|
|
{
|
|
|
|
m_compare.Reset();
|
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.compareMode == 2 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
|
|
|
ImGui::Separator();
|
|
|
|
ImGui::BeginChild( "##compare" );
|
2022-12-23 16:11:47 +00:00
|
|
|
|
2022-12-30 19:33:17 +00:00
|
|
|
TextDisabledUnformatted( "Diff direction: " );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/255.f, 0xDD/255.f, 0x22/255.f, 1.f ), ICON_FA_LEMON );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Text( " %s ", m_compare.diffDirection ? ICON_FA_ARROW_RIGHT : ICON_FA_ARROW_LEFT );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/255.f, 0x22/255.f, 0x22/255.f, 1.f ), ICON_FA_GEM );
|
|
|
|
ImGui::SameLine();
|
|
|
|
if( ImGui::SmallButton( "Switch" ) )
|
|
|
|
{
|
|
|
|
m_compare.diffDirection = !m_compare.diffDirection;
|
|
|
|
m_compare.Reset();
|
|
|
|
}
|
|
|
|
ImGui::Separator();
|
|
|
|
|
|
|
|
ImGui::BeginChild( "##diff" );
|
|
|
|
|
|
|
|
const auto& tfc = m_compare.diffDirection ? m_worker.GetSourceFileCache() : m_compare.second->GetSourceFileCache();
|
|
|
|
const auto& ofc = m_compare.diffDirection ? m_compare.second->GetSourceFileCache() : m_worker.GetSourceFileCache();
|
2022-12-23 18:14:31 +00:00
|
|
|
|
2022-12-23 16:11:47 +00:00
|
|
|
if( !m_compare.diffDone )
|
|
|
|
{
|
|
|
|
m_compare.diffDone = true;
|
|
|
|
|
|
|
|
if( !tfc.empty() && !ofc.empty() )
|
|
|
|
{
|
|
|
|
for( auto& tv : tfc )
|
|
|
|
{
|
|
|
|
auto it = ofc.find( tv.first );
|
|
|
|
if( it == ofc.end() )
|
|
|
|
{
|
|
|
|
m_compare.thisUnique.emplace_back( tv.first );
|
|
|
|
}
|
|
|
|
else if( tv.second.len != it->second.len || memcmp( tv.second.data, it->second.data, tv.second.len ) != 0 )
|
|
|
|
{
|
2022-12-23 17:48:05 +00:00
|
|
|
auto src0 = SplitLines( tv.second.data, tv.second.len );
|
|
|
|
auto src1 = SplitLines( it->second.data, it->second.len );
|
|
|
|
dtl::Diff<std::string, std::vector<std::string>> diff { src0, src1 };
|
|
|
|
diff.compose();
|
|
|
|
diff.composeUnifiedHunks();
|
|
|
|
std::ostringstream stream;
|
|
|
|
diff.printUnifiedFormat( stream );
|
|
|
|
m_compare.diffs.emplace_back( std::make_pair( tv.first, stream.str() ) );
|
2022-12-23 16:11:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
for( auto& ov : ofc )
|
|
|
|
{
|
|
|
|
auto it = tfc.find( ov.first );
|
|
|
|
if( it == tfc.end() )
|
|
|
|
{
|
|
|
|
m_compare.secondUnique.emplace_back( ov.first );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
std::sort( m_compare.thisUnique.begin(), m_compare.thisUnique.end(), []( const auto& lhs, const auto& rhs ) { return strcmp( lhs, rhs ) < 0; } );
|
|
|
|
std::sort( m_compare.secondUnique.begin(), m_compare.secondUnique.end(), []( const auto& lhs, const auto& rhs ) { return strcmp( lhs, rhs ) < 0; } );
|
2022-12-23 17:48:05 +00:00
|
|
|
std::sort( m_compare.diffs.begin(), m_compare.diffs.end(), []( const auto& lhs, const auto& rhs ) { return strcmp( lhs.first, rhs.first ) < 0; } );
|
2022-12-23 16:11:47 +00:00
|
|
|
}
|
|
|
|
}
|
2022-12-23 18:14:31 +00:00
|
|
|
|
|
|
|
if( m_compare.thisUnique.empty() && m_compare.secondUnique.empty() && m_compare.diffs.empty() )
|
|
|
|
{
|
|
|
|
ImGui::TextUnformatted( "Source files are identical." );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( !m_compare.thisUnique.empty() )
|
|
|
|
{
|
2022-12-30 19:20:52 +00:00
|
|
|
const auto expand = ImGui::TreeNode( ICON_FA_FILE_CIRCLE_XMARK " Deleted files" );
|
2022-12-23 18:14:31 +00:00
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%s)", RealToString( m_compare.thisUnique.size() ) );
|
|
|
|
if( expand )
|
|
|
|
{
|
|
|
|
for( auto& v : m_compare.thisUnique )
|
|
|
|
{
|
|
|
|
if( ImGui::TreeNode( v ) )
|
|
|
|
{
|
|
|
|
auto it = tfc.find( v );
|
|
|
|
assert( it != tfc.end() );
|
|
|
|
ImGui::PushFont( m_fixedFont );
|
2022-12-23 18:56:39 +00:00
|
|
|
ImGui::PushStyleVar( ImGuiStyleVar_ItemSpacing, ImVec2( 0, 0 ) );
|
2022-12-23 18:14:31 +00:00
|
|
|
PrintFile( it->second.data, it->second.len, 0xFF6666FF );
|
2022-12-23 18:56:39 +00:00
|
|
|
ImGui::PopStyleVar();
|
2022-12-23 18:14:31 +00:00
|
|
|
ImGui::PopFont();
|
|
|
|
ImGui::TreePop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ImGui::TreePop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( !m_compare.secondUnique.empty() )
|
|
|
|
{
|
2022-12-30 19:20:52 +00:00
|
|
|
const auto expand = ImGui::TreeNode( ICON_FA_FILE_CIRCLE_PLUS " Added files" );
|
2022-12-23 18:14:31 +00:00
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%s)", RealToString( m_compare.secondUnique.size() ) );
|
|
|
|
if( expand )
|
|
|
|
{
|
|
|
|
for( auto& v : m_compare.secondUnique )
|
|
|
|
{
|
|
|
|
if( ImGui::TreeNode( v ) )
|
|
|
|
{
|
|
|
|
auto it = ofc.find( v );
|
|
|
|
assert( it != ofc.end() );
|
|
|
|
ImGui::PushFont( m_fixedFont );
|
2022-12-23 18:56:39 +00:00
|
|
|
ImGui::PushStyleVar( ImGuiStyleVar_ItemSpacing, ImVec2( 0, 0 ) );
|
2022-12-23 18:14:31 +00:00
|
|
|
PrintFile( it->second.data, it->second.len, 0xFF66DD66 );
|
2022-12-23 18:56:39 +00:00
|
|
|
ImGui::PopStyleVar();
|
2022-12-23 18:14:31 +00:00
|
|
|
ImGui::PopFont();
|
|
|
|
ImGui::TreePop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ImGui::TreePop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( !m_compare.diffs.empty() )
|
|
|
|
{
|
|
|
|
const auto expand = ImGui::TreeNodeEx( ICON_FA_FILE_PEN " Changed files", ImGuiTreeNodeFlags_DefaultOpen );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%s)", RealToString( m_compare.diffs.size() ) );
|
|
|
|
if( expand )
|
|
|
|
{
|
|
|
|
for( auto& v : m_compare.diffs )
|
|
|
|
{
|
|
|
|
if( ImGui::TreeNode( v.first ) )
|
|
|
|
{
|
|
|
|
ImGui::PushFont( m_fixedFont );
|
2022-12-23 18:56:39 +00:00
|
|
|
ImGui::PushStyleVar( ImGuiStyleVar_ItemSpacing, ImVec2( 0, 0 ) );
|
2022-12-23 18:14:31 +00:00
|
|
|
PrintDiff( v.second );
|
2022-12-23 18:56:39 +00:00
|
|
|
ImGui::PopStyleVar();
|
2022-12-23 18:14:31 +00:00
|
|
|
ImGui::PopFont();
|
|
|
|
ImGui::TreePop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ImGui::TreePop();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-12-30 19:33:17 +00:00
|
|
|
ImGui::EndChild();
|
2022-12-23 15:54:07 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
bool findClicked = false;
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.compareMode == 0 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::PushItemWidth( -0.01f );
|
|
|
|
findClicked |= ImGui::InputTextWithHint( "###compare", "Enter zone name to search for", m_compare.pattern, 1024, ImGuiInputTextFlags_EnterReturnsTrue );
|
|
|
|
ImGui::PopItemWidth();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
findClicked |= ImGui::Button( ICON_FA_MAGNIFYING_GLASS " Find" );
|
2022-07-02 11:48:54 +00:00
|
|
|
ImGui::SameLine();
|
2022-12-23 15:54:07 +00:00
|
|
|
|
|
|
|
if( ImGui::Button( ICON_FA_BAN " Clear" ) )
|
|
|
|
{
|
|
|
|
m_compare.Reset();
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
ImGui::SameLine();
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::Checkbox( "Ignore case", &m_compare.ignoreCase );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( findClicked )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
m_compare.Reset();
|
|
|
|
FindZonesCompare();
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.match[0].empty() && m_compare.match[1].empty() )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::End();
|
|
|
|
return;
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::Separator();
|
|
|
|
ImGui::BeginChild( "##compare" );
|
|
|
|
|
|
|
|
if( ImGui::TreeNodeEx( "Matched source locations", ImGuiTreeNodeFlags_DefaultOpen ) )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::SameLine();
|
|
|
|
SmallCheckbox( "Link selection", &m_compare.link );
|
|
|
|
|
|
|
|
ImGui::Separator();
|
|
|
|
ImGui::Columns( 2 );
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/255.f, 0xDD/255.f, 0x22/255.f, 1.f ), ICON_FA_LEMON );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextUnformatted( "This trace" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%zu)", m_compare.match[0].size() );
|
|
|
|
ImGui::NextColumn();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/255.f, 0x22/255.f, 0x22/255.f, 1.f ), ICON_FA_GEM );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextUnformatted( "External trace" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%zu)", m_compare.match[1].size() );
|
|
|
|
ImGui::Separator();
|
|
|
|
ImGui::NextColumn();
|
|
|
|
|
|
|
|
const auto prev0 = m_compare.selMatch[0];
|
|
|
|
int idx = 0;
|
|
|
|
for( auto& v : m_compare.match[0] )
|
|
|
|
{
|
|
|
|
auto& srcloc = m_worker.GetSourceLocation( v );
|
|
|
|
auto& zones = m_worker.GetZonesForSourceLocation( v ).zones;
|
|
|
|
SmallColorBox( GetSrcLocColor( srcloc, 0 ) );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::PushID( idx );
|
|
|
|
ImGui::PushStyleVar( ImGuiStyleVar_FramePadding, ImVec2( 0, 0 ) );
|
|
|
|
ImGui::RadioButton( m_worker.GetString( srcloc.name.active ? srcloc.name : srcloc.function ), &m_compare.selMatch[0], idx++ );
|
|
|
|
ImGui::PopStyleVar();
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextColored( ImVec4( 0.5, 0.5, 0.5, 1 ), "(%s) %s", RealToString( zones.size() ), LocationToString( m_worker.GetString( srcloc.file ), srcloc.line ) );
|
|
|
|
ImGui::PopID();
|
|
|
|
}
|
|
|
|
ImGui::NextColumn();
|
|
|
|
|
|
|
|
const auto prev1 = m_compare.selMatch[1];
|
|
|
|
idx = 0;
|
|
|
|
for( auto& v : m_compare.match[1] )
|
|
|
|
{
|
|
|
|
auto& srcloc = m_compare.second->GetSourceLocation( v );
|
|
|
|
auto& zones = m_compare.second->GetZonesForSourceLocation( v ).zones;
|
|
|
|
ImGui::PushID( -1 - idx );
|
|
|
|
ImGui::PushStyleVar( ImGuiStyleVar_FramePadding, ImVec2( 0, 0 ) );
|
|
|
|
ImGui::RadioButton( m_compare.second->GetString( srcloc.name.active ? srcloc.name : srcloc.function ), &m_compare.selMatch[1], idx++ );
|
|
|
|
ImGui::PopStyleVar();
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextColored( ImVec4( 0.5, 0.5, 0.5, 1 ), "(%s) %s", RealToString( zones.size() ), LocationToString( m_compare.second->GetString( srcloc.file ), srcloc.line ) );
|
|
|
|
ImGui::PopID();
|
|
|
|
}
|
|
|
|
ImGui::NextColumn();
|
|
|
|
ImGui::EndColumns();
|
|
|
|
ImGui::TreePop();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( prev0 != m_compare.selMatch[0] || prev1 != m_compare.selMatch[1] )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
m_compare.ResetSelection();
|
|
|
|
|
|
|
|
if( m_compare.link )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
if( !FindMatchingZone( prev0, prev1, FindMatchingZoneFlagSourceFile | FindMatchingZoneFlagLineNum ) )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
if( !FindMatchingZone( prev0, prev1, FindMatchingZoneFlagSourceFile ) )
|
|
|
|
{
|
|
|
|
FindMatchingZone( prev0, prev1, FindMatchingZoneFlagDefault );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.match[0].empty() || m_compare.match[1].empty() )
|
|
|
|
{
|
|
|
|
ImGui::Separator();
|
|
|
|
ImGui::TextWrapped( "Both traces must have matches." );
|
|
|
|
ImGui::End();
|
|
|
|
return;
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
2022-12-23 15:54:07 +00:00
|
|
|
else
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
assert( m_compare.compareMode == 1 );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
|
|
|
ImGui::Separator();
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::BeginChild( "##compare" );
|
|
|
|
if( ImGui::TreeNodeEx( "Frame sets", ImGuiTreeNodeFlags_DefaultOpen ) )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto& f0 = m_worker.GetFrames();
|
|
|
|
const auto& f1 = m_compare.second->GetFrames();
|
|
|
|
|
2022-07-02 11:48:54 +00:00
|
|
|
ImGui::SameLine();
|
2022-12-23 15:54:07 +00:00
|
|
|
SmallCheckbox( "Link selection", &m_compare.link );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::Separator();
|
|
|
|
ImGui::Columns( 2 );
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/255.f, 0xDD/255.f, 0x22/255.f, 1.f ), ICON_FA_LEMON );
|
2022-07-02 11:48:54 +00:00
|
|
|
ImGui::SameLine();
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::TextUnformatted( "This trace" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%zu)", f0.size() );
|
|
|
|
ImGui::NextColumn();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/255.f, 0x22/255.f, 0x22/255.f, 1.f ), ICON_FA_GEM );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextUnformatted( "External trace" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%zu)", f1.size() );
|
|
|
|
ImGui::Separator();
|
|
|
|
ImGui::NextColumn();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto prev0 = m_compare.selMatch[0];
|
|
|
|
int idx = 0;
|
|
|
|
for( auto& v : f0 )
|
|
|
|
{
|
|
|
|
const auto name = GetFrameSetName( *v );
|
|
|
|
ImGui::PushID( -1 - idx );
|
|
|
|
ImGui::RadioButton( name, &m_compare.selMatch[0], idx++ );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%s)", RealToString( v->frames.size() ) );
|
|
|
|
ImGui::PopID();
|
|
|
|
}
|
|
|
|
ImGui::NextColumn();
|
|
|
|
|
|
|
|
const auto prev1 = m_compare.selMatch[1];
|
|
|
|
idx = 0;
|
|
|
|
for( auto& v : f1 )
|
|
|
|
{
|
|
|
|
const auto name = GetFrameSetName( *v, *m_compare.second );
|
|
|
|
ImGui::PushID( idx );
|
|
|
|
ImGui::RadioButton( name, &m_compare.selMatch[1], idx++ );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextDisabled( "(%s)", RealToString( v->frames.size() ) );
|
|
|
|
ImGui::PopID();
|
|
|
|
}
|
|
|
|
ImGui::NextColumn();
|
|
|
|
ImGui::EndColumns();
|
|
|
|
ImGui::TreePop();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( prev0 != m_compare.selMatch[0] || prev1 != m_compare.selMatch[1] )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
m_compare.ResetSelection();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.link )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
auto string0 = GetFrameSetName( *f0[m_compare.selMatch[0]] );
|
|
|
|
auto string1 = GetFrameSetName( *f1[m_compare.selMatch[1]], *m_compare.second );
|
|
|
|
|
|
|
|
if( strcmp( string0, string1 ) != 0 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
idx = 0;
|
|
|
|
if( prev0 != m_compare.selMatch[0] )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
for( auto& v : f1 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
auto string = GetFrameSetName( *v, *m_compare.second );
|
|
|
|
if( strcmp( string0, string ) == 0 )
|
|
|
|
{
|
|
|
|
m_compare.selMatch[1] = idx;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
idx++;
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
2022-12-23 15:54:07 +00:00
|
|
|
else
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
assert( prev1 != m_compare.selMatch[1] );
|
|
|
|
for( auto& v : f0 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
auto string = GetFrameSetName( *v );
|
|
|
|
if( strcmp( string1, string ) == 0 )
|
|
|
|
{
|
|
|
|
m_compare.selMatch[0] = idx;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
idx++;
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::Separator();
|
|
|
|
if( ImGui::TreeNodeEx( "Histogram", ImGuiTreeNodeFlags_DefaultOpen ) )
|
|
|
|
{
|
|
|
|
const auto ty = ImGui::GetTextLineHeight();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
int64_t tmin, tmax;
|
|
|
|
size_t size0, size1;
|
|
|
|
int64_t total0, total1;
|
|
|
|
double sumSq0, sumSq1;
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.compareMode == 0 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
auto& zoneData0 = m_worker.GetZonesForSourceLocation( m_compare.match[0][m_compare.selMatch[0]] );
|
|
|
|
auto& zoneData1 = m_compare.second->GetZonesForSourceLocation( m_compare.match[1][m_compare.selMatch[1]] );
|
|
|
|
auto& zones0 = zoneData0.zones;
|
|
|
|
auto& zones1 = zoneData1.zones;
|
|
|
|
zones0.ensure_sorted();
|
|
|
|
zones1.ensure_sorted();
|
|
|
|
|
|
|
|
tmin = std::min( zoneData0.min, zoneData1.min );
|
|
|
|
tmax = std::max( zoneData0.max, zoneData1.max );
|
|
|
|
|
|
|
|
size0 = zones0.size();
|
|
|
|
size1 = zones1.size();
|
|
|
|
total0 = zoneData0.total;
|
|
|
|
total1 = zoneData1.total;
|
|
|
|
sumSq0 = zoneData0.sumSq;
|
|
|
|
sumSq1 = zoneData1.sumSq;
|
|
|
|
|
|
|
|
const size_t zsz[2] = { size0, size1 };
|
|
|
|
for( int k=0; k<2; k++ )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.sortedNum[k] != zsz[k] )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
auto& zones = k == 0 ? zones0 : zones1;
|
|
|
|
auto& vec = m_compare.sorted[k];
|
|
|
|
vec.reserve( zsz[k] );
|
|
|
|
int64_t total = m_compare.total[k];
|
|
|
|
size_t i;
|
|
|
|
for( i=m_compare.sortedNum[k]; i<zsz[k]; i++ )
|
|
|
|
{
|
|
|
|
auto& zone = *zones[i].Zone();
|
|
|
|
const auto t = zone.End() - zone.Start();
|
|
|
|
vec.emplace_back( t );
|
|
|
|
total += t;
|
|
|
|
}
|
|
|
|
auto mid = vec.begin() + m_compare.sortedNum[k];
|
|
|
|
pdqsort_branchless( mid, vec.end() );
|
|
|
|
std::inplace_merge( vec.begin(), mid, vec.end() );
|
|
|
|
|
|
|
|
m_compare.average[k] = float( total ) / i;
|
|
|
|
m_compare.median[k] = vec[i/2];
|
|
|
|
m_compare.total[k] = total;
|
|
|
|
m_compare.sortedNum[k] = i;
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-12-23 15:54:07 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
assert( m_compare.compareMode == 1 );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto& f0 = m_worker.GetFrames()[m_compare.selMatch[0]];
|
|
|
|
const auto& f1 = m_compare.second->GetFrames()[m_compare.selMatch[1]];
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
tmin = std::min( f0->min, f1->min );
|
|
|
|
tmax = std::max( f0->max, f1->max );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
size0 = f0->frames.size();
|
|
|
|
size1 = f1->frames.size();
|
|
|
|
total0 = f0->total;
|
|
|
|
total1 = f1->total;
|
|
|
|
sumSq0 = f0->sumSq;
|
|
|
|
sumSq1 = f1->sumSq;
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const size_t zsz[2] = { size0, size1 };
|
|
|
|
for( int k=0; k<2; k++ )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.sortedNum[k] != zsz[k] )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
auto& frameSet = k == 0 ? f0 : f1;
|
|
|
|
auto worker = k == 0 ? &m_worker : m_compare.second.get();
|
|
|
|
auto& vec = m_compare.sorted[k];
|
|
|
|
vec.reserve( zsz[k] );
|
|
|
|
int64_t total = m_compare.total[k];
|
|
|
|
size_t i;
|
|
|
|
for( i=m_compare.sortedNum[k]; i<zsz[k]; i++ )
|
|
|
|
{
|
|
|
|
if( worker->GetFrameEnd( *frameSet, i ) == worker->GetLastTime() ) break;
|
|
|
|
const auto t = worker->GetFrameTime( *frameSet, i );
|
|
|
|
vec.emplace_back( t );
|
|
|
|
total += t;
|
|
|
|
}
|
|
|
|
auto mid = vec.begin() + m_compare.sortedNum[k];
|
|
|
|
pdqsort_branchless( mid, vec.end() );
|
|
|
|
std::inplace_merge( vec.begin(), mid, vec.end() );
|
|
|
|
|
|
|
|
m_compare.average[k] = float( total ) / i;
|
|
|
|
m_compare.median[k] = vec[i/2];
|
|
|
|
m_compare.total[k] = total;
|
|
|
|
m_compare.sortedNum[k] = i;
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( tmin != std::numeric_limits<int64_t>::max() )
|
|
|
|
{
|
|
|
|
TextDisabledUnformatted( "Minimum values in bin:" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::SetNextItemWidth( ImGui::CalcTextSize( "123456890123456" ).x );
|
|
|
|
ImGui::PushStyleVar( ImGuiStyleVar_FramePadding, ImVec2( 1, 1 ) );
|
|
|
|
ImGui::InputInt( "##minBinVal", &m_compare.minBinVal );
|
|
|
|
if( m_compare.minBinVal < 1 ) m_compare.minBinVal = 1;
|
|
|
|
ImGui::SameLine();
|
|
|
|
if( ImGui::Button( "Reset" ) ) m_compare.minBinVal = 1;
|
|
|
|
ImGui::PopStyleVar();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
SmallCheckbox( "Log values", &m_compare.logVal );
|
|
|
|
ImGui::SameLine();
|
|
|
|
SmallCheckbox( "Log time", &m_compare.logTime );
|
|
|
|
ImGui::SameLine();
|
|
|
|
SmallCheckbox( "Cumulate time", &m_compare.cumulateTime );
|
|
|
|
ImGui::SameLine();
|
|
|
|
DrawHelpMarker( "Show total time taken by calls in each bin instead of call counts." );
|
|
|
|
ImGui::SameLine();
|
|
|
|
SmallCheckbox( "Normalize values", &m_compare.normalize );
|
|
|
|
ImGui::SameLine();
|
|
|
|
DrawHelpMarker( "Normalization will fudge reported data values!" );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto cumulateTime = m_compare.cumulateTime;
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( tmax - tmin > 0 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto w = ImGui::GetContentRegionAvail().x;
|
|
|
|
|
|
|
|
const auto numBins = int64_t( w - 4 );
|
|
|
|
if( numBins > 1 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
if( numBins > m_compare.numBins )
|
|
|
|
{
|
|
|
|
m_compare.numBins = numBins;
|
|
|
|
m_compare.bins = std::make_unique<CompVal[]>( numBins );
|
|
|
|
m_compare.binTime = std::make_unique<CompVal[]>( numBins );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto& bins = m_compare.bins;
|
|
|
|
const auto& binTime = m_compare.binTime;
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
memset( bins.get(), 0, sizeof( CompVal ) * numBins );
|
|
|
|
memset( binTime.get(), 0, sizeof( CompVal ) * numBins );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
double adj0 = 1;
|
|
|
|
double adj1 = 1;
|
|
|
|
if( m_compare.normalize )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
if( size0 > size1 )
|
|
|
|
{
|
|
|
|
adj1 = double( size0 ) / size1;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
adj0 = double( size1 ) / size0;
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
2022-12-23 15:54:07 +00:00
|
|
|
|
|
|
|
const auto& sorted = m_compare.sorted;
|
|
|
|
auto sBegin0 = sorted[0].begin();
|
|
|
|
auto sBegin1 = sorted[1].begin();
|
|
|
|
auto sEnd0 = sorted[0].end();
|
|
|
|
auto sEnd1 = sorted[1].end();
|
|
|
|
|
|
|
|
if( m_compare.minBinVal > 1 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.logTime )
|
|
|
|
{
|
|
|
|
const auto tMinLog = log10( tmin );
|
|
|
|
const auto zmax = ( log10( tmax ) - tMinLog ) / numBins;
|
|
|
|
int64_t i;
|
|
|
|
for( i=0; i<numBins; i++ )
|
|
|
|
{
|
|
|
|
const auto nextBinVal = int64_t( pow( 10.0, tMinLog + ( i+1 ) * zmax ) );
|
|
|
|
auto nit0 = std::lower_bound( sBegin0, sEnd0, nextBinVal );
|
|
|
|
auto nit1 = std::lower_bound( sBegin1, sEnd1, nextBinVal );
|
|
|
|
const auto distance0 = std::distance( sBegin0, nit0 );
|
|
|
|
const auto distance1 = std::distance( sBegin1, nit1 );
|
|
|
|
if( distance0 >= m_compare.minBinVal || distance1 >= m_compare.minBinVal ) break;
|
|
|
|
sBegin0 = nit0;
|
|
|
|
sBegin1 = nit1;
|
|
|
|
}
|
|
|
|
for( int64_t j=numBins-1; j>i; j-- )
|
|
|
|
{
|
|
|
|
const auto nextBinVal = int64_t( pow( 10.0, tMinLog + ( j-1 ) * zmax ) );
|
|
|
|
auto nit0 = std::lower_bound( sBegin0, sEnd0, nextBinVal );
|
|
|
|
auto nit1 = std::lower_bound( sBegin1, sEnd1, nextBinVal );
|
|
|
|
const auto distance0 = std::distance( nit0, sEnd0 );
|
|
|
|
const auto distance1 = std::distance( nit1, sEnd1 );
|
|
|
|
if( distance0 >= m_compare.minBinVal || distance1 >= m_compare.minBinVal ) break;
|
|
|
|
sEnd0 = nit0;
|
|
|
|
sEnd1 = nit1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const auto zmax = tmax - tmin;
|
|
|
|
int64_t i;
|
|
|
|
for( i=0; i<numBins; i++ )
|
|
|
|
{
|
|
|
|
const auto nextBinVal = tmin + ( i+1 ) * zmax / numBins;
|
|
|
|
auto nit0 = std::lower_bound( sBegin0, sEnd0, nextBinVal );
|
|
|
|
auto nit1 = std::lower_bound( sBegin1, sEnd1, nextBinVal );
|
|
|
|
const auto distance0 = std::distance( sBegin0, nit0 );
|
|
|
|
const auto distance1 = std::distance( sBegin1, nit1 );
|
|
|
|
if( distance0 >= m_compare.minBinVal || distance1 >= m_compare.minBinVal ) break;
|
|
|
|
sBegin0 = nit0;
|
|
|
|
sBegin1 = nit1;
|
|
|
|
}
|
|
|
|
for( int64_t j=numBins-1; j>i; j-- )
|
|
|
|
{
|
|
|
|
const auto nextBinVal = tmin + ( j-1 ) * zmax / numBins;
|
|
|
|
auto nit0 = std::lower_bound( sBegin0, sEnd0, nextBinVal );
|
|
|
|
auto nit1 = std::lower_bound( sBegin1, sEnd1, nextBinVal );
|
|
|
|
const auto distance0 = std::distance( nit0, sEnd0 );
|
|
|
|
const auto distance1 = std::distance( nit1, sEnd1 );
|
|
|
|
if( distance0 >= m_compare.minBinVal || distance1 >= m_compare.minBinVal ) break;
|
|
|
|
sEnd0 = nit0;
|
|
|
|
sEnd1 = nit1;
|
|
|
|
}
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
tmin = std::min( *sBegin0, *sBegin1 );
|
|
|
|
tmax = std::max( *(sEnd0-1), *(sEnd1-1) );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
auto zit0 = sBegin0;
|
|
|
|
auto zit1 = sBegin1;
|
2022-07-02 11:48:54 +00:00
|
|
|
if( m_compare.logTime )
|
|
|
|
{
|
|
|
|
const auto tMinLog = log10( tmin );
|
|
|
|
const auto zmax = ( log10( tmax ) - tMinLog ) / numBins;
|
2022-12-23 15:54:07 +00:00
|
|
|
for( int64_t i=0; i<numBins; i++ )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
|
|
|
const auto nextBinVal = int64_t( pow( 10.0, tMinLog + ( i+1 ) * zmax ) );
|
2022-12-23 15:54:07 +00:00
|
|
|
auto nit0 = std::lower_bound( zit0, sEnd0, nextBinVal );
|
|
|
|
auto nit1 = std::lower_bound( zit1, sEnd1, nextBinVal );
|
|
|
|
bins[i].v0 += adj0 * std::distance( zit0, nit0 );
|
|
|
|
bins[i].v1 += adj1 * std::distance( zit1, nit1 );
|
|
|
|
binTime[i].v0 += adj0 * std::accumulate( zit0, nit0, int64_t( 0 ) );
|
|
|
|
binTime[i].v1 += adj1 * std::accumulate( zit1, nit1, int64_t( 0 ) );
|
|
|
|
zit0 = nit0;
|
|
|
|
zit1 = nit1;
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const auto zmax = tmax - tmin;
|
2022-12-23 15:54:07 +00:00
|
|
|
for( int64_t i=0; i<numBins; i++ )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
|
|
|
const auto nextBinVal = tmin + ( i+1 ) * zmax / numBins;
|
2022-12-23 15:54:07 +00:00
|
|
|
auto nit0 = std::lower_bound( zit0, sEnd0, nextBinVal );
|
|
|
|
auto nit1 = std::lower_bound( zit1, sEnd1, nextBinVal );
|
|
|
|
bins[i].v0 += adj0 * std::distance( zit0, nit0 );
|
|
|
|
bins[i].v1 += adj1 * std::distance( zit1, nit1 );
|
|
|
|
binTime[i].v0 += adj0 * std::accumulate( zit0, nit0, int64_t( 0 ) );
|
|
|
|
binTime[i].v1 += adj1 * std::accumulate( zit1, nit1, int64_t( 0 ) );
|
|
|
|
zit0 = nit0;
|
|
|
|
zit1 = nit1;
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
double maxVal;
|
|
|
|
if( cumulateTime )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
maxVal = std::max( binTime[0].v0, binTime[0].v1 );
|
|
|
|
for( int i=1; i<numBins; i++ )
|
|
|
|
{
|
|
|
|
maxVal = std::max( { maxVal, binTime[i].v0, binTime[i].v1 } );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
2022-12-23 15:54:07 +00:00
|
|
|
else
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
maxVal = std::max( bins[0].v0, bins[0].v1 );
|
|
|
|
for( int i=1; i<numBins; i++ )
|
|
|
|
{
|
|
|
|
maxVal = std::max( { maxVal, bins[i].v0, bins[i].v1 } );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0xDD/511.f, 0x22/511.f, 1.f ), ICON_FA_LEMON );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextFocused( "Total time (this):", TimeToString( total0 * adj0 ) );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Spacing();
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0x22/511.f, 0x22/511.f, 1.f ), ICON_FA_GEM );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextFocused( "Total time (ext.):", TimeToString( total1 * adj1 ) );
|
|
|
|
TextFocused( "Savings:", TimeToString( total1 * adj1 - total0 * adj0 ) );
|
|
|
|
ImGui::SameLine();
|
|
|
|
char buf[64];
|
|
|
|
PrintStringPercent( buf, ( total0 * adj0 ) / ( total1 * adj1 ) * 100 );
|
|
|
|
TextDisabledUnformatted( buf );
|
|
|
|
TextFocused( "Max counts:", cumulateTime ? TimeToString( maxVal ) : RealToString( floor( maxVal ) ) );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0xDD/511.f, 0x22/511.f, 1.f ), ICON_FA_LEMON );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextFocused( "Mean time (this):", TimeToString( m_compare.average[0] ) );
|
2022-07-02 11:48:54 +00:00
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Spacing();
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0xDD/511.f, 0x22/511.f, 1.f ), ICON_FA_LEMON );
|
|
|
|
ImGui::SameLine();
|
2022-12-23 15:54:07 +00:00
|
|
|
TextFocused( "Median time (this):", TimeToString( m_compare.median[0] ) );
|
|
|
|
if( sorted[0].size() > 1 )
|
|
|
|
{
|
|
|
|
const auto sz = sorted[0].size();
|
|
|
|
const auto avg = m_compare.average[0];
|
|
|
|
const auto ss = sumSq0 - 2. * total0 * avg + avg * avg * sz;
|
|
|
|
const auto sd = sqrt( ss / ( sz - 1 ) );
|
|
|
|
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Spacing();
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0xDD/511.f, 0x22/511.f, 1.f ), ICON_FA_LEMON );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextFocused( "\xcf\x83 (this):", TimeToString( sd ) );
|
|
|
|
TooltipIfHovered( "Standard deviation" );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0x22/511.f, 0x22/511.f, 1.f ), ICON_FA_GEM );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextFocused( "Mean time (ext.):", TimeToString( m_compare.average[1] ) );
|
2022-07-02 11:48:54 +00:00
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Spacing();
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0x22/511.f, 0x22/511.f, 1.f ), ICON_FA_GEM );
|
|
|
|
ImGui::SameLine();
|
2022-12-23 15:54:07 +00:00
|
|
|
TextFocused( "Median time (ext.):", TimeToString( m_compare.median[1] ) );
|
|
|
|
if( sorted[1].size() > 1 )
|
|
|
|
{
|
|
|
|
const auto sz = sorted[1].size();
|
|
|
|
const auto avg = m_compare.average[1];
|
|
|
|
const auto ss = sumSq1 - 2. * total1 * avg + avg * avg * sz;
|
|
|
|
const auto sd = sqrt( ss / ( sz - 1 ) );
|
|
|
|
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Spacing();
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0x22/511.f, 0x22/511.f, 1.f ), ICON_FA_GEM );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextFocused( "\xcf\x83 (ext.):", TimeToString( sd ) );
|
|
|
|
TooltipIfHovered( "Standard deviation" );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::PushStyleColor( ImGuiCol_Text, ImVec4( 0xDD/511.f, 0xDD/511.f, 0x22/511.f, 1.f ) );
|
|
|
|
ImGui::PushStyleColor( ImGuiCol_Button, ImVec4( 0xDD/255.f, 0xDD/255.f, 0x22/255.f, 1.f ) );
|
|
|
|
ImGui::PushStyleColor( ImGuiCol_ButtonHovered, ImVec4( 0xDD/255.f, 0xDD/255.f, 0x22/255.f, 1.f ) );
|
|
|
|
ImGui::PushStyleColor( ImGuiCol_ButtonActive, ImVec4( 0xDD/255.f, 0xDD/255.f, 0x22/255.f, 1.f ) );
|
|
|
|
ImGui::Button( ICON_FA_LEMON );
|
|
|
|
ImGui::PopStyleColor( 4 );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextUnformatted( "This trace" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Spacing();
|
|
|
|
ImGui::SameLine();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::PushStyleColor( ImGuiCol_Text, ImVec4( 0xDD/511.f, 0x22/511.f, 0x22/511.f, 1.f ) );
|
|
|
|
ImGui::PushStyleColor( ImGuiCol_Button, ImVec4( 0xDD/255.f, 0x22/255.f, 0x22/255.f, 1.f ) );
|
|
|
|
ImGui::PushStyleColor( ImGuiCol_ButtonHovered, ImVec4( 0xDD/255.f, 0x22/255.f, 0x22/255.f, 1.f ) );
|
|
|
|
ImGui::PushStyleColor( ImGuiCol_ButtonActive, ImVec4( 0xDD/255.f, 0x22/255.f, 0x22/255.f, 1.f ) );
|
|
|
|
ImGui::Button( ICON_FA_GEM );
|
|
|
|
ImGui::PopStyleColor( 4 );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextUnformatted( "External trace" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Spacing();
|
|
|
|
ImGui::SameLine();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::ColorButton( "c3", ImVec4( 0x44/255.f, 0xBB/255.f, 0xBB/255.f, 1.f ), ImGuiColorEditFlags_NoTooltip | ImGuiColorEditFlags_NoDragDrop );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::TextUnformatted( "Overlap" );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto Height = 200 * scale;
|
|
|
|
const auto wpos = ImGui::GetCursorScreenPos();
|
|
|
|
const auto dpos = wpos + ImVec2( 0.5f, 0.5f );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::InvisibleButton( "##histogram", ImVec2( w, Height + round( ty * 2.5 ) ) );
|
|
|
|
const bool hover = ImGui::IsItemHovered();
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
auto draw = ImGui::GetWindowDrawList();
|
|
|
|
draw->AddRectFilled( wpos, wpos + ImVec2( w, Height ), 0x22FFFFFF );
|
|
|
|
draw->AddRect( wpos, wpos + ImVec2( w, Height ), 0x88FFFFFF );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( m_compare.logVal )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto hAdj = double( Height - 4 ) / log10( maxVal + 1 );
|
|
|
|
for( int i=0; i<numBins; i++ )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto val0 = cumulateTime ? binTime[i].v0 : bins[i].v0;
|
|
|
|
const auto val1 = cumulateTime ? binTime[i].v1 : bins[i].v1;
|
|
|
|
if( val0 > 0 || val1 > 0 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto val = std::min( val0, val1 );
|
|
|
|
if( val > 0 )
|
|
|
|
{
|
|
|
|
DrawLine( draw, dpos + ImVec2( 2+i, Height-3 ), dpos + ImVec2( 2+i, Height-3 - log10( val + 1 ) * hAdj ), 0xFFBBBB44 );
|
|
|
|
}
|
|
|
|
if( val1 == val )
|
|
|
|
{
|
|
|
|
DrawLine( draw, dpos + ImVec2( 2+i, Height-3 - log10( val + 1 ) * hAdj ), dpos + ImVec2( 2+i, Height-3 - log10( val0 + 1 ) * hAdj ), 0xFF22DDDD );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
DrawLine( draw, dpos + ImVec2( 2+i, Height-3 - log10( val + 1 ) * hAdj ), dpos + ImVec2( 2+i, Height-3 - log10( val1 + 1 ) * hAdj ), 0xFF2222DD );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-12-23 15:54:07 +00:00
|
|
|
else
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto hAdj = double( Height - 4 ) / maxVal;
|
|
|
|
for( int i=0; i<numBins; i++ )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto val0 = cumulateTime ? binTime[i].v0 : bins[i].v0;
|
|
|
|
const auto val1 = cumulateTime ? binTime[i].v1 : bins[i].v1;
|
|
|
|
if( val0 > 0 || val1 > 0 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto val = std::min( val0, val1 );
|
|
|
|
if( val > 0 )
|
|
|
|
{
|
|
|
|
DrawLine( draw, dpos + ImVec2( 2+i, Height-3 ), dpos + ImVec2( 2+i, Height-3 - val * hAdj ), 0xFFBBBB44 );
|
|
|
|
}
|
|
|
|
if( val1 == val )
|
|
|
|
{
|
|
|
|
DrawLine( draw, dpos + ImVec2( 2+i, Height-3 - val * hAdj ), dpos + ImVec2( 2+i, Height-3 - val0 * hAdj ), 0xFF22DDDD );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
DrawLine( draw, dpos + ImVec2( 2+i, Height-3 - val * hAdj ), dpos + ImVec2( 2+i, Height-3 - val1 * hAdj ), 0xFF2222DD );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto xoff = 2;
|
|
|
|
const auto yoff = Height + 1;
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
DrawHistogramMinMaxLabel( draw, tmin, tmax, wpos + ImVec2( 0, yoff ), w, ty );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto ty05 = round( ty * 0.5f );
|
|
|
|
const auto ty025 = round( ty * 0.25f );
|
|
|
|
if( m_compare.logTime )
|
|
|
|
{
|
|
|
|
const auto ltmin = log10( tmin );
|
|
|
|
const auto ltmax = log10( tmax );
|
|
|
|
const auto start = int( floor( ltmin ) );
|
|
|
|
const auto end = int( ceil( ltmax ) );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto range = ltmax - ltmin;
|
|
|
|
const auto step = w / range;
|
|
|
|
auto offset = start - ltmin;
|
|
|
|
int tw = 0;
|
|
|
|
int tx = 0;
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
auto tt = int64_t( pow( 10, start ) );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
static const double logticks[] = { log10( 2 ), log10( 3 ), log10( 4 ), log10( 5 ), log10( 6 ), log10( 7 ), log10( 8 ), log10( 9 ) };
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
for( int i=start; i<=end; i++ )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto x = ( i - start + offset ) * step;
|
|
|
|
|
|
|
|
if( x >= 0 )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
DrawLine( draw, dpos + ImVec2( x, yoff ), dpos + ImVec2( x, yoff + ty05 ), 0x66FFFFFF );
|
|
|
|
if( tw == 0 || x > tx + tw + ty * 1.1 )
|
|
|
|
{
|
|
|
|
tx = x;
|
|
|
|
auto txt = TimeToString( tt );
|
|
|
|
draw->AddText( wpos + ImVec2( x, yoff + ty05 ), 0x66FFFFFF, txt );
|
|
|
|
tw = ImGui::CalcTextSize( txt ).x;
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
for( int j=0; j<8; j++ )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto xoff = x + logticks[j] * step;
|
|
|
|
if( xoff >= 0 )
|
|
|
|
{
|
|
|
|
DrawLine( draw, dpos + ImVec2( xoff, yoff ), dpos + ImVec2( xoff, yoff + ty025 ), 0x66FFFFFF );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
tt *= 10;
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
2022-12-23 15:54:07 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
const auto pxns = numBins / double( tmax - tmin );
|
|
|
|
const auto nspx = 1.0 / pxns;
|
|
|
|
const auto scale = std::max<float>( 0.0f, round( log10( nspx ) + 2 ) );
|
|
|
|
const auto step = pow( 10, scale );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto dx = step * pxns;
|
|
|
|
double x = 0;
|
|
|
|
int tw = 0;
|
|
|
|
int tx = 0;
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto sstep = step / 10.0;
|
|
|
|
const auto sdx = dx / 10.0;
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
static const double linelen[] = { 0.5, 0.25, 0.25, 0.25, 0.25, 0.375, 0.25, 0.25, 0.25, 0.25 };
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
int64_t tt = int64_t( ceil( tmin / sstep ) * sstep );
|
|
|
|
const auto diff = tmin / sstep - int64_t( tmin / sstep );
|
|
|
|
const auto xo = ( diff == 0 ? 0 : ( ( 1 - diff ) * sstep * pxns ) ) + xoff;
|
|
|
|
int iter = int( ceil( ( tmin - int64_t( tmin / step ) * step ) / sstep ) );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
while( x < numBins )
|
2022-07-02 11:48:54 +00:00
|
|
|
{
|
2022-12-23 15:54:07 +00:00
|
|
|
DrawLine( draw, dpos + ImVec2( xo + x, yoff ), dpos + ImVec2( xo + x, yoff + round( ty * linelen[iter] ) ), 0x66FFFFFF );
|
|
|
|
if( iter == 0 && ( tw == 0 || x > tx + tw + ty * 1.1 ) )
|
|
|
|
{
|
|
|
|
tx = x;
|
|
|
|
auto txt = TimeToString( tt );
|
|
|
|
draw->AddText( wpos + ImVec2( xo + x, yoff + ty05 ), 0x66FFFFFF, txt );
|
|
|
|
tw = ImGui::CalcTextSize( txt ).x;
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
iter = ( iter + 1 ) % 10;
|
|
|
|
x += sdx;
|
|
|
|
tt += sstep;
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
if( hover && ImGui::IsMouseHoveringRect( wpos + ImVec2( 2, 2 ), wpos + ImVec2( w-2, Height + round( ty * 1.5 ) ) ) )
|
|
|
|
{
|
|
|
|
const auto ltmin = log10( tmin );
|
|
|
|
const auto ltmax = log10( tmax );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
auto& io = ImGui::GetIO();
|
|
|
|
DrawLine( draw, ImVec2( io.MousePos.x + 0.5f, dpos.y ), ImVec2( io.MousePos.x + 0.5f, dpos.y+Height-2 ), 0x33FFFFFF );
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
const auto bin = int64_t( io.MousePos.x - wpos.x - 2 );
|
|
|
|
int64_t t0, t1;
|
|
|
|
if( m_compare.logTime )
|
|
|
|
{
|
|
|
|
t0 = int64_t( pow( 10, ltmin + double( bin ) / numBins * ( ltmax - ltmin ) ) );
|
|
|
|
t1 = int64_t( pow( 10, ltmin + double( bin+1 ) / numBins * ( ltmax - ltmin ) ) );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
t0 = int64_t( tmin + double( bin ) / numBins * ( tmax - tmin ) );
|
|
|
|
t1 = int64_t( tmin + double( bin+1 ) / numBins * ( tmax - tmin ) );
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
int64_t tBefore[2] = { 0, 0 };
|
|
|
|
for( int i=0; i<bin; i++ )
|
|
|
|
{
|
|
|
|
tBefore[0] += binTime[i].v0;
|
|
|
|
tBefore[1] += binTime[i].v1;
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
int64_t tAfter[2] = { 0, 0 };
|
|
|
|
for( int i=bin+1; i<numBins; i++ )
|
|
|
|
{
|
|
|
|
tAfter[0] += binTime[i].v0;
|
|
|
|
tAfter[1] += binTime[i].v1;
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::BeginTooltip();
|
|
|
|
TextDisabledUnformatted( "Time range:" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Text( "%s - %s", TimeToString( t0 ), TimeToString( t1 ) );
|
|
|
|
TextDisabledUnformatted( "Count:" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Text( "%s / %s", RealToString( floor( bins[bin].v0 ) ), RealToString( floor( bins[bin].v1 ) ) );
|
|
|
|
TextDisabledUnformatted( "Time spent in bin:" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Text( "%s / %s", TimeToString( binTime[bin].v0 ), TimeToString( binTime[bin].v1 ) );
|
|
|
|
TextDisabledUnformatted( "Time spent in the left bins:" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Text( "%s / %s", TimeToString( tBefore[0] ), TimeToString( tBefore[1] ) );
|
|
|
|
TextDisabledUnformatted( "Time spent in the right bins:" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
ImGui::Text( "%s / %s", TimeToString( tAfter[0] ), TimeToString( tAfter[1] ) );
|
|
|
|
TextDisabledUnformatted( "(Data is displayed as:" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0xDD/511.f, 0x22/511.f, 1.f ), ICON_FA_LEMON );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextDisabledUnformatted( "[this trace] /" );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextColoredUnformatted( ImVec4( 0xDD/511.f, 0x22/511.f, 0x22/511.f, 1.f ), ICON_FA_GEM );
|
|
|
|
ImGui::SameLine();
|
|
|
|
TextDisabledUnformatted( "[external trace])" );
|
|
|
|
ImGui::EndTooltip();
|
|
|
|
}
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2022-12-23 15:54:07 +00:00
|
|
|
ImGui::TreePop();
|
2022-07-02 11:48:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ImGui::EndChild();
|
|
|
|
#endif
|
|
|
|
ImGui::End();
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|