diagnostics.h

#pragma once
 
#include <cstddef>
#include <cstdint>
#include <limits>
 
// TESS_ENABLE_DIAGNOSTICS changes public TYPES, not just statements:
// PathCounters, TraceBuffer, WarningSink and six more exist only when it is
// defined, and the diagnostics accessors change signature with them. A
// program that defines it for some translation units and not others
// violates the one-definition rule with no diagnostic on any compiler --
// the layouts simply disagree at link time. Define it for a whole binary
// or not at all.
//
// The pragma gives MSVC a link-time check; GCC and Clang have no equivalent
// mechanism, so consistency there is the build system's job. This mirrors
// what core/config.h does for the exception mode and core/capacity.h for
// the internal capacity hook.
#if defined(_MSC_VER)
#if defined(TESS_ENABLE_DIAGNOSTICS)
#pragma detect_mismatch("tess_diagnostics_mode", "enabled")
#else
#pragma detect_mismatch("tess_diagnostics_mode", "disabled")
#endif
#endif
 
#if defined(TESS_ENABLE_DIAGNOSTICS)
#define TESS_DIAGNOSTICS_ENABLED 1
#define TESS_DIAGNOSTIC_ONLY(expr) \
  do {                             \
    expr;                          \
  } while (false)
#define TESS_DIAGNOSTIC_INC(counter) \
  do {                               \
    ++(counter);                     \
  } while (false)
#define TESS_DIAGNOSTIC_ADD(counter, value) \
  do {                                      \
    (counter) += (value);                   \
  } while (false)
#define TESS_DIAG_EVENT(name)            \
  do {                                   \
    ::tess::diagnostics::event_##name(); \
  } while (false)
#define TESS_DIAG_EVENT_VALUE(name, value)    \
  do {                                        \
    ::tess::diagnostics::event_##name(value); \
  } while (false)
#else
#define TESS_DIAGNOSTICS_ENABLED 0
#define TESS_DIAGNOSTIC_ONLY(expr) \
  do {                             \
  } while (false)
#define TESS_DIAGNOSTIC_INC(counter) \
  do {                               \
  } while (false)
#define TESS_DIAGNOSTIC_ADD(counter, value) \
  do {                                      \
  } while (false)
#define TESS_DIAG_EVENT(name) \
  do {                        \
  } while (false)
#define TESS_DIAG_EVENT_VALUE(name, value) \
  do {                                     \
  } while (false)
#endif
 
namespace tess::diagnostics {
 
#if TESS_DIAGNOSTICS_ENABLED
struct PathCounters {
  std::uint64_t scratch_clear_calls = 0;
  std::uint64_t scratch_clear_nodes = 0;
  std::uint64_t initializations = 0;
  std::uint64_t start_passability_checks = 0;
  std::uint64_t goal_passability_checks = 0;
  std::uint64_t heap_pushes = 0;
  std::uint64_t heap_pops = 0;
  std::uint64_t stale_pops = 0;
  std::uint64_t closed_pops = 0;
  std::uint64_t neighbor_candidates = 0;
  std::uint64_t passability_checks = 0;
  std::uint64_t cost_reads = 0;
  std::uint64_t blocked_neighbors = 0;
  std::uint64_t closed_neighbors = 0;
  std::uint64_t relax_attempts = 0;
  std::uint64_t relax_successes = 0;
  std::uint64_t touched_nodes = 0;
  std::uint64_t heuristic_calls = 0;
  std::uint64_t reconstructed_nodes = 0;
 
  void reset() noexcept { *this = PathCounters{}; }
};

struct AllocationCounters {
  std::uint64_t allocations = 0;
  std::uint64_t allocation_bytes = 0;
  std::uint64_t deallocations = 0;
  std::uint64_t deallocation_bytes = 0;
  // Best-effort retained-byte accounting. Unsized deallocation hooks pass
  // zero and therefore cannot reduce this value; consumers that require exact
  // live memory must supply sized allocator hooks.
  std::uint64_t live_bytes = 0;
  std::uint64_t peak_live_bytes = 0;
 
  void reset() noexcept { *this = AllocationCounters{}; }
};

struct QueuedPhaseCounters {
  std::uint64_t phase_calls = 0;
  std::uint64_t phase_operations = 0;
  std::uint64_t phase_invalid_ranges = 0;
  std::uint64_t phase_failures = 0;
  std::uint64_t partitioned_phase_calls = 0;
  std::uint64_t dirty_partitions = 0;
  std::uint64_t scoped_thread_calls = 0;
  std::uint64_t scoped_thread_workers = 0;
  std::uint64_t worker_pool_calls = 0;
  std::uint64_t worker_pool_workers = 0;
  std::uint64_t dirty_records_collected = 0;
  std::uint64_t dirty_chunks_merged = 0;
 
