fccu-cpp: C++17 Header-Only 软件故障收集器

// fault_queue_set.hpp
template <typename T, uint32_t Levels = 4U, uint32_t LevelSize = 32U>
class FaultQueueSet {
  static constexpr uint32_t kLowThreshold = (LevelSize * 60U) / 100U;
  static constexpr uint32_t kMediumThreshold = (LevelSize * 80U) / 100U;
  static constexpr uint32_t kHighThreshold = (LevelSize * 99U) / 100U;

  bool PushWithAdmission(uint8_t level, const T& item) noexcept {
    auto current_size = queues_[level].size();
    uint32_t threshold = LevelSize;
    switch (level) {
      case 1U: threshold = kHighThreshold; break;   // High: < 99%
      case 2U: threshold = kMediumThreshold; break;  // Medium: < 80%
      case 3U: threshold = kLowThreshold; break;     // Low: < 60%
      default: break;                                 // Critical: always
    }
    if (current_size >= threshold) { return false; }
    return queues_[level].push(item);
  }
};

// fccu.hpp
static constexpr uint32_t kBitmapWords = (MaxFaults + 63U) / 64U;
std::array<std::atomic<uint64_t>, kBitmapWords> active_bitmap_{};

void SetFaultActive(uint16_t fault_index) noexcept {
  uint32_t word_idx = fault_index / 64U;
  uint32_t bit_idx = fault_index % 64U;
  active_bitmap_[word_idx].fetch_or(1ULL << bit_idx, std::memory_order_relaxed);
}

uint32_t ActiveFaultCount() const noexcept {
  uint32_t count = 0U;
  for (uint32_t i = 0U; i < kBitmapWords; ++i) {
    count += PopCount64(active_bitmap_[i].load(std::memory_order_relaxed));
  }
  return count;
}

enum class HookAction : uint8_t {
  kHandled = 0U,   // 已处理，清除故障活跃位
  kEscalate = 1U,  // 升级到更高优先级，重新入队
  kDefer = 2U,     // 保持活跃，稍后处理
  kShutdown = 3U   // 请求系统关停
};

struct FaultReporter {
  FaultReportFn fn = nullptr;
  void* ctx = nullptr;

  void Report(uint16_t fault_index, uint32_t detail = 0U,
              FaultPriority priority = FaultPriority::kMedium) const noexcept {
    if (fn != nullptr) { fn(fault_index, detail, priority, ctx); }
  }
};

// 子模块只持有 FaultReporter，不依赖 FaultCollector 头文件
auto reporter = collector.GetReporter();
reporter.Report(0U, 0xBEEF, fccu::FaultPriority::kMedium);

// 绑定 Per-Fault HSM (可选)
collector.BindFaultHsm(0U, 3U);  // fault_index=0, threshold=3
// 连续检测到 3 次后才从 Detected -> Active

#include "fccu/fccu.hpp"

// 创建收集器: 16 个最大故障点, 8 深队列, 4 个优先级
fccu::FaultCollector<16, 8, 4> collector;

// 注册故障点
collector.RegisterFault(0, 0x1001);  // 温度传感器
collector.RegisterFault(1, 0x1002);  // 电压监控

// 注册 Hook
collector.RegisterHook(0, [](const fccu::FaultEvent& e, void*) -> fccu::HookAction {
    printf("Fault 0x%04x: detail=0x%x, count=%u\n",
           e.fault_code, e.detail, e.occurrence_count);
    return fccu::HookAction::kHandled;
});

// 设置关停回调
collector.SetShutdownCallback([](void*) {
    printf("EMERGENCY SHUTDOWN!\n");
});

// 上报故障 (生产者侧)
collector.ReportFault(0, 0xDEAD, fccu::FaultPriority::kCritical);

// 处理故障 (消费者侧, 在主循环或 ztask 回调中)
collector.ProcessFaults();

// 查询状态
printf("Active faults: %u\n", collector.ActiveFaultCount());
printf("HSM state: %s\n", collector.GetGlobalHsm().IsIdle() ? "Idle" : "Active");

#include "fccu/fccu.hpp"
#include "mccc/message_bus.hpp"

struct FaultNotification {
  uint16_t fault_index;
  uint32_t fault_code;
  uint32_t detail;
  uint8_t priority;
};

using BusPayload = std::variant<FaultNotification>;
using Bus = mccc::AsyncBus<BusPayload>;

// 订阅故障通知
Bus& bus = Bus::Instance();
bus.Subscribe<FaultNotification>([](const Bus::EnvelopeType& env) {
    if (auto* msg = std::get_if<FaultNotification>(&env.payload)) {
        printf("Bus: fault 0x%04x pri=%u\n", msg->fault_code, msg->priority);
    }
});

// 设置 FCCU 的总线通知回调
collector.SetBusNotifier([](const fccu::FaultEvent& event, void* ctx) {
    auto* bus = static_cast<Bus*>(ctx);
    FaultNotification msg{event.fault_index, event.fault_code,
                          event.detail, static_cast<uint8_t>(event.priority)};
    bus->Publish(BusPayload{msg}, 0U);
}, &bus);

#include "fccu/fccu.hpp"
#include "ztask/task_scheduler.hpp"

fccu::FaultCollector<16, 8, 4> collector;
ztask::TaskScheduler<8> scheduler;

// 注册周期任务: 每 10ms 处理一次故障队列
scheduler.Bind("fccu_proc", 10, [](void* ctx) {
    static_cast<decltype(&collector)>(ctx)->ProcessFaults();
}, &collector);

// 主循环
while (!collector.IsShutdownRequested()) {
    scheduler.Tick();
}

# 基本构建
cmake -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build -j

# 运行测试
cd build && ctest --output-on-failure

# ASan + UBSan 验证
cmake -B build -DCMAKE_BUILD_TYPE=Debug \
  -DCMAKE_CXX_FLAGS="-fsanitize=address,undefined -fno-omit-frame-pointer"
cmake --build build -j && ctest --output-on-failure

# 中国大陆加速
cmake -B build -DFCCU_GITHUB_MIRROR="https://ghfast.top/"