PotRegistry Class Reference

#include <PotRegistry.h>

Classes
struct	InstanceRecord
struct	TypeStats

Public Types
using	Clock = std::chrono::system_clock
using	TimePoint = Clock::time_point

Public Member Functions
void	reset ()
uint64_t	on_created (PotType t) noexcept
void	on_destroyed (uint64_t id, PotType t, size_t force_calls, TimePoint created_at)
void	on_force_call (PotType t) noexcept
size_t	type_force_calls (PotType t) const noexcept
size_t	total_force_calls () const noexcept
size_t	type_alive (PotType t) const noexcept
void	write_summary (const std::string &path="_potcalls.json") const

Static Public Member Functions
static PotRegistry &	get () noexcept
	Process-lifetime singleton.

Private Attributes
std::array< TypeStats, magic_enum::enum_count< PotType >()>	m_type_stats {}
std::mutex	m_records_mutex
std::vector< InstanceRecord >	m_records
std::atomic< uint64_t >	m_next_id {1}

Detailed Description

Definition at line 24 of file PotRegistry.h.

Member Typedef Documentation

Clock

using eonc::PotRegistry::Clock = std::chrono::system_clock

Definition at line 26 of file PotRegistry.h.

TimePoint

using eonc::PotRegistry::TimePoint = Clock::time_point

Definition at line 27 of file PotRegistry.h.

Member Function Documentation

get()

PotRegistry & eonc::PotRegistry::get ( )

staticnoexcept

Process-lifetime singleton.

The instance is allocated on the heap and never destroyed, so Potential destructors can still record teardown after C++ static destruction.

Definition at line 50 of file PotRegistry.cpp.

                                       {
  // Heap-allocated and never deleted. Potential destructors call
  // on_destroyed, and those objects can outlive C++ static
  // destructors (interpreter finalization, leaked shared_ptrs). A
  // function-local static would already be destroyed on those paths,
  // so on_destroyed would lock a destroyed mutex.
  static PotRegistry *instance = new PotRegistry;
  return *instance;
}

on_created()

uint64_t eonc::PotRegistry::on_created ( PotType t )

nodiscardnoexcept

Definition at line 71 of file PotRegistry.cpp.

                                                   {
  auto idx = static_cast<size_t>(magic_enum::enum_index(t).value_or(0));
  m_type_stats[idx].created.fetch_add(1, std::memory_order_relaxed);
  m_type_stats[idx].alive.fetch_add(1, std::memory_order_relaxed);
  return m_next_id.fetch_add(1, std::memory_order_relaxed);
}

on_destroyed()

void eonc::PotRegistry::on_destroyed	(	uint64_t	id,
		PotType	t,
		size_t	force_calls,
		TimePoint	created_at )

Definition at line 78 of file PotRegistry.cpp.

                                                     {
  auto idx = static_cast<size_t>(magic_enum::enum_index(t).value_or(0));
  m_type_stats[idx].alive.fetch_sub(1, std::memory_order_relaxed);
 
  InstanceRecord rec{id, t, created_at, Clock::now(), force_calls};
  std::lock_guard<std::mutex> lock(m_records_mutex);
  m_records.push_back(rec);
}

on_force_call()

void eonc::PotRegistry::on_force_call ( PotType t )

noexcept

Definition at line 88 of file PotRegistry.cpp.

                                                  {
  auto idx = static_cast<size_t>(magic_enum::enum_index(t).value_or(0));
  m_type_stats[idx].force_calls.fetch_add(1, std::memory_order_relaxed);
}

reset()

void eonc::PotRegistry::reset

(

)

Definition at line 60 of file PotRegistry.cpp.

                        {
  for (auto &ts : m_type_stats) {
    ts.force_calls.store(0, std::memory_order_relaxed);
    ts.created.store(0, std::memory_order_relaxed);
    ts.alive.store(0, std::memory_order_relaxed);
  }
  std::lock_guard<std::mutex> lock(m_records_mutex);
  m_records.clear();
  m_next_id.store(1, std::memory_order_relaxed);
}

total_force_calls()

size_t eonc::PotRegistry::total_force_calls ( ) const

nodiscardnoexcept

Definition at line 98 of file PotRegistry.cpp.

                                                     {
  size_t total = 0;
  for (const auto &ts : m_type_stats) {
    total += ts.force_calls.load(std::memory_order_relaxed);
  }
  return total;
}

type_alive()

size_t eonc::PotRegistry::type_alive ( PotType t ) const

nodiscardnoexcept

Definition at line 106 of file PotRegistry.cpp.

                                                       {
  auto idx = static_cast<size_t>(magic_enum::enum_index(t).value_or(0));
  return m_type_stats[idx].alive.load(std::memory_order_relaxed);
}

type_force_calls()

size_t eonc::PotRegistry::type_force_calls ( PotType t ) const

nodiscardnoexcept

Definition at line 93 of file PotRegistry.cpp.

                                                             {
  auto idx = static_cast<size_t>(magic_enum::enum_index(t).value_or(0));
  return m_type_stats[idx].force_calls.load(std::memory_order_relaxed);
}

write_summary()

void eonc::PotRegistry::write_summary

(

const std::string &

path = "_potcalls.json"

)

const

Definition at line 111 of file PotRegistry.cpp.

                                                           {
  std::vector<InstanceRecord> snapshot;
  {
    std::lock_guard<std::mutex> lock(const_cast<std::mutex &>(m_records_mutex));
    snapshot = m_records;
  }
 
  std::ofstream ofs(path);
  if (!ofs.is_open())
    return;
 
  ofs << "[\n";
  for (size_t i = 0; i < snapshot.size(); ++i) {
    const auto &r = snapshot[i];
    auto type_name = magic_enum::enum_name(r.type);
    ofs << "  {\n";
    ofs << "    \"id\": " << r.id << ",\n";
    ofs << "    \"type\": \"" << json_escape(type_name) << "\",\n";
    ofs << "    \"created_at\": \"" << format_timepoint(r.created_at)
        << "\",\n";
    ofs << "    \"destroyed_at\": \"" << format_timepoint(r.destroyed_at)
        << "\",\n";
    ofs << "    \"force_calls\": " << r.force_calls << "\n";
    ofs << "  }";
    if (i + 1 < snapshot.size())
      ofs << ',';
    ofs << '\n';
  }
  ofs << "]\n";
}

Member Data Documentation

m_next_id

std::atomic<uint64_t> eonc::PotRegistry::m_next_id {1}

private

Definition at line 48 of file PotRegistry.h.

{1};

m_records

std::vector<InstanceRecord> eonc::PotRegistry::m_records

private

Definition at line 46 of file PotRegistry.h.

m_records_mutex

std::mutex eonc::PotRegistry::m_records_mutex

private

Definition at line 45 of file PotRegistry.h.

m_type_stats

std::array<TypeStats, magic_enum::enum_count<PotType>()> eonc::PotRegistry::m_type_stats {}

private

Definition at line 43 of file PotRegistry.h.

{};

---

The documentation for this class was generated from the following files:

• /home/runner/work/eOn/eOn/include/eon/PotRegistry.h
• /home/runner/work/eOn/eOn/client/PotRegistry.cpp