mirror of
https://github.com/MaSzyna-EU07/maszyna.git
synced 2026-11-21 23:44:58 +01:00
perf(debug): live heap blocks by size and the objects of the simulation tables in the memory section of the debug panel
This commit is contained in:
@@ -18,6 +18,9 @@ http://mozilla.org/MPL/2.0/.
|
||||
#include "model/MdlMngr.h"
|
||||
#include "audio/audiorenderer.h"
|
||||
#include "world/Track.h"
|
||||
#include "world/Traction.h"
|
||||
#include "world/MemCell.h"
|
||||
#include "audio/sound.h"
|
||||
#include "utilities/memorystats.h"
|
||||
#include "utilities/Logs.h"
|
||||
#include "simulation/simulationtime.h"
|
||||
@@ -1178,6 +1181,25 @@ void opengl46_renderer::Update_Memory_Info()
|
||||
auto const heap { query_heap_memory() };
|
||||
text += "taken with new: " + mb( heap.bytes ) + " in " + std::to_string( heap.blocks ) + " blocks"
|
||||
+ ( process.valid && ( process.committed > heap.bytes ) ? ", the rest of the private memory " + mb( process.committed - heap.bytes ) + " (drivers, libraries)" : std::string{} ) + "\n";
|
||||
// the same by the size of the blocks, in wider ranges
|
||||
{
|
||||
struct range { std::size_t last; char const *name; }; // classes up to last, see heap_memory
|
||||
static range const ranges[] = {
|
||||
{ 6, "below 64 B" }, { 8, "64-255 B" }, { 10, "256 B-1 KB" }, { 12, "1-4 KB" }, { 16, "4-64 KB" }, { 20, "64 KB-1 MB" }, { 24, "1-16 MB" }, { heap_memory::CLASSES - 1, "16 MB and more" } };
|
||||
std::size_t first { 0 };
|
||||
text += " by block size:";
|
||||
for( auto const &item : ranges ) {
|
||||
std::uint64_t bytes { 0 }, blocks { 0 };
|
||||
for( auto index { first }; index <= item.last; ++index ) {
|
||||
bytes += heap.classbytes[ index ];
|
||||
blocks += heap.classblocks[ index ];
|
||||
}
|
||||
first = item.last + 1;
|
||||
if( blocks == 0 ) { continue; }
|
||||
text += std::string( " " ) + item.name + ": " + mb( bytes ) + " in " + std::to_string( blocks ) + ";";
|
||||
}
|
||||
text += "\n";
|
||||
}
|
||||
// the memory of the card, all processes: GL_NVX_gpu_memory_info (in kB)
|
||||
if( m_nvxmemory < 0 ) {
|
||||
m_nvxmemory = 0;
|
||||
@@ -1252,6 +1274,18 @@ void opengl46_renderer::Update_Memory_Info()
|
||||
accounted += sounds.bytes;
|
||||
text += "sounds: " + counted( sounds, "buffers" ) + " " + mb( sounds.bytes ) + "\n";
|
||||
text += "vehicles: " + std::to_string( simulation::Vehicles.sequence().size() ) + "\n";
|
||||
// the objects of the tables of the simulation, without what they hold
|
||||
{
|
||||
auto const table = [ & ]( char const *Name, std::size_t const Count, std::size_t const Size ) {
|
||||
return std::string( Name ) + " " + std::to_string( Count ) + " (" + mb( static_cast<std::uint64_t>( Count ) * Size ) + ")"; };
|
||||
auto const tables {
|
||||
table( "tracks", simulation::Paths.sequence().size(), sizeof( TTrack ) ) + ", "
|
||||
+ table( "traction", simulation::Traction.sequence().size(), sizeof( TTraction ) ) + ", "
|
||||
+ table( "memory cells", simulation::Memory.sequence().size(), sizeof( TMemCell ) ) + ", "
|
||||
+ table( "instances in the table", simulation::Instances.sequence().size(), sizeof( TAnimModel ) ) + ", "
|
||||
+ table( "sounds", simulation::Sounds.sequence().size(), sizeof( sound_source ) ) };
|
||||
text += "tables: " + tables + "\n";
|
||||
}
|
||||
if( process.valid ) {
|
||||
auto const total { process.committed > 0 ? process.committed : process.resident };
|
||||
text += "counted above: " + mb( accounted ) + " of " + mb( total ) + ( process.committed > 0 ? " private" : " resident" ) + ", the rest "
|
||||
|
||||
@@ -11,6 +11,7 @@ http://mozilla.org/MPL/2.0/.
|
||||
#include "utilities/memorystats.h"
|
||||
|
||||
#include <atomic>
|
||||
#include <bit>
|
||||
#include <cstdlib>
|
||||
#include <new>
|
||||
|
||||
@@ -34,6 +35,14 @@ namespace
|
||||
|
||||
std::atomic<std::uint64_t> g_heapbytes{0};
|
||||
std::atomic<std::uint64_t> g_heapblocks{0};
|
||||
// by the size of the blocks, see heap_memory
|
||||
std::array<std::atomic<std::uint64_t>, heap_memory::CLASSES> g_classbytes{};
|
||||
std::array<std::atomic<std::uint64_t>, heap_memory::CLASSES> g_classblocks{};
|
||||
|
||||
std::size_t size_class(std::size_t const Size)
|
||||
{
|
||||
return std::min<std::size_t>(std::bit_width(Size), heap_memory::CLASSES - 1);
|
||||
}
|
||||
|
||||
std::size_t block_size(void *Block)
|
||||
{
|
||||
@@ -56,8 +65,11 @@ void *counted_new(std::size_t Size)
|
||||
{
|
||||
if (auto *block{std::malloc(Size)})
|
||||
{
|
||||
g_heapbytes.fetch_add(block_size(block), std::memory_order_relaxed);
|
||||
auto const size{block_size(block)};
|
||||
g_heapbytes.fetch_add(size, std::memory_order_relaxed);
|
||||
g_heapblocks.fetch_add(1, std::memory_order_relaxed);
|
||||
g_classbytes[size_class(size)].fetch_add(size, std::memory_order_relaxed);
|
||||
g_classblocks[size_class(size)].fetch_add(1, std::memory_order_relaxed);
|
||||
return block;
|
||||
}
|
||||
auto const handler{std::get_new_handler()};
|
||||
@@ -75,8 +87,11 @@ void counted_delete(void *Block) noexcept
|
||||
{
|
||||
return;
|
||||
}
|
||||
g_heapbytes.fetch_sub(block_size(Block), std::memory_order_relaxed);
|
||||
auto const size{block_size(Block)};
|
||||
g_heapbytes.fetch_sub(size, std::memory_order_relaxed);
|
||||
g_heapblocks.fetch_sub(1, std::memory_order_relaxed);
|
||||
g_classbytes[size_class(size)].fetch_sub(size, std::memory_order_relaxed);
|
||||
g_classblocks[size_class(size)].fetch_sub(1, std::memory_order_relaxed);
|
||||
std::free(Block);
|
||||
}
|
||||
|
||||
@@ -148,7 +163,15 @@ void operator delete[](void *Block, std::nothrow_t const &) noexcept
|
||||
|
||||
heap_memory query_heap_memory()
|
||||
{
|
||||
return {g_heapbytes.load(std::memory_order_relaxed), g_heapblocks.load(std::memory_order_relaxed)};
|
||||
heap_memory result;
|
||||
result.bytes = g_heapbytes.load(std::memory_order_relaxed);
|
||||
result.blocks = g_heapblocks.load(std::memory_order_relaxed);
|
||||
for (std::size_t index = 0; index < heap_memory::CLASSES; ++index)
|
||||
{
|
||||
result.classbytes[index] = g_classbytes[index].load(std::memory_order_relaxed);
|
||||
result.classblocks[index] = g_classblocks[index].load(std::memory_order_relaxed);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
process_memory query_process_memory()
|
||||
|
||||
@@ -9,6 +9,7 @@ http://mozilla.org/MPL/2.0/.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <array>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
@@ -29,6 +30,10 @@ struct heap_memory
|
||||
{
|
||||
std::uint64_t bytes{0};
|
||||
std::uint64_t blocks{0};
|
||||
// the same by the size of the blocks: class N holds the blocks of 2^(N-1) to 2^N - 1 bytes
|
||||
static constexpr std::size_t CLASSES{48};
|
||||
std::array<std::uint64_t, CLASSES> classbytes{};
|
||||
std::array<std::uint64_t, CLASSES> classblocks{};
|
||||
};
|
||||
|
||||
heap_memory query_heap_memory();
|
||||
|
||||
Reference in New Issue
Block a user