  void reset() noexcept { *this = QueuedPhaseCounters{}; }
};
 
inline thread_local PathCounters* active_path_counters = nullptr;
inline thread_local AllocationCounters* active_allocation_counters = nullptr;
inline thread_local std::uint64_t active_allocation_scope_id = 0;
inline thread_local std::uint64_t next_allocation_scope_id = 1;
inline thread_local QueuedPhaseCounters* active_queued_phase_counters = nullptr;

class ScopedPathCounters {
 public:
  explicit ScopedPathCounters(PathCounters& counters) noexcept
      : previous_{active_path_counters} {
    active_path_counters = &counters;
  }
 
  ScopedPathCounters(const ScopedPathCounters&) = delete;
  auto operator=(const ScopedPathCounters&) -> ScopedPathCounters& = delete;
 
  ~ScopedPathCounters() { active_path_counters = previous_; }
 
 private:
  PathCounters* previous_;
};

class ScopedAllocationCounters {
 public:
  explicit ScopedAllocationCounters(AllocationCounters& counters) noexcept
      : previous_{active_allocation_counters},
        previous_scope_id_{active_allocation_scope_id},
        scope_id_{next_allocation_scope_id++} {
    if (next_allocation_scope_id == 0) {
      next_allocation_scope_id = 1;
    }
    active_allocation_counters = &counters;
    active_allocation_scope_id = scope_id_;
  }
 
  ScopedAllocationCounters(const ScopedAllocationCounters&) = delete;
  auto operator=(const ScopedAllocationCounters&)
      -> ScopedAllocationCounters& = delete;
 
  ~ScopedAllocationCounters() {
    active_allocation_counters = previous_;
    active_allocation_scope_id = previous_scope_id_;
  }
 
 private:
  AllocationCounters* previous_;
  std::uint64_t previous_scope_id_;
  std::uint64_t scope_id_;
};

class ScopedQueuedPhaseCounters {
 public:
  explicit ScopedQueuedPhaseCounters(QueuedPhaseCounters& counters) noexcept
      : previous_{active_queued_phase_counters} {
    active_queued_phase_counters = &counters;
  }
 
  ScopedQueuedPhaseCounters(const ScopedQueuedPhaseCounters&) = delete;
  auto operator=(const ScopedQueuedPhaseCounters&)
      -> ScopedQueuedPhaseCounters& = delete;
 
  ~ScopedQueuedPhaseCounters() { active_queued_phase_counters = previous_; }
 
 private:
  QueuedPhaseCounters* previous_;
};

inline void record_allocation(std::size_t size) noexcept {
  if (active_allocation_counters != nullptr) {
    auto& counters = *active_allocation_counters;
    ++counters.allocations;
    counters.allocation_bytes += size;
    const auto bytes = static_cast<std::uint64_t>(size);
    const auto maximum = std::numeric_limits<std::uint64_t>::max();
    counters.live_bytes = bytes > maximum - counters.live_bytes
                              ? maximum
                              : counters.live_bytes + bytes;
    if (counters.live_bytes > counters.peak_live_bytes) {
      counters.peak_live_bytes = counters.live_bytes;
    }
  }
}

inline void record_deallocation(std::size_t size = 0) noexcept {
  if (active_allocation_counters != nullptr) {
    auto& counters = *active_allocation_counters;
    ++counters.deallocations;
    counters.deallocation_bytes += size;
    const auto bytes = static_cast<std::uint64_t>(size);
    counters.live_bytes =
        bytes > counters.live_bytes ? 0 : counters.live_bytes - bytes;
  }
}

inline void event_path_clear(std::uint64_t nodes) noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->scratch_clear_calls;
    active_path_counters->scratch_clear_nodes += nodes;
  }
}

inline void event_path_initialize() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->initializations;
  }
}

inline void event_path_start_passability_check() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->start_passability_checks;
  }
}

inline void event_path_goal_passability_check() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->goal_passability_checks;
  }
}

inline void event_path_heap_push() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->heap_pushes;
  }
}

inline void event_path_heap_pop() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->heap_pops;
  }
}

inline void event_path_skip_pop(bool closed) noexcept {
  if (active_path_counters != nullptr) {
    if (closed) {
      ++active_path_counters->closed_pops;
    } else {
      ++active_path_counters->stale_pops;
    }
  }
}

inline void event_path_neighbor_candidate() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->neighbor_candidates;
  }
}

inline void event_path_passability_check() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->passability_checks;
  }
}

inline void event_path_cost_read() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->cost_reads;
  }
}

inline void event_path_neighbor_blocked() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->blocked_neighbors;
  }
}

inline void event_path_neighbor_closed() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->closed_neighbors;
  }
}

inline void event_path_relax_attempt() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->relax_attempts;
  }
}

inline void event_path_relax_success() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->relax_successes;
  }
}

