mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-07-18 03:09:18 +02:00
459 lines
17 KiB
C++
459 lines
17 KiB
C++
/*
|
|
This Source Code Form is subject to the
|
|
terms of the Mozilla Public License, v.
|
|
2.0. If a copy of the MPL was not
|
|
distributed with this file, You can
|
|
obtain one at
|
|
http://mozilla.org/MPL/2.0/.
|
|
*/
|
|
|
|
#include "stdafx.h"
|
|
#include "scene/eu7/eu7_pack_mesh_loader.h"
|
|
#include "scene/eu7/eu7_pack_bench.h"
|
|
|
|
#include "utilities/Logs.h"
|
|
#include "utilities/utilities.h"
|
|
|
|
#include <algorithm>
|
|
#include <iomanip>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
|
|
namespace scene::eu7 {
|
|
namespace {
|
|
|
|
Eu7PackBench g_pack_bench;
|
|
Eu7PackBench g_pack_bench_stream;
|
|
Eu7PackBench g_pack_bench_bootstrap;
|
|
bool g_stream_phase { false };
|
|
std::unordered_set<std::string> g_logged_texture_fails;
|
|
|
|
struct BenchLine {
|
|
std::string label;
|
|
double ms { 0.0 };
|
|
std::string detail;
|
|
};
|
|
|
|
[[nodiscard]] std::string
|
|
format_seconds( double const ms ) {
|
|
std::ostringstream out;
|
|
out << std::fixed << std::setprecision( 1 ) << ( ms / 1000.0 ) << 's';
|
|
return out.str();
|
|
}
|
|
|
|
[[nodiscard]] std::string
|
|
format_ms_per( double const ms, std::uint64_t const count ) {
|
|
if( count == 0 ) {
|
|
return "n/a";
|
|
}
|
|
std::ostringstream out;
|
|
out << std::fixed << std::setprecision( 2 ) << ( ms / static_cast<double>( count ) ) << " ms/item";
|
|
return out.str();
|
|
}
|
|
|
|
void
|
|
note_peak(
|
|
std::uint64_t Eu7PackBench::*const field,
|
|
std::size_t const size ) {
|
|
auto &total_peak { g_pack_bench.*field };
|
|
total_peak = std::max( total_peak, size );
|
|
if( g_stream_phase ) {
|
|
auto &stream_peak { g_pack_bench_stream.*field };
|
|
stream_peak = std::max( stream_peak, size );
|
|
}
|
|
}
|
|
|
|
void
|
|
add_bench_ms( double Eu7PackBench::*const field, double const delta ) {
|
|
g_pack_bench.*field += delta;
|
|
if( g_stream_phase ) {
|
|
g_pack_bench_stream.*field += delta;
|
|
}
|
|
}
|
|
|
|
void
|
|
log_pack_bench_impl( Eu7PackBench const &bench, char const *const title ) {
|
|
auto const total { bench.accounted_ms() };
|
|
|
|
if( total <= 0.0 && bench.main_drain_calls == 0 && bench.worker_sections_done == 0 ) {
|
|
return;
|
|
}
|
|
|
|
auto const main_apply_sum {
|
|
bench.main_load_eu7_pack_ms + bench.main_load_eu7_full_ms + bench.main_region_insert_ms };
|
|
auto const chunk_sum {
|
|
bench.main_chunk_cold_ms + bench.main_chunk_warm_tex_ms + bench.main_chunk_pointer_apply_ms };
|
|
|
|
std::vector<BenchLine> lines {
|
|
{ "worker read_pack", bench.worker_read_pack_ms,
|
|
"chunks=" + std::to_string( bench.worker_chunks_decoded ) +
|
|
" sections=" + std::to_string( bench.worker_sections_done ) +
|
|
" finalized=" + std::to_string( bench.sections_finalized ) +
|
|
" models=" + std::to_string( bench.worker_models_decoded ) +
|
|
" fail=" + std::to_string( bench.worker_failures ) },
|
|
{ "main read_pack", bench.main_read_pack_ms,
|
|
"models=" + std::to_string( bench.worker_models_decoded ) },
|
|
{ "main GetModel (cold)", bench.main_cold_getmodel_ms,
|
|
"calls=" + std::to_string( bench.main_cold_getmodel_calls ) + " " +
|
|
format_ms_per( bench.main_cold_getmodel_ms, bench.main_cold_getmodel_calls ) },
|
|
{ "main LoadEu7Pack", bench.main_load_eu7_pack_ms,
|
|
"loads=" + std::to_string( bench.main_pack_fast_loads ) + " " +
|
|
format_ms_per( bench.main_load_eu7_pack_ms, bench.main_pack_fast_loads ) },
|
|
{ "main LoadEu7 (full)", bench.main_load_eu7_full_ms,
|
|
"loads=" + std::to_string( bench.main_pack_full_loads ) + " " +
|
|
format_ms_per( bench.main_load_eu7_full_ms, bench.main_pack_full_loads ) },
|
|
{ "main Region::insert", bench.main_region_insert_ms,
|
|
"inserts=" + std::to_string( bench.main_region_inserts ) + " " +
|
|
format_ms_per( bench.main_region_insert_ms, bench.main_region_inserts ) },
|
|
{ "main apply (load+region)", main_apply_sum,
|
|
"instances=" + std::to_string( bench.main_instances_applied ) + " " +
|
|
format_ms_per( main_apply_sum, bench.main_instances_applied ) },
|
|
{ "chunk cold preload", bench.main_chunk_cold_ms,
|
|
"loads=" + std::to_string( bench.main_chunk_cold_loads ) + " " +
|
|
format_ms_per( bench.main_chunk_cold_ms, bench.main_chunk_cold_loads ) },
|
|
{ "chunk warm textures", bench.main_chunk_warm_tex_ms,
|
|
"fetches=" + std::to_string( bench.main_chunk_tex_fetches ) + " " +
|
|
format_ms_per( bench.main_chunk_warm_tex_ms, bench.main_chunk_tex_fetches ) },
|
|
{ "chunk pointer apply", bench.main_chunk_pointer_apply_ms,
|
|
"chunks=" + std::to_string( bench.main_chunks ) + " inst=" +
|
|
std::to_string( bench.main_chunk_instances ) + " " +
|
|
format_ms_per( bench.main_chunk_pointer_apply_ms, bench.main_chunk_instances ) },
|
|
{ "chunk wall (phases)", chunk_sum,
|
|
"chunks=" + std::to_string( bench.main_chunks ) + " slow8=" +
|
|
std::to_string( bench.chunk_slow_8ms ) + " slow16=" +
|
|
std::to_string( bench.chunk_slow_16ms ) },
|
|
};
|
|
|
|
std::sort(
|
|
lines.begin(),
|
|
lines.end(),
|
|
[]( BenchLine const &lhs, BenchLine const &rhs ) {
|
|
return lhs.ms > rhs.ms;
|
|
} );
|
|
|
|
WriteLog( std::string{ title } + " (accounted " + format_seconds( total ) + "):" );
|
|
for( auto const &line : lines ) {
|
|
if( line.ms <= 0.0 ) {
|
|
continue;
|
|
}
|
|
auto const pct {
|
|
total > 0.0 ?
|
|
( 100.0 * line.ms / total ) :
|
|
0.0 };
|
|
std::ostringstream row;
|
|
row << std::fixed << std::setprecision( 1 );
|
|
row << " " << line.label << ": " << format_seconds( line.ms );
|
|
if( total > 0.0 ) {
|
|
row << " (" << pct << "%)";
|
|
}
|
|
if( false == line.detail.empty() ) {
|
|
row << " " << line.detail;
|
|
}
|
|
WriteLog( row.str() );
|
|
}
|
|
|
|
WriteLog(
|
|
" drain: calls=" + std::to_string( bench.main_drain_calls ) +
|
|
" wait_cold_frames=" + std::to_string( bench.main_drain_wait_cold_mesh ) +
|
|
" wait_worker_frames=" + std::to_string( bench.main_drain_wait_worker ) +
|
|
" idle_frames=" + std::to_string( bench.main_drain_idle ) );
|
|
WriteLog(
|
|
" stream: reenqueue=" + std::to_string( bench.stream_reenqueue ) +
|
|
" lookahead=" + std::to_string( bench.stream_lookahead_enqueue ) +
|
|
" tex_fail=" + std::to_string( bench.main_texture_assign_fail ) +
|
|
" warm_miss=" + std::to_string( bench.main_texture_warm_miss ) );
|
|
WriteLog(
|
|
" diag drain: urg=" + std::to_string( bench.stream_drain_catchup_urgent ) +
|
|
" catchup=" + std::to_string( bench.stream_drain_catchup ) +
|
|
" gameplay=" + std::to_string( bench.stream_drain_gameplay ) +
|
|
" loader=" + std::to_string( bench.stream_drain_loader ) +
|
|
" preempt=" + std::to_string( bench.stream_preempt_pending ) +
|
|
" budget_stops=" + std::to_string( bench.drain_budget_stops ) );
|
|
WriteLog(
|
|
" diag chunk: urg=" + std::to_string( bench.stream_chunks_urgent ) +
|
|
" heavy=" + std::to_string( bench.stream_chunks_heavy ) +
|
|
" light=" + std::to_string( bench.stream_chunks_light ) +
|
|
" cold_trunc=" + std::to_string( bench.stream_cold_slice_truncated ) +
|
|
" inst_plan=" + std::to_string( bench.stream_inst_planned ) +
|
|
" inst_cold=" + std::to_string( bench.stream_inst_after_cold ) );
|
|
WriteLog(
|
|
" diag mesh: sess_hit=" + std::to_string( bench.stream_mesh_session_hit ) +
|
|
" glob_hit=" + std::to_string( bench.stream_mesh_global_hit ) +
|
|
" disk=" + std::to_string( bench.stream_mesh_disk_load ) +
|
|
" async_q=" + std::to_string( bench.stream_mesh_async_queued ) +
|
|
" async_r=" + std::to_string( bench.stream_mesh_async_ready ) +
|
|
" loader=" + std::to_string( bench.loader_thread_disk_loads ) +
|
|
" dequeue_near=" + std::to_string( bench.stream_dequeue_near ) +
|
|
" far=" + std::to_string( bench.stream_dequeue_far ) +
|
|
" cam=" + std::to_string( bench.stream_dequeue_camera ) +
|
|
" wait_near=" + std::to_string( bench.stream_dequeue_wait_near ) +
|
|
" block_far=" + std::to_string( bench.stream_jobs_blocked_far ) +
|
|
" block_ring_in=" + std::to_string( bench.stream_jobs_blocked_ring_inner ) +
|
|
" block_ring_out=" + std::to_string( bench.stream_jobs_blocked_ring_outer ) +
|
|
" defer_dist=" + std::to_string( bench.stream_worker_deferred_distant ) +
|
|
" stuck_skip=" + std::to_string( bench.stream_apply_stuck_skip ) +
|
|
" apply_defer=" + std::to_string( bench.stream_apply_deferred ) +
|
|
" defer_bypass=" + std::to_string( bench.stream_apply_defer_bypass ) +
|
|
" sparse_skip=" + std::to_string( bench.stream_sparse_apply_skip ) );
|
|
WriteLog(
|
|
" diag ready_tex_ms=" + std::to_string( static_cast<int>( bench.stream_prefetch_ready_tex_ms ) ) +
|
|
" ready_umes_ms=" + std::to_string( static_cast<int>( bench.stream_prefetch_ready_umes_ms ) ) +
|
|
" umes_loads=" + std::to_string( bench.stream_prefetch_ready_umes_loads ) +
|
|
" peak_pending=" + std::to_string( bench.peak_pending_total ) );
|
|
WriteLog(
|
|
" peaks: ready_q=" + std::to_string( bench.peak_ready_queue ) +
|
|
" in_flight=" + std::to_string( bench.peak_in_flight ) +
|
|
" cold_q=" + std::to_string( bench.peak_pending_cold_meshes ) );
|
|
if( bench.main_chunks > 0 ) {
|
|
WriteLog(
|
|
" chunk peaks: wall_ms=" + std::to_string( static_cast<int>( bench.peak_chunk_ms ) ) +
|
|
" inst=" + std::to_string( bench.peak_chunk_instances ) +
|
|
" cold=" + std::to_string( bench.peak_chunk_cold ) +
|
|
" last_ms=" + std::to_string( static_cast<int>( bench.last_chunk_ms ) ) +
|
|
" last_inst=" + std::to_string( bench.last_chunk_instances ) +
|
|
" budget_stops=" + std::to_string( bench.drain_budget_stops ) );
|
|
}
|
|
|
|
if( false == lines.empty() && lines.front().ms > 0.0 ) {
|
|
WriteLog( " >> bottleneck: " + lines.front().label );
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
double
|
|
Eu7PackBench::accounted_ms() const {
|
|
return (
|
|
worker_read_pack_ms +
|
|
main_read_pack_ms +
|
|
main_cold_getmodel_ms +
|
|
main_load_eu7_pack_ms +
|
|
main_load_eu7_full_ms +
|
|
main_region_insert_ms );
|
|
}
|
|
|
|
double
|
|
Eu7PackBench::chunk_accounted_ms() const {
|
|
return (
|
|
main_chunk_cold_ms +
|
|
main_chunk_warm_tex_ms +
|
|
main_chunk_pointer_apply_ms );
|
|
}
|
|
|
|
PackBenchTimer::PackBenchTimer( double Eu7PackBench::*const field )
|
|
: m_field { field }
|
|
, m_start { std::chrono::steady_clock::now() } {}
|
|
|
|
PackBenchTimer::~PackBenchTimer() {
|
|
auto const end { std::chrono::steady_clock::now() };
|
|
auto const delta {
|
|
std::chrono::duration<double, std::milli>( end - m_start ).count() };
|
|
g_pack_bench.*m_field += delta;
|
|
if( g_stream_phase ) {
|
|
g_pack_bench_stream.*m_field += delta;
|
|
}
|
|
}
|
|
|
|
Eu7PackBench &
|
|
pack_bench() {
|
|
return g_pack_bench;
|
|
}
|
|
|
|
Eu7PackBench &
|
|
pack_bench_stream() {
|
|
return g_pack_bench_stream;
|
|
}
|
|
|
|
Eu7PackBench const &
|
|
pack_bench_bootstrap() {
|
|
return g_pack_bench_bootstrap;
|
|
}
|
|
|
|
bool
|
|
pack_bench_stream_phase_active() {
|
|
return g_stream_phase;
|
|
}
|
|
|
|
void
|
|
reset_pack_bench() {
|
|
g_pack_bench = {};
|
|
g_pack_bench_stream = {};
|
|
g_pack_bench_bootstrap = {};
|
|
g_stream_phase = false;
|
|
g_logged_texture_fails.clear();
|
|
}
|
|
|
|
void
|
|
pack_bench_begin_stream_phase() {
|
|
g_pack_bench_bootstrap = g_pack_bench;
|
|
g_pack_bench_stream = {};
|
|
g_stream_phase = true;
|
|
}
|
|
|
|
void
|
|
pack_bench_note_ready_queue( std::size_t const size ) {
|
|
note_peak( &Eu7PackBench::peak_ready_queue, size );
|
|
}
|
|
|
|
void
|
|
pack_bench_note_in_flight( std::size_t const size ) {
|
|
note_peak( &Eu7PackBench::peak_in_flight, size );
|
|
}
|
|
|
|
void
|
|
pack_bench_note_pending_cold_meshes( std::size_t const size ) {
|
|
note_peak( &Eu7PackBench::peak_pending_cold_meshes, size );
|
|
}
|
|
|
|
void
|
|
pack_bench_note_pending_total( std::size_t const total ) {
|
|
note_peak( &Eu7PackBench::peak_pending_total, total );
|
|
}
|
|
|
|
void
|
|
pack_bench_inc( std::uint64_t Eu7PackBench::*const field, std::uint64_t const amount ) {
|
|
g_pack_bench.*field += amount;
|
|
if( g_stream_phase ) {
|
|
g_pack_bench_stream.*field += amount;
|
|
}
|
|
}
|
|
|
|
void
|
|
pack_bench_note_chunk(
|
|
double const wall_ms,
|
|
std::size_t const instances,
|
|
std::size_t const cold_meshes,
|
|
double const cold_ms,
|
|
double const warm_tex_ms,
|
|
double const pointer_apply_ms ) {
|
|
add_bench_ms( &Eu7PackBench::main_chunk_cold_ms, cold_ms );
|
|
add_bench_ms( &Eu7PackBench::main_chunk_warm_tex_ms, warm_tex_ms );
|
|
add_bench_ms( &Eu7PackBench::main_chunk_pointer_apply_ms, pointer_apply_ms );
|
|
pack_bench_inc( &Eu7PackBench::main_chunks );
|
|
pack_bench_inc( &Eu7PackBench::main_chunk_instances, instances );
|
|
pack_bench_inc( &Eu7PackBench::main_chunk_cold_loads, cold_meshes );
|
|
|
|
g_pack_bench.last_chunk_ms = wall_ms;
|
|
g_pack_bench.last_apply_ms = pointer_apply_ms;
|
|
g_pack_bench.last_chunk_instances = instances;
|
|
g_pack_bench.last_chunk_cold = cold_meshes;
|
|
if( wall_ms > g_pack_bench.peak_chunk_ms ) {
|
|
g_pack_bench.peak_chunk_ms = wall_ms;
|
|
g_pack_bench.peak_chunk_instances = instances;
|
|
g_pack_bench.peak_chunk_cold = cold_meshes;
|
|
}
|
|
if( wall_ms >= 8.0 ) {
|
|
pack_bench_inc( &Eu7PackBench::chunk_slow_8ms );
|
|
}
|
|
if( wall_ms >= 16.0 ) {
|
|
pack_bench_inc( &Eu7PackBench::chunk_slow_16ms );
|
|
}
|
|
|
|
if( false == g_stream_phase ) {
|
|
return;
|
|
}
|
|
|
|
auto &stream { g_pack_bench_stream };
|
|
stream.last_chunk_ms = wall_ms;
|
|
stream.last_apply_ms = pointer_apply_ms;
|
|
stream.last_chunk_instances = instances;
|
|
stream.last_chunk_cold = cold_meshes;
|
|
if( wall_ms > stream.peak_chunk_ms ) {
|
|
stream.peak_chunk_ms = wall_ms;
|
|
stream.peak_chunk_instances = instances;
|
|
stream.peak_chunk_cold = cold_meshes;
|
|
}
|
|
}
|
|
|
|
void
|
|
log_pack_texture_fail( std::string const &texture_path ) {
|
|
if( texture_path.empty() ) {
|
|
return;
|
|
}
|
|
|
|
auto key { texture_path };
|
|
replace_slashes( key );
|
|
key = ToLower( key );
|
|
if( false == g_logged_texture_fails.insert( key ).second ) {
|
|
return;
|
|
}
|
|
|
|
WriteLog( "EU7 PACK tex_fail: \"" + texture_path + "\"" );
|
|
}
|
|
|
|
void
|
|
log_pack_bench() {
|
|
if( g_pack_bench_bootstrap.worker_sections_done > 0
|
|
|| g_pack_bench_bootstrap.accounted_ms() > 0.0 ) {
|
|
log_pack_bench_impl( g_pack_bench_bootstrap, "EU7 PACK bench [bootstrap]" );
|
|
return;
|
|
}
|
|
log_pack_bench_impl( g_pack_bench, "EU7 PACK bench" );
|
|
}
|
|
|
|
void
|
|
log_pack_stream_bench() {
|
|
log_pack_bench_impl( g_pack_bench_stream, "EU7 PACK bench [stream]" );
|
|
}
|
|
|
|
void
|
|
flush_pack_stream_bench() {
|
|
if( false == g_stream_phase ) {
|
|
return;
|
|
}
|
|
if(
|
|
g_pack_bench_stream.sections_finalized == 0 &&
|
|
g_pack_bench_stream.main_drain_calls == 0 &&
|
|
g_pack_bench_stream.accounted_ms() <= 0.0 ) {
|
|
return;
|
|
}
|
|
log_pack_stream_bench();
|
|
}
|
|
|
|
void
|
|
log_pack_stream_status(
|
|
glm::dvec3 const &camera_position,
|
|
double const camera_speed_mps,
|
|
float const inner_ring_progress,
|
|
float const outer_ring_progress,
|
|
std::size_t const ready_queue,
|
|
std::size_t const in_flight,
|
|
std::size_t const pending_offset,
|
|
std::size_t const pending_total,
|
|
double const drain_budget_ms,
|
|
std::size_t const chunk_limit ) {
|
|
auto const &bench { g_pack_bench_stream };
|
|
WriteLog(
|
|
"EU7 PACK [live]: cam=" + std::to_string( camera_position.x ) + "," +
|
|
std::to_string( camera_position.z ) + " m/s=" + std::to_string( camera_speed_mps ) +
|
|
" ring4=" + std::to_string( static_cast<int>( inner_ring_progress * 100.f ) ) + "%" +
|
|
" ring11=" + std::to_string( static_cast<int>( outer_ring_progress * 100.f ) ) + "%" +
|
|
" ready=" + std::to_string( ready_queue ) +
|
|
" in_flight=" + std::to_string( in_flight ) +
|
|
" pending=" + std::to_string( pending_offset ) + "/" + std::to_string( pending_total ) +
|
|
" slice=" + std::to_string( chunk_limit ) +
|
|
" budget_ms=" + std::to_string( static_cast<int>( drain_budget_ms ) ) +
|
|
" applied=" + std::to_string( bench.main_instances_applied ) +
|
|
" tex_fail=" + std::to_string( bench.main_texture_assign_fail ) +
|
|
" warm_miss=" + std::to_string( bench.main_texture_warm_miss ) +
|
|
" chunks=" + std::to_string( bench.main_chunks ) +
|
|
" last_chunk_ms=" + std::to_string( static_cast<int>( bench.last_chunk_ms ) ) +
|
|
" peak_chunk_ms=" + std::to_string( static_cast<int>( bench.peak_chunk_ms ) ) +
|
|
" slow8=" + std::to_string( bench.chunk_slow_8ms ) +
|
|
" cold_ms=" + std::to_string( static_cast<int>( bench.main_chunk_cold_ms ) ) +
|
|
" warm_ms=" + std::to_string( static_cast<int>( bench.main_chunk_warm_tex_ms ) ) +
|
|
" apply_ms=" + std::to_string( static_cast<int>( bench.main_chunk_pointer_apply_ms ) ) +
|
|
" reenq=" + std::to_string( bench.stream_reenqueue ) +
|
|
" ahead=" + std::to_string( bench.stream_lookahead_enqueue ) +
|
|
" urg_chunks=" + std::to_string( bench.stream_chunks_urgent ) +
|
|
" cold_trunc=" + std::to_string( bench.stream_cold_slice_truncated ) +
|
|
" mesh_q=" + std::to_string( pack_mesh_loader_queue_depth() ) +
|
|
" mesh_r=" + std::to_string( pack_mesh_loader_ready_count() ) +
|
|
" mesh_d=" + std::to_string( bench.stream_mesh_async_drained ) +
|
|
" preempt=" + std::to_string( bench.stream_preempt_pending ) );
|
|
}
|
|
|
|
} // namespace scene::eu7
|