StillHammer
1b7703f07b
## Breaking Change
IIO API redesigned from manual pull+if-forest to callback dispatch.
All modules must update their subscribe() calls to pass handlers.
### Before (OLD API)
```cpp
io->subscribe("input:mouse");
void process(...) {
while (io->hasMessages()) {
auto msg = io->pullMessage();
if (msg.topic == "input:mouse") {
handleMouse(msg);
} else if (msg.topic == "input:keyboard") {
handleKeyboard(msg);
}
}
}
```
### After (NEW API)
```cpp
io->subscribe("input:mouse", [this](const Message& msg) {
handleMouse(msg);
});
void process(...) {
while (io->hasMessages()) {
io->pullAndDispatch(); // Callbacks invoked automatically
}
}
```
## Changes
**Core API (include/grove/IIO.h)**
- Added: `using MessageHandler = std::function<void(const Message&)>`
- Changed: `subscribe()` now requires `MessageHandler` callback parameter
- Changed: `subscribeLowFreq()` now requires `MessageHandler` callback
- Removed: `pullMessage()`
- Added: `pullAndDispatch()` - pulls and auto-dispatches to handlers
**Implementation (src/IntraIO.cpp)**
- Store callbacks in `Subscription.handler`
- `pullAndDispatch()` matches topic against ALL subscriptions (not just first)
- Fixed: Regex pattern compilation supports both wildcards (*) and regex (.*)
- Performance: ~1000 msg/s throughput (unchanged from before)
**Files Updated**
- 31 test/module files migrated to callback API (via parallel agents)
- 8 documentation files updated (DEVELOPER_GUIDE, USER_GUIDE, module READMEs)
## Bugs Fixed During Migration
1. **pullAndDispatch() early return bug**: Was only calling FIRST matching handler
- Fix: Loop through ALL subscriptions, invoke all matching handlers
2. **Regex pattern compilation bug**: Pattern "player:.*" failed to match
- Fix: Detect ".*" in pattern → use as regex, otherwise escape and convert wildcards
## Testing
✅ test_11_io_system: PASSED (IIO pub/sub, pattern matching, batching)
✅ test_threaded_module_system: 6/6 PASSED
✅ test_threaded_stress: 5/5 PASSED (50 modules, 100x reload, concurrent ops)
✅ test_12_datanode: PASSED
✅ 10 TopicTree scenarios: 10/10 PASSED
✅ benchmark_e2e: ~1000 msg/s throughput
Total: 23+ tests passing
## Performance Impact
No performance regression from callback dispatch:
- IIO throughput: ~1000 msg/s (same as before)
- ThreadedModuleSystem: Speedup ~1.0x (barrier pattern expected)
## Migration Guide
For all modules using IIO:
1. Update subscribe() calls to include handler lambda
2. Replace pullMessage() loops with pullAndDispatch()
3. Move topic-specific logic from if-forest into callbacks
Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
127 lines
3.4 KiB
C++
127 lines
3.4 KiB
C++
#include "MetricsModule.h"
|
|
#include <iostream>
|
|
|
|
namespace grove {
|
|
|
|
MetricsModule::MetricsModule() {
|
|
std::cout << "[MetricsModule] Constructor" << std::endl;
|
|
}
|
|
|
|
MetricsModule::~MetricsModule() {
|
|
std::cout << "[MetricsModule] Destructor" << std::endl;
|
|
}
|
|
|
|
void MetricsModule::process(const IDataNode& input) {
|
|
float deltaTime = static_cast<float>(input.getDouble("deltaTime", 1.0/60.0));
|
|
|
|
accumulator += deltaTime;
|
|
|
|
// Collect metrics every 100ms
|
|
if (accumulator >= 0.1f) {
|
|
collectMetrics();
|
|
accumulator = 0.0f;
|
|
}
|
|
|
|
// Pull and dispatch all pending messages (callbacks invoked automatically)
|
|
if (io) {
|
|
while (io->hasMessages() > 0) {
|
|
io->pullAndDispatch();
|
|
}
|
|
}
|
|
}
|
|
|
|
void MetricsModule::setConfiguration(const IDataNode& configNode, IIO* ioPtr, ITaskScheduler* schedulerPtr) {
|
|
std::cout << "[MetricsModule] setConfiguration called" << std::endl;
|
|
|
|
this->io = ioPtr;
|
|
this->scheduler = schedulerPtr;
|
|
|
|
// Store config
|
|
config = std::make_unique<JsonDataNode>("config", nlohmann::json::object());
|
|
|
|
// Subscribe to economy events with callback
|
|
if (io) {
|
|
io->subscribe("economy:*", [this](const Message& msg) {
|
|
std::cout << "[MetricsModule] Received: " << msg.topic << std::endl;
|
|
});
|
|
}
|
|
}
|
|
|
|
const IDataNode& MetricsModule::getConfiguration() {
|
|
if (!config) {
|
|
config = std::make_unique<JsonDataNode>("config", nlohmann::json::object());
|
|
}
|
|
return *config;
|
|
}
|
|
|
|
std::unique_ptr<IDataNode> MetricsModule::getHealthStatus() {
|
|
nlohmann::json health = {
|
|
{"status", "healthy"},
|
|
{"snapshotsPublished", snapshotsPublished}
|
|
};
|
|
return std::make_unique<JsonDataNode>("health", health);
|
|
}
|
|
|
|
void MetricsModule::shutdown() {
|
|
std::cout << "[MetricsModule] Shutdown - Published " << snapshotsPublished << " snapshots" << std::endl;
|
|
}
|
|
|
|
std::unique_ptr<IDataNode> MetricsModule::getState() {
|
|
nlohmann::json state = {
|
|
{"snapshotsPublished", snapshotsPublished},
|
|
{"accumulator", accumulator}
|
|
};
|
|
return std::make_unique<JsonDataNode>("state", state);
|
|
}
|
|
|
|
void MetricsModule::setState(const IDataNode& state) {
|
|
snapshotsPublished = state.getInt("snapshotsPublished", 0);
|
|
accumulator = static_cast<float>(state.getDouble("accumulator", 0.0));
|
|
std::cout << "[MetricsModule] State restored" << std::endl;
|
|
}
|
|
|
|
void MetricsModule::setDataTree(IDataTree* treePtr) {
|
|
this->tree = treePtr;
|
|
}
|
|
|
|
void MetricsModule::collectMetrics() {
|
|
if (!tree) return;
|
|
|
|
auto runtimeRoot = tree->getRuntimeRoot();
|
|
|
|
nlohmann::json metricsData = {
|
|
{"fps", 60.0},
|
|
{"memory", 125000000},
|
|
{"messageCount", snapshotsPublished}
|
|
};
|
|
|
|
auto metrics = std::make_unique<JsonDataNode>("metrics", metricsData);
|
|
|
|
// Update runtime metrics (not persisted)
|
|
// Note: Cannot use setChild directly, would need proper implementation
|
|
}
|
|
|
|
void MetricsModule::publishSnapshot() {
|
|
if (!io) return;
|
|
|
|
nlohmann::json snapshot = {
|
|
{"fps", 60.0},
|
|
{"memory", 125000000},
|
|
{"snapshotsPublished", snapshotsPublished}
|
|
};
|
|
|
|
auto dataNode = std::make_unique<JsonDataNode>("snapshot", snapshot);
|
|
io->publish("metrics:snapshot", std::move(dataNode));
|
|
|
|
snapshotsPublished++;
|
|
}
|
|
|
|
} // namespace grove
|
|
|
|
// Export C API
|
|
extern "C" {
|
|
grove::IModule* createModule() {
|
|
return new grove::MetricsModule();
|
|
}
|
|
}
|