Lamp-Da 0.1
A compact lantern project
Loading...
Searching...
No Matches
recovery_trace.h
1#pragma once
2
3#include <array>
4#include <atomic>
5#include <cstdint>
6
7namespace lampda::common {
8
9enum class RecoveryStage : uint8_t
10{
11 ChargerProbe,
12 BalancerProbe,
13 VbusGateRequested,
14 StartupRejected,
15 ChargerSetup,
16 ChargeRequested,
17 BalancerSetupFailed,
18 Count
19};
20
22{
23 uint32_t time_ms = 0;
24 RecoveryStage stage = RecoveryStage::ChargerProbe;
25 int result = 0;
26
27 RecoveryEvent() = default;
28 RecoveryEvent(uint32_t t, RecoveryStage s, int r) : time_ms(t), stage(s), result(r) {}
29};
30
31// One startup writer, CLI readers. Published entries are immutable, with no wraparound.
33{
34public:
35 static constexpr uint32_t capacity = 16;
36
37 void probe(RecoveryStage stage, int result, uint32_t time_ms)
38 {
39 const bool charger = stage == RecoveryStage::ChargerProbe;
40 auto& attempts = charger ? charger_attempts : balancer_attempts;
41 auto& last = charger ? charger_result : balancer_result;
42 attempts.fetch_add(1, std::memory_order_relaxed);
43 if (last.exchange(static_cast<uint32_t>(result), std::memory_order_relaxed) != static_cast<uint32_t>(result))
44 append(RecoveryEvent(time_ms, stage, result));
45 }
46
47 void once(RecoveryStage stage, int result, uint32_t time_ms)
48 {
49 const uint32_t bit = 1u << static_cast<uint8_t>(stage);
50 if (seen & bit)
51 return;
52 seen |= bit;
53 append(RecoveryEvent(time_ms, stage, result));
54 }
55
56 uint32_t size() const { return published.load(std::memory_order_acquire); }
57 const RecoveryEvent& event(uint32_t index) const { return events[index]; }
58 uint32_t omitted() const { return dropped.load(std::memory_order_relaxed); }
59 uint32_t charger_probes() const { return charger_attempts.load(std::memory_order_relaxed); }
60 uint32_t balancer_probes() const { return balancer_attempts.load(std::memory_order_relaxed); }
61
62private:
63 void append(RecoveryEvent event)
64 {
65 const uint32_t index = published.load(std::memory_order_relaxed);
66 if (index >= capacity)
67 {
68 dropped.fetch_add(1, std::memory_order_relaxed);
69 return;
70 }
71 events[index] = event;
72 published.store(index + 1, std::memory_order_release);
73 }
74
75 std::array<RecoveryEvent, capacity> events {};
76 std::atomic<uint32_t> published {0}, dropped {0};
77 std::atomic<uint32_t> charger_attempts {0}, balancer_attempts {0};
78 std::atomic<uint32_t> charger_result {UINT32_MAX}, balancer_result {UINT32_MAX};
79 uint32_t seen = 0;
80};
81
82static_assert(ATOMIC_INT_LOCK_FREE == 2, "Startup diagnostics require lock-free integer atomics");
83
84} // namespace lampda::common
Definition: recovery_trace.h:33
Shared interfaces & general utilities.
Definition: cmd_parser.cpp:9
Definition: recovery_trace.h:22