inline void event_path_touch_node() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->touched_nodes;
  }
}

inline void event_path_heuristic() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->heuristic_calls;
  }
}

inline void event_path_reconstruct_node() noexcept {
  if (active_path_counters != nullptr) {
    ++active_path_counters->reconstructed_nodes;
  }
}

inline void event_queued_phase_execute(std::uint64_t operations) noexcept {
  if (active_queued_phase_counters != nullptr) {
    ++active_queued_phase_counters->phase_calls;
    active_queued_phase_counters->phase_operations += operations;
  }
}

inline void event_queued_phase_invalid_range() noexcept {
  if (active_queued_phase_counters != nullptr) {
    ++active_queued_phase_counters->phase_invalid_ranges;
  }
}

inline void event_queued_phase_failure() noexcept {
  if (active_queued_phase_counters != nullptr) {
    ++active_queued_phase_counters->phase_failures;
  }
}

inline void event_queued_partitioned_phase(std::uint64_t partitions) noexcept {
  if (active_queued_phase_counters != nullptr) {
    ++active_queued_phase_counters->partitioned_phase_calls;
    active_queued_phase_counters->dirty_partitions += partitions;
  }
}

inline void event_queued_scoped_thread_dispatch(
    std::uint64_t workers) noexcept {
  if (active_queued_phase_counters != nullptr) {
    ++active_queued_phase_counters->scoped_thread_calls;
    active_queued_phase_counters->scoped_thread_workers += workers;
  }
}

inline void event_queued_worker_pool_dispatch(std::uint64_t workers) noexcept {
  if (active_queued_phase_counters != nullptr) {
    ++active_queued_phase_counters->worker_pool_calls;
    active_queued_phase_counters->worker_pool_workers += workers;
  }
}

inline void event_queued_dirty_collect(std::uint64_t records) noexcept {
  if (active_queued_phase_counters != nullptr) {
    active_queued_phase_counters->dirty_records_collected += records;
  }
}

inline void event_queued_dirty_merge(std::uint64_t chunks) noexcept {
  if (active_queued_phase_counters != nullptr) {
    active_queued_phase_counters->dirty_chunks_merged += chunks;
  }
}
#endif

struct FlowCounters {
  std::uint64_t offered = 0;
  std::uint64_t admitted = 0;
  std::uint64_t rejected = 0;
  std::uint64_t coalesced_into_pending = 0;
  std::uint64_t completed = 0;
  std::uint64_t cancelled = 0;
  std::uint64_t superseded = 0;
  std::uint64_t stale = 0;
  std::uint64_t failed = 0;
  std::uint64_t dropped_after_admission = 0;
  std::uint64_t offered_work_units = 0;
  std::uint64_t consumed_work_units = 0;
  std::uint64_t outstanding_current = 0;
  std::uint64_t outstanding_high_water = 0;
  std::uint64_t inventory_tick_weighted = 0;
  std::uint64_t residence_ticks_accumulated = 0;
  std::uint64_t oldest_outstanding_age_ticks = 0;

  [[nodiscard]] constexpr auto terminal() const noexcept -> std::uint64_t {
    return completed + cancelled + superseded + stale + failed +
           dropped_after_admission;
  }

  [[nodiscard]] constexpr auto admission_identity_holds() const noexcept
      -> bool {
    return offered == admitted + rejected + coalesced_into_pending;
  }

  [[nodiscard]] constexpr auto retention_identity_holds() const noexcept
      -> bool {
    return admitted == terminal() + outstanding_current;
  }

  void reset() noexcept { *this = FlowCounters{}; }
};

struct FlowAccounting {
  FlowCounters counters{};
  std::uint64_t last_observed_tick = 0;

  void observe_tick(std::uint64_t tick) noexcept {
    if (tick > last_observed_tick) {
      counters.inventory_tick_weighted +=
          counters.outstanding_current * (tick - last_observed_tick);
      last_observed_tick = tick;
    }
  }

  void record_admitted() noexcept {
    ++counters.admitted;
    ++counters.outstanding_current;
    if (counters.outstanding_current > counters.outstanding_high_water) {
      counters.outstanding_high_water = counters.outstanding_current;
    }
  }

  void record_left_outstanding() noexcept {
    if (counters.outstanding_current > 0) {
      --counters.outstanding_current;
    }
  }
};

struct FlowHealthSnapshot {
  FlowCounters counters{};
  bool admission_identity_ok = false;
  bool retention_identity_ok = false;
};

[[nodiscard]] inline auto snapshot(const FlowAccounting& accounting) noexcept
    -> FlowHealthSnapshot {
  return FlowHealthSnapshot{
      accounting.counters,
      accounting.counters.admission_identity_holds(),
      accounting.counters.retention_identity_holds(),
  };
}
 
}  // namespace tess::diagnostics