diff --git a/README.md b/README.md index 2f40415..6657247 100644 --- a/README.md +++ b/README.md @@ -60,6 +60,18 @@ Each Saved Network gets its address automatically (DHCP) or has a Fixed one (doc "DNS and NTP" on the same screen holds two DNS servers (9.9.9.9 and 1.1.1.1 by default), used on Fixed networks, or on every network with "Always use my DNS"; and two NTP servers (pool.ntp.org and time.cloudflare.com), used after any the network's DHCP offers. Enter on "Status" shows what's in use and where each value came from. +## System + +The System App (docs/milestones/S1.md) shows what the device is doing, live and read-only, in any build. Tab moves between five views: + +- **Overview:** each core's load, free memory, network traffic, battery, uptime and chip temperature, and both cores' load over the last two minutes. +- **Tasks:** every FreeRTOS task with its core, its share of a core over the last second, and the least stack it ever had left (in the warning colour under 512 bytes). `s` sorts by share, stack or name. +- **Memory:** free heap, the lowest since boot and the largest free block, with two minutes of free heap drawn against the three memory floors (55, 40 and 20 KB). +- **Network:** the connection, then for IRC, Gemini, the Debug Console and Firmware Updates the bytes read and written since boot and what's moving now. For TLS connections these are the bytes the service sees, without the encryption overhead. +- **System:** what `info` prints, plus the battery, the SD card with its write faults, the radio and the GNSS receiver. + +It samples once a second and keeps its history only while it's open. + ## Gemini The Gemini App browses Geminispace (docs/milestones/G1.md): Tab and Shift+Tab pick a link, Enter follows it, Back returns (to where the page was scrolled), Space pages down, `g` types an address. Certificates are trusted on first use; a changed one stops the page and asks. @@ -95,7 +107,8 @@ The LoRa Scanner (docs/milestones/M3.md) listens with the Cap's radio and **neve | `irc dump` | Prints IRC status, memory, and the last lines of each Buffer | | `wifi status` | Prints Wi-Fi state, network, signal, clock and free heap, then the address, gateway, DNS and NTP servers in use and where each came from | | `info` | Firmware, uptime, last start reason, memory, Wi-Fi, the SD card and its write faults since boot, and both app slots with their versions and OTA states | -| `tasks` | FreeRTOS tasks: state, priority, lowest free stack, CPU share | +| `tasks` | FreeRTOS tasks over the next second: state, priority, lowest free stack, share of a core, and each core's load | +| `net` | Bytes each network service has read and written since boot | | `reboot` / `boot other` | Restart, or restart into the other app slot (a manual Rollback) | | `log level <0-5>` | ESP-IDF log level | | `ls [folder]` / `rm ` | Lists a folder of the SD card, or deletes a file | diff --git a/docs/milestones/S1.md b/docs/milestones/S1.md index 1f50517..060cf9d 100644 --- a/docs/milestones/S1.md +++ b/docs/milestones/S1.md @@ -1,6 +1,6 @@ # S1 — System basics -**Status:** in progress. The SD driver fix shipped in v0.6.1 (issue #21, ADR 0007), and fixed IPv4 settings in v0.7.0 (issue #7). The System Monitor (#11) hasn't started; issue #39 follows the SD driver upstream. +**Status:** the three planned items are done: the SD driver fix in v0.6.1 (issue #21, ADR 0007), fixed IPv4 settings in v0.7.0 (issue #7), the System App in v0.8.0 (issue #11). Still open in the milestone: #39, following the SD driver upstream, and #40, the main loop's CPU use. **Goal:** the device works on any network, the card can be trusted, and you can see what the system is doing. A side milestone, like G1. @@ -59,3 +59,34 @@ The network is 10.39.39.0/24, gateway 10.39.39.1; DHCP gives 10.39.39.1 as DNS a 3. **Wi-Fi Service:** apply it when joining; DNS and NTP; `wifi status` and the console commands. 4. **Settings:** the network page, the DNS and NTP rows, connection details. 5. **Tests on the device**, recorded here. + +## System Monitor (issue #11) + +Every milestone so far was driven by measurements, heap floors, stack sizes, TLS dips, that needed a Debug Build and a computer. The System App shows them on the device, in any build. + +### Decisions (design round 2026-10-06) + +| # | Decision | +|---|---| +| Q117 | An App of its own, **System**, in release builds too. Read-only. | +| Q118 | Four views, switched with Tab: **Overview** (CPU per core, memory, network, battery), **Tasks**, **Memory**, **System**. | +| Q119 | Sampled once a second. A task's share is its run time over the last second; a core's load is 100 % minus its idle task's share. | +| Q120 | **History only while the App is open:** two minutes at one sample a second, about 1 KB. The system already keeps what matters afterwards: the lowest free heap since boot and each task's lowest free stack. | +| Q121 | **Bytes are counted per service:** IRC, Gemini, the Debug Console and Firmware Updates add what they read and write to a shared counter. The network view shows the connection details, each service's bytes in and out, and the signal strength. | +| Q122 | Tasks: name, core, share, state and lowest free stack, sorted by share; `s` cycles the sort (share, stack, name). **Under 512 bytes of stack left shows in the warning colour.** | +| Q123 | Memory: free heap, lowest since boot, largest free block, and a two-minute graph of free heap **with the floors of Q86 drawn as lines** (55, 40 and 20 KB). | +| Q124 | System: uptime and why it last started, firmware and both app slots, chip temperature and CPU frequency, battery voltage and percentage, SD usage and write faults, the radio's and the GNSS receiver's state. | +| Q125 | `info` and `tasks` are split into a **snapshot** that the console and the App share; the arithmetic (shares from two samples, sorting, the stack warning) is host-tested. | +| Q126 | Left out: acting on tasks, an event log, exporting snapshots to the card. | +| Q127 | The main loop uses about 81 % of a core. The App shows it; fixing it is issue #40, not part of #11. | + +The App has five views, not four: Q121's network view is one of its own (Overview, Tasks, Memory, Network, System). + +### Measured (2026-10-06) + +- **Traffic counters are exact.** A Gemini fetch of a 164,970-byte page counts 164,986 bytes in (the page and its 16-byte header line) and 42 out (the 40-character URL and CRLF). A 1,797,760-byte upload counts 1,798,123 in for the Debug Console, commands included. +- **The Memory view shows a TLS dip as it happens.** Starting IRC and a 165 KB Gemini fetch together: free heap falls from about 100 KB through the three floors to a low of 12.1 KB, then settles near 50 KB. That's the dip accepted in G1 (Q86). +- **A run-time counter only moves when its task is switched out.** FreeRTOS adds to a task's run time at the context switch. The main loop takes the samples, and with core 1 to itself it's never switched out: its counter said 2 % while the core's idle task had 0 %. So the task that samples gets what's left of its core. With that: **the main loop uses 100 % of core 1 at rest** (issue #40 said 81 %, an average since boot). +- **`tasks` on the console** sampled twice inside one command at first, a quarter second apart, and showed the loop at 1 %: it was asleep in the command's own wait. It now samples, lets the loop run for a second, and prints. +- **Low stack, flagged:** `IDLE0` (232 bytes left), `IDLE1` (328 to 352) and `spk_task` (256 to 264), all the framework's own tasks. +- **Cost:** 15.6 KB of flash for the App and the counters (1,742,723 bytes, release). Nothing while it's closed; about 2 KB of history and samples while it's open. diff --git a/lib/net/src/traffic.cpp b/lib/net/src/traffic.cpp new file mode 100644 index 0000000..cf3a02a --- /dev/null +++ b/lib/net/src/traffic.cpp @@ -0,0 +1,46 @@ +#include "traffic.h" + +#include +#include + +namespace roro::net { + +namespace { +constexpr size_t kUsers = static_cast(User::Count); +std::atomic in_[kUsers], out_[kUsers]; +} // namespace + +const char* userName(User user) { + switch (user) { + case User::Irc: return "IRC"; + case User::Gemini: return "Gemini"; + case User::DebugConsole: return "Debug Console"; + case User::Updates: return "Updates"; + default: return "?"; + } +} + +void received(User user, size_t bytes) { in_[static_cast(user)] += static_cast(bytes); } +void sent(User user, size_t bytes) { out_[static_cast(user)] += static_cast(bytes); } +Traffic traffic(User user) { return {in_[static_cast(user)], out_[static_cast(user)]}; } + +void resetTraffic() { + for (size_t i = 0; i < kUsers; i++) in_[i] = out_[i] = 0; +} + +uint32_t bytesPerSecond(uint32_t before, uint32_t now, uint32_t elapsedMs) { + if (!elapsedMs) return 0; + return static_cast(static_cast(now - before) * 1000 / elapsedMs); // wraps with the counter +} + +std::string formatTraffic(uint32_t bytes) { + char s[16]; + if (bytes < 1000) std::snprintf(s, sizeof s, "%u B", static_cast(bytes)); + else if (bytes < 10 * 1024) std::snprintf(s, sizeof s, "%.1f KB", bytes / 1024.0); + else if (bytes < 1000 * 1024) std::snprintf(s, sizeof s, "%u KB", static_cast(bytes / 1024)); + else if (bytes < 10u * 1024 * 1024) std::snprintf(s, sizeof s, "%.1f MB", bytes / 1048576.0); + else std::snprintf(s, sizeof s, "%u MB", static_cast(bytes / 1048576)); + return s; +} + +} // namespace roro::net diff --git a/lib/net/src/traffic.h b/lib/net/src/traffic.h new file mode 100644 index 0000000..d0aea63 --- /dev/null +++ b/lib/net/src/traffic.h @@ -0,0 +1,26 @@ +#pragma once + +#include +#include +#include + +namespace roro::net { + +// Bytes each network service has read and written since boot (S1, Q121), as the service sees +// them: for TLS connections that's the plain text, without the handshake or record overhead. +// Counted from the services' own tasks, read from the main loop. +enum class User : uint8_t { Irc, Gemini, DebugConsole, Updates, Count }; +const char* userName(User user); + +struct Traffic { + uint32_t in = 0, out = 0; +}; +void received(User user, size_t bytes); +void sent(User user, size_t bytes); +Traffic traffic(User user); +void resetTraffic(); // for tests + +uint32_t bytesPerSecond(uint32_t before, uint32_t now, uint32_t elapsedMs); +std::string formatTraffic(uint32_t bytes); // "999 B", "1.5 KB", "12 KB", "1.7 MB" + +} // namespace roro::net diff --git a/lib/system/src/task_stats.cpp b/lib/system/src/task_stats.cpp new file mode 100644 index 0000000..acf2945 --- /dev/null +++ b/lib/system/src/task_stats.cpp @@ -0,0 +1,72 @@ +#include "task_stats.h" + +#include +#include +#include + +namespace roro { + +std::vector taskRows(const std::vector& before, uint32_t totalBefore, + const std::vector& now, uint32_t totalNow) { + uint32_t elapsed = totalNow - totalBefore; // unsigned: right across one wrap + std::vector rows; + rows.reserve(now.size()); + for (const TaskSample& t : now) { + uint32_t ran = t.runtime; // a task that wasn't there before ran all of it since + for (const TaskSample& b : before) + if (b.id == t.id) { + ran = t.runtime - b.runtime; + break; + } + TaskRow r; + r.name = t.name; + r.core = t.core; + r.state = t.state; + r.priority = t.priority; + r.stackFree = t.stackFree; + r.permille = elapsed ? static_cast(std::min(1000, static_cast(ran) * 1000 / elapsed)) : 0; + r.lowStack = t.stackFree < kLowStackBytes; + r.idle = std::strncmp(t.name, "IDLE", 4) == 0; + rows.push_back(r); + } + // The task that took the sample is running, and FreeRTOS counts a task's time when it's + // switched out: with its core to itself it never was, and its counter hardly moved. Give it + // what's left of its core once the idle task and the other tasks pinned there are counted. + for (TaskRow& r : rows) { + if (r.state != 0 || r.idle || r.core < 0) continue; // 0: eRunning + int others = 0; + bool idleSeen = false; + for (const TaskRow& o : rows) { + if (&o == &r || o.core != r.core) continue; + others += o.permille; + idleSeen |= o.idle; + } + if (idleSeen && elapsed && 1000 - others > r.permille) r.permille = static_cast(std::max(0, 1000 - others)); + } + return rows; +} + +int coreLoad(const std::vector& rows, int core) { + for (const TaskRow& r : rows) + if (r.idle && r.core == core) return 100 - (r.permille + 5) / 10; + return -1; +} + +void sortTasks(std::vector& rows, TaskSort by) { + auto lower = [](const std::string& s) { + std::string l = s; + for (char& c : l) c = static_cast(std::tolower(static_cast(c))); + return l; + }; + std::stable_sort(rows.begin(), rows.end(), [&](const TaskRow& a, const TaskRow& b) { + switch (by) { + case TaskSort::Share: + if (a.idle != b.idle) return !a.idle; // idle tasks last + return a.permille > b.permille; + case TaskSort::Stack: return a.stackFree < b.stackFree; + default: return lower(a.name) < lower(b.name); + } + }); +} + +} // namespace roro diff --git a/lib/system/src/task_stats.h b/lib/system/src/task_stats.h new file mode 100644 index 0000000..cbec751 --- /dev/null +++ b/lib/system/src/task_stats.h @@ -0,0 +1,65 @@ +#pragma once + +#include +#include +#include +#include +#include + +namespace roro { + +// One task as FreeRTOS reports it at one moment. +struct TaskSample { + uint32_t id = 0; // unique per task: a new task with an old name has another + char name[17] = {}; + uint32_t runtime = 0; // microseconds on a CPU since it started; 32 bits, so it wraps every 71 minutes + uint16_t stackFree = 0; // the least it ever had left, bytes + int8_t core = -1; // -1: not pinned + uint8_t state = 0; // eTaskState + uint8_t priority = 0; +}; + +// What the System App and `tasks` show for a task (S1, Q119, Q122). +struct TaskRow { + std::string name; + int core = -1; + uint8_t state = 0, priority = 0; + uint16_t stackFree = 0; + uint16_t permille = 0; // share of one core over the interval, in tenths of a percent + bool lowStack = false; + bool idle = false; // a core's idle task: what's left over +}; + +constexpr uint16_t kLowStackBytes = 512; + +// Shares from two samples: each task's run time between them over the time that passed. The +// 32-bit counters may have wrapped once in between. The task that took the samples (the one +// running) gets what's left of its core: see the .cpp. +std::vector taskRows(const std::vector& before, uint32_t totalBefore, + const std::vector& now, uint32_t totalNow); + +// A core's load in percent: what its idle task didn't use. -1 without that task in the rows. +int coreLoad(const std::vector& rows, int core); + +enum class TaskSort : uint8_t { Share, Stack, Name }; +void sortTasks(std::vector& rows, TaskSort by); + +// The last N samples, oldest first (Q120). +template +class History { + public: + void push(T value) { + values_[(first_ + size_) % N] = value; + if (size_ < N) size_++; + else first_ = (first_ + 1) % N; + } + size_t size() const { return size_; } + T at(size_t i) const { return values_[(first_ + i) % N]; } // 0: the oldest kept + void clear() { first_ = size_ = 0; } + + private: + T values_[N] = {}; + size_t first_ = 0, size_ = 0; +}; + +} // namespace roro diff --git a/src/apps/system_app.cpp b/src/apps/system_app.cpp new file mode 100644 index 0000000..618357c --- /dev/null +++ b/src/apps/system_app.cpp @@ -0,0 +1,361 @@ +#include "system_app.h" + +#include +#include +#include + +#include +#include + +#include "cleanup_plan.h" +#include "platform/system_info.h" +#include "sd_fault.h" +#include "services/gemini_service.h" +#include "ui/canvas.h" +#include "ui/fonts.h" +#include "ui/theme.h" +#include "ui/widgets.h" + +namespace roro { + +namespace { + +constexpr size_t kUsers = static_cast(net::User::Count); + +// Collects what the console's `info` prints, so the System view can't drift from it (Q125). +class Lines : public Print { + public: + size_t write(uint8_t ch) override { + if (ch == '\n') { + lines.push_back(current_); + current_.clear(); + } else if (ch != '\r') { + current_ += static_cast(ch); + } + return 1; + } + std::vector lines; + + private: + std::string current_; +}; + +std::string duration(uint32_t seconds) { + char s[24]; + if (seconds < 3600) std::snprintf(s, sizeof s, "%lu min %02lu s", (unsigned long)(seconds / 60), (unsigned long)(seconds % 60)); + else std::snprintf(s, sizeof s, "%lu h %02lu min", (unsigned long)(seconds / 3600), (unsigned long)(seconds / 60 % 60)); + return s; +} + +// A filled bar for a percentage; the warning colour from 90 %. +void bar(Canvas& c, int x, int y, int w, int percent) { + c.drawRect(x, y, w, 9, theme::kMuted); + int filled = std::clamp(percent, 0, 100) * (w - 2) / 100; + if (filled > 0) c.fillRect(x + 1, y + 1, filled, 7, percent >= 90 ? theme::kWarning : theme::kAccent); +} + +} // namespace + +void SystemApp::onEnter() { + view_ = View::Overview; + beforeTotal_ = system_info::sampleTasks(before_); + sampledMs_ = millis(); + for (size_t i = 0; i < kUsers; i++) traffic_[i] = net::traffic(static_cast(i)); + requestRedraw(); +} + +void SystemApp::onExit() { // nothing is kept while it's closed (Q120) + std::vector().swap(before_); + std::vector().swap(rows_); + std::vector().swap(systemLines_); + for (auto& h : loadHistory_) h.clear(); + heapHistory_.clear(); + load_[0] = load_[1] = -1; +} + +bool SystemApp::onKey(const KeyEvent& e) { + if (e.key == Key::Tab) { + int n = static_cast(View::Count), v = static_cast(view_); + view_ = static_cast(e.shift ? (v + n - 1) % n : (v + 1) % n); + taskTop_ = systemTop_ = 0; + requestRedraw(); + return true; + } + int step = e.key == Key::Up ? -1 : e.key == Key::Down ? 1 : 0; + if (step && view_ == View::Tasks) { + taskTop_ = std::clamp(taskTop_ + step, 0, std::max(0, static_cast(rows_.size()) - kTaskRows)); + requestRedraw(); + return true; + } + if (step && view_ == View::System) { + systemTop_ = std::clamp(systemTop_ + step, 0, std::max(0, wrappedLines_ - 8)); + requestRedraw(); + return true; + } + if (view_ == View::Tasks && e.key == Key::Char && (e.ch == 's' || e.ch == 'S')) { // Q122 + sort_ = static_cast((static_cast(sort_) + 1) % 3); + sortTasks(rows_, sort_); + taskTop_ = 0; + requestRedraw(); + return true; + } + return false; // Back leaves the App +} + +void SystemApp::update(uint32_t nowMs) { + if (nowMs - sampledMs_ >= 1000) sample(nowMs); +} + +// Once a second (Q119): the tasks' shares over that second, the cores' load, the heap, the traffic. +void SystemApp::sample(uint32_t nowMs) { + uint32_t elapsedMs = nowMs - sampledMs_; + sampledMs_ = nowMs; + + std::vector now; + uint32_t total = system_info::sampleTasks(now); + rows_ = taskRows(before_, beforeTotal_, now, total); + sortTasks(rows_, sort_); + before_.swap(now); + beforeTotal_ = total; + for (int core = 0; core < 2; core++) { + load_[core] = coreLoad(rows_, core); + loadHistory_[core].push(static_cast(std::max(0, load_[core]))); + } + heapHistory_.push(static_cast(ESP.getFreeHeap() / 1024)); + + for (size_t i = 0; i < kUsers; i++) { + net::Traffic t = net::traffic(static_cast(i)); + rateIn_[i] = net::bytesPerSecond(traffic_[i].in, t.in, elapsedMs); + rateOut_[i] = net::bytesPerSecond(traffic_[i].out, t.out, elapsedMs); + traffic_[i] = t; + } + + if (view_ == View::System) { // the slow things: only while they're on screen + Lines out; + system_info::printSystem(out); + const BatteryEstimator& b = battery_.estimator(); + if (b.hasReading()) out.printf("battery: %d %%, %d.%02d V\n", b.percent(), b.millivolts() / 1000, b.millivolts() % 1000 / 10); + StorageState card = storage_.state(); + if (card.present) + out.printf("sd: %s of %s used, %u write faults\n", formatBytes(card.usedBytes).c_str(), formatBytes(card.totalBytes).c_str(), + (unsigned)sdLastFault().count); + else out.println("sd: no card"); + out.printf("radio: %s\n", !radio_.present() ? "none" : radio_.sweeping() ? "sweeping" : radio_.listening() ? "listening" : "asleep"); + const auto& g = gnss_.state(); + out.printf("gnss: %s, %d satellites used\n", !gnss_.on() ? "off" : gnss_.receiving(nowMs) ? "receiving" : "silent", g.satellitesUsed); + system_info::printSlots(out, store_); + systemLines_.swap(out.lines); + } + requestRedraw(); +} + +void SystemApp::footer(Canvas& c, const char* keys) { + const auto& area = theme::kContent; + c.setFont(&fonts::small); + c.setTextColor(theme::kMuted); + c.setTextDatum(top_left); + c.drawString(keys, 4, area.y + area.h - 9); +} + +void SystemApp::draw(Canvas& c) { + c.setTextDatum(top_left); + switch (view_) { + case View::Overview: drawOverview(c); break; + case View::Tasks: drawTasks(c); break; + case View::Memory: drawMemory(c); break; + case View::Network: drawNetwork(c); break; + case View::System: drawSystem(c); break; + default: break; + } +} + +void SystemApp::drawOverview(Canvas& c) { + const auto& area = theme::kContent; + char line[72]; + c.setFont(&fonts::body); + int y = area.y + 2; + for (int core = 0; core < 2; core++) { + c.setTextColor(theme::kMuted); + std::snprintf(line, sizeof line, "Core %d", core); + c.drawString(line, 4, y); + bar(c, 52, y + 2, 130, load_[core]); + c.setTextColor(theme::kText); + if (load_[core] >= 0) std::snprintf(line, sizeof line, "%d%%", load_[core]); + else std::snprintf(line, sizeof line, "..."); + c.drawString(line, 190, y); + y += theme::kLineHeight; + } + auto row = [&](const char* label, const std::string& value) { + c.setTextColor(theme::kMuted); + c.drawString(label, 4, y); + c.setTextColor(theme::kText); + c.drawString(value.c_str(), 62, y); + y += theme::kLineHeight; + }; + std::snprintf(line, sizeof line, "%u KB free, lowest %u", (unsigned)(ESP.getFreeHeap() / 1024), (unsigned)(ESP.getMinFreeHeap() / 1024)); + row("Memory", line); + uint32_t in = 0, out = 0; + for (size_t i = 0; i < kUsers; i++) in += rateIn_[i], out += rateOut_[i]; + if (wifi_.state() == WifiController::State::Connected) + std::snprintf(line, sizeof line, "%s/s in, %s/s out", net::formatTraffic(in).c_str(), net::formatTraffic(out).c_str()); + else std::snprintf(line, sizeof line, "not connected"); + row("Network", line); + const BatteryEstimator& b = battery_.estimator(); + if (b.hasReading()) std::snprintf(line, sizeof line, "%d%%, %d.%02d V", b.percent(), b.millivolts() / 1000, b.millivolts() % 1000 / 10); + else std::snprintf(line, sizeof line, "..."); + row("Battery", line); + std::snprintf(line, sizeof line, "%s, %.0f C", duration(millis() / 1000).c_str(), temperatureRead()); + row("Uptime", line); + + // Both cores over the last two minutes: core 0 in the accent colour, core 1 in green. + int gx = 4, gy = y + 3, gw = static_cast(kHistory) * 2 - 8, gh = area.y + area.h - 12 - gy; + if (gh > 8) { + c.drawRect(gx, gy, gw + 2, gh + 2, theme::kMuted); + for (int core = 0; core < 2; core++) { + const auto& h = loadHistory_[core]; + for (size_t i = 1; i < h.size(); i++) { + int x0 = gx + 1 + static_cast((i - 1) * gw / kHistory), x1 = gx + 1 + static_cast(i * gw / kHistory); + c.drawLine(x0, gy + gh - h.at(i - 1) * gh / 100, x1, gy + gh - h.at(i) * gh / 100, core ? theme::kMessage : theme::kAccent); + } + } + } + footer(c, "Tab: tasks, memory, network, system"); +} + +void SystemApp::drawTasks(Canvas& c) { + const auto& area = theme::kContent; + c.setFont(&fonts::small); + c.setTextColor(theme::kMuted); + c.drawString("task", 4, area.y + 2); + c.setTextDatum(top_right); + c.drawString("core", 128, area.y + 2); + c.drawString("cpu", 176, area.y + 2); + c.drawString("stack left", area.w - 4, area.y + 2); + c.setFont(&fonts::body); + char cell[16]; + for (int i = 0; i < kTaskRows && taskTop_ + i < static_cast(rows_.size()); i++) { + const TaskRow& r = rows_[taskTop_ + i]; + int y = area.y + 12 + i * theme::kLineHeight; + c.setTextDatum(top_left); + c.setTextColor(r.idle ? theme::kMuted : theme::kText); + c.drawString(r.name.c_str(), 4, y); + c.setTextDatum(top_right); + c.setTextColor(theme::kMuted); + c.drawString(r.core < 0 ? "any" : std::to_string(r.core).c_str(), 128, y); + c.setTextColor(r.idle ? theme::kMuted : theme::kText); + std::snprintf(cell, sizeof cell, "%u.%u%%", r.permille / 10, r.permille % 10); + c.drawString(cell, 176, y); + c.setTextColor(r.lowStack ? theme::kWarning : theme::kMuted); // Q122: under 512 bytes + c.drawString(std::to_string(r.stackFree).c_str(), area.w - 4, y); + } + c.setTextDatum(top_left); + std::string keys = std::string("s: by ") + (sort_ == TaskSort::Share ? "stack" : sort_ == TaskSort::Stack ? "name" : "cpu") + + " " + std::to_string(rows_.size()) + " tasks Tab: memory"; + footer(c, keys.c_str()); +} + +void SystemApp::drawMemory(Canvas& c) { + const auto& area = theme::kContent; + char line[72]; + c.setFont(&fonts::body); + c.setTextColor(theme::kText); + std::snprintf(line, sizeof line, "%.1f KB free, lowest %.1f", ESP.getFreeHeap() / 1024.0, ESP.getMinFreeHeap() / 1024.0); + c.drawString(line, 4, area.y + 2); + c.setTextColor(theme::kMuted); + std::snprintf(line, sizeof line, "largest free block %.1f KB", heap_caps_get_largest_free_block(MALLOC_CAP_8BIT) / 1024.0); + c.drawString(line, 4, area.y + 2 + theme::kLineHeight); + + // Free heap over two minutes, with the floors of Q86 as lines. + int gx = 26, gy = area.y + 32, gw = area.w - gx - 6, gh = area.y + area.h - 12 - gy; + uint16_t top = 128; // KB at the top of the scale: more if the heap has been higher + for (size_t i = 0; i < heapHistory_.size(); i++) top = std::max(top, heapHistory_.at(i) + 8); + auto yOf = [&](int kb) { return gy + gh - std::clamp(kb, 0, static_cast(top)) * gh / top; }; + c.drawRect(gx, gy, gw, gh + 1, theme::kMuted); + c.setFont(&fonts::small); + struct { + size_t bytes; + uint16_t color; + } floors[] = {{GeminiService::kStartFloor, theme::kMuted}, {GeminiService::kSteadyFloor, theme::kWarning}, {GeminiService::kTransientFloor, theme::kMessage}}; + for (auto& f : floors) { + int kb = static_cast(f.bytes / 1024), y = yOf(kb); + for (int x = gx + 1; x < gx + gw - 1; x += 4) c.drawPixel(x, y, f.color); + c.setTextColor(f.color); + c.setTextDatum(top_right); + c.drawString(std::to_string(kb).c_str(), gx - 3, y - 3); + } + c.setTextDatum(top_left); + for (size_t i = 1; i < heapHistory_.size(); i++) { + int x0 = gx + 1 + static_cast((i - 1) * (gw - 2) / kHistory), x1 = gx + 1 + static_cast(i * (gw - 2) / kHistory); + c.drawLine(x0, yOf(heapHistory_.at(i - 1)), x1, yOf(heapHistory_.at(i)), theme::kAccent); + } + footer(c, "KB free, 2 min, with the floors Tab: network"); +} + +void SystemApp::drawNetwork(Canvas& c) { + const auto& area = theme::kContent; + char line[72]; + c.setFont(&fonts::body); + WifiService::Connection n = wifi_.connection(); + c.setTextColor(n.connected ? theme::kText : theme::kWarning); + if (n.connected) std::snprintf(line, sizeof line, "%s, %d dBm", wifi_.ssid().c_str(), wifi_.rssi()); + else std::snprintf(line, sizeof line, "Wi-Fi isn't connected"); + c.drawString(line, 4, area.y + 2); + if (n.connected) { + c.setTextColor(theme::kMuted); + std::snprintf(line, sizeof line, "%s/%d %s, gw %s", n.address.c_str(), n.prefix, n.fixed ? "fixed" : "DHCP", + n.gateway.empty() ? "none" : n.gateway.c_str()); + c.drawString(line, 4, area.y + 2 + theme::kLineHeight); + } + // Per service (Q121): totals since boot, and the last second. + int y = area.y + 32; + c.setFont(&fonts::small); + c.setTextColor(theme::kMuted); + c.drawString("service", 4, y); + c.setTextDatum(top_right); + c.drawString("in", 124, y); + c.drawString("out", 168, y); + c.drawString("now, /s", area.w - 4, y); + c.setFont(&fonts::body); + y += 10; + for (size_t i = 0; i < kUsers; i++) { + bool active = rateIn_[i] || rateOut_[i]; + c.setTextDatum(top_left); + c.setTextColor(active ? theme::kMessage : theme::kText); + c.drawString(net::userName(static_cast(i)), 4, y); + c.setTextDatum(top_right); + c.setTextColor(theme::kText); + c.drawString(net::formatTraffic(traffic_[i].in).c_str(), 124, y); + c.drawString(net::formatTraffic(traffic_[i].out).c_str(), 168, y); + c.setTextColor(active ? theme::kMessage : theme::kMuted); + c.drawString(active ? net::formatTraffic(rateIn_[i] + rateOut_[i]).c_str() : "-", area.w - 4, y); + y += theme::kLineHeight; + } + c.setTextDatum(top_left); + footer(c, "bytes since boot Tab: system"); +} + +void SystemApp::drawSystem(Canvas& c) { + const auto& area = theme::kContent; + if (systemLines_.empty()) { + c.setFont(&fonts::body); + c.setTextColor(theme::kMuted); + c.drawString("Reading...", 4, area.y + 4); + return; + } + // The console's lines are longer than the screen: wrap them, continuation lines indented. + std::vector wrapped; + auto measure = widgets::bodyMeasure(c); + for (const std::string& line : systemLines_) { + bool first = true; + for (const std::string& part : wrapText(line, area.w - 14, measure)) { + wrapped.push_back(first ? part : " " + part); + first = false; + } + } + wrappedLines_ = static_cast(wrapped.size()); + systemTop_ = std::clamp(systemTop_, 0, std::max(0, wrappedLines_ - 8)); + widgets::textLines(c, wrapped, systemTop_, {area.x + 2, area.y + 2, area.w - 2, area.h - 12}); + footer(c, "Tab: overview"); +} + +} // namespace roro diff --git a/src/apps/system_app.h b/src/apps/system_app.h new file mode 100644 index 0000000..7fa1501 --- /dev/null +++ b/src/apps/system_app.h @@ -0,0 +1,67 @@ +#pragma once + +#include +#include + +#include "app.h" +#include "key_value_store.h" +#include "services/battery_service.h" +#include "services/gnss_service.h" +#include "services/radio_service.h" +#include "services/storage_service.h" +#include "services/wifi_service.h" +#include "task_stats.h" +#include "traffic.h" + +namespace roro { + +// The System App (docs/milestones/S1.md, Q117 to Q127): what the device is doing, live and +// read-only. Tab moves between Overview, Tasks, Memory, Network and System. It samples once a +// second and keeps two minutes of history, only while it's open (Q120). +class SystemApp : public App { + public: + SystemApp(WifiService& wifi, BatteryService& battery, StorageService& storage, RadioService& radio, GnssService& gnss, + KeyValueStore& store) + : wifi_(wifi), battery_(battery), storage_(storage), radio_(radio), gnss_(gnss), store_(store) {} + void onEnter() override; + void onExit() override; + bool onKey(const KeyEvent& e) override; + void update(uint32_t nowMs) override; + void draw(Canvas& c) override; + + private: + enum class View : uint8_t { Overview, Tasks, Memory, Network, System, Count }; + static constexpr size_t kHistory = 120; // seconds + static constexpr int kTaskRows = 7; + + void sample(uint32_t nowMs); + void drawOverview(Canvas& c); + void drawTasks(Canvas& c); + void drawMemory(Canvas& c); + void drawNetwork(Canvas& c); + void drawSystem(Canvas& c); + void footer(Canvas& c, const char* keys); + + WifiService& wifi_; + BatteryService& battery_; + StorageService& storage_; + RadioService& radio_; + GnssService& gnss_; + KeyValueStore& store_; + View view_ = View::Overview; + uint32_t sampledMs_ = 0; + std::vector before_; + uint32_t beforeTotal_ = 0; + std::vector rows_; // the last second, sorted + TaskSort sort_ = TaskSort::Share; + int taskTop_ = 0; + int load_[2] = {-1, -1}; + History loadHistory_[2]; + History heapHistory_; // free heap, KB + net::Traffic traffic_[static_cast(net::User::Count)]; + uint32_t rateIn_[static_cast(net::User::Count)] = {}, rateOut_[static_cast(net::User::Count)] = {}; + std::vector systemLines_; + int systemTop_ = 0, wrappedLines_ = 0; +}; + +} // namespace roro diff --git a/src/main.cpp b/src/main.cpp index 5ee043b..f367f80 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -14,11 +14,13 @@ #include "apps/launcher_app.h" #include "apps/lora_scanner_app.h" #include "apps/settings_app.h" +#include "apps/system_app.h" #include "apps/wifi_tools_app.h" #include "apps/setup_app.h" #include "event_bus.h" #include "file_receiver.h" #include "ipv4.h" +#include "traffic.h" #include "key_mapper.h" #include "platform/console.h" #include "platform/crash_report.h" @@ -195,6 +197,8 @@ void setup() { apps->registerApp({"gnss", "GNSS", false, new GnssApp(*gnssService, settings)}); apps->registerApp({"gemini", "Gemini", false, new GeminiApp(*geminiService)}); apps->registerApp({"lora", "LoRa Scanner", false, new LoraScannerApp(*radioService, *loraCapture, settings, *clockService)}); + apps->registerApp({"system", "System", false, + new SystemApp(*wifi, *battery, *storageService, *radioService, *gnssService, nvs)}); apps->registerApp({"settings", "Settings", false, new SettingsApp({settings, bus, *apps, *battery, *storageService, *clockService, *wifi, *savedNetworks, *update})}); apps->registerApp({"demo", "Widget demo", true, new DemoApp(bus)}); @@ -381,9 +385,21 @@ static void ipTrialStep() { } #endif +// `tasks`: the first sample, and when to take the second and print. +static std::vector tasksBefore; +static uint32_t tasksTotal = 0, tasksDueMs = 0; +static bool tasksPending = false; + +static void tasksStep() { + if (!tasksPending || static_cast(millis() - tasksDueMs) < 0) return; + tasksPending = false; + system_info::printTasks(console, tasksBefore, tasksTotal); + std::vector().swap(tasksBefore); +} + static const char* const kHelp = "info firmware, uptime, memory, Wi-Fi, app slots\n" - "tasks FreeRTOS tasks: state, priority, free stack, CPU\n" + "tasks FreeRTOS tasks over the next second: state, priority, free stack, CPU share\n" "net bytes each network service has read and written since boot\n" "reboot restart\n" "boot other restart into the other app slot (manual Rollback)\n" "log level <0-5> ESP-IDF log level (0 none ... 5 verbose)\n" @@ -415,7 +431,7 @@ static const char* const kHelp = // Commands that only touch what Safe Mode starts. static bool safeModeCommand(const String& line) { - return line == "help" || line == "info" || line == "tasks" || line == "reboot" || line == "boot other" || + return line == "help" || line == "info" || line == "tasks" || line == "net" || line == "reboot" || line == "boot other" || line.startsWith("log level ") || line.startsWith("crash") || line.startsWith("coredump") || line == "wifi status" || line.startsWith("wifi add "); } @@ -432,7 +448,18 @@ static void runCommand(String line) { console.printf("update: %s\n", update->onProbation() ? "on probation" : "confirmed"); system_info::printSlots(console, nvs); } - if (line == "tasks") system_info::printTasks(console); + if (line == "tasks") { // sampled now, printed a second later by tasksStep(): the loop must run in between + tasksTotal = system_info::sampleTasks(tasksBefore); + tasksDueMs = millis() + 1000; + tasksPending = true; + } + if (line == "net") { // bytes each service has read and written since boot (S1, Q121) + for (int i = 0; i < static_cast(net::User::Count); i++) { + net::Traffic t = net::traffic(static_cast(i)); + console.printf("net: %-14s in %10lu out %10lu\n", net::userName(static_cast(i)), (unsigned long)t.in, + (unsigned long)t.out); + } + } if (line == "reboot") { console.println("restarting"); delay(300); @@ -731,6 +758,7 @@ static void loopSafeMode() { uint32_t now = millis(); serialCommands(); remoteCommands(); + tasksStep(); services.tick(now); bus.dispatch(); noteStableOnce(now); @@ -762,6 +790,7 @@ void loop() { serialCommands(); remoteCommands(); + tasksStep(); #ifdef RORO_DEBUG ipTrialStep(); #endif diff --git a/src/platform/counted_client.h b/src/platform/counted_client.h new file mode 100644 index 0000000..43bbb93 --- /dev/null +++ b/src/platform/counted_client.h @@ -0,0 +1,40 @@ +#pragma once + +#include +#include + +#include "traffic.h" + +namespace roro { + +// A NetworkClient (or NetworkClientSecure) that adds what it reads and writes to its service's +// traffic counters (S1, Q121). Only the two buffer calls are overridden: the single-byte ones, +// print() and printf() all go through them, so every byte is counted once. +template +class Counted : public Base { + public: + explicit Counted(net::User user) : user_(user) {} + Counted(const Base& accepted, net::User user) : Base(accepted), user_(user) {} + + // Overriding the buffer calls hides the single-byte ones; these put them back. They end up in + // the buffer calls below, where the counting happens. + int read() override { return Base::read(); } + size_t write(uint8_t byte) override { return Base::write(byte); } + + size_t write(const uint8_t* buf, size_t size) override { + size_t n = Base::write(buf, size); + net::sent(user_, n); + return n; + } + + int read(uint8_t* buf, size_t size) override { + int n = Base::read(buf, size); + if (n > 0) net::received(user_, static_cast(n)); + return n; + } + + private: + net::User user_; +}; + +} // namespace roro diff --git a/src/platform/system_info.cpp b/src/platform/system_info.cpp index 8df4afc..8aea61d 100644 --- a/src/platform/system_info.cpp +++ b/src/platform/system_info.cpp @@ -7,6 +7,8 @@ #include #include +#include +#include #include #include @@ -89,20 +91,40 @@ void printSlots(Print& out, KeyValueStore& store) { } } -void printTasks(Print& out) { +uint32_t sampleTasks(std::vector& out) { UBaseType_t n = uxTaskGetNumberOfTasks(); std::vector tasks(n + 4); uint32_t total = 0; n = uxTaskGetSystemState(tasks.data(), tasks.size(), &total); - out.printf("%-16s %-4s %3s %6s %5s %s\n", "task", "st", "pri", "stack", "cpu%", "core"); - static const char kStates[] = "RrBSD"; // running, ready, blocked, suspended, deleted + out.clear(); + out.reserve(n); for (UBaseType_t i = 0; i < n; i++) { const TaskStatus_t& t = tasks[i]; - unsigned cpu = total ? (unsigned)((uint64_t)t.ulRunTimeCounter * 100 / total) : 0; - int core = t.xCoreID == tskNO_AFFINITY ? -1 : (int)t.xCoreID; - out.printf("%-16s %-4c %3u %6u %5u %d\n", t.pcTaskName, t.eCurrentState < 5 ? kStates[t.eCurrentState] : '?', - (unsigned)t.uxCurrentPriority, (unsigned)t.usStackHighWaterMark, cpu, core); + TaskSample s; + s.id = t.xTaskNumber; + std::snprintf(s.name, sizeof s.name, "%s", t.pcTaskName); + s.runtime = t.ulRunTimeCounter; + s.stackFree = static_cast(std::min(t.usStackHighWaterMark, 0xFFFF)); + s.core = t.xCoreID == tskNO_AFFINITY ? -1 : static_cast(t.xCoreID); + s.state = static_cast(t.eCurrentState); + s.priority = static_cast(t.uxCurrentPriority); + out.push_back(s); } + return total; +} + +// Shares over the interval since `before`, not since boot: the counters wrap every 71 minutes. +void printTasks(Print& out, const std::vector& before, uint32_t beforeTotal) { + std::vector now; + uint32_t t1 = sampleTasks(now); + std::vector rows = taskRows(before, beforeTotal, now, t1); + sortTasks(rows, TaskSort::Share); + out.printf("%-16s %-4s %3s %6s %6s %s\n", "task", "st", "pri", "stack", "cpu%", "core"); + static const char kStates[] = "RrBSD"; // running, ready, blocked, suspended, deleted + for (const TaskRow& r : rows) + out.printf("%-16s %-4c %3u %6u %4u.%u %d%s\n", r.name.c_str(), r.state < 5 ? kStates[r.state] : '?', r.priority, + r.stackFree, r.permille / 10, r.permille % 10, r.core, r.lowStack ? " low stack" : ""); + out.printf("load: core 0 %d %%, core 1 %d %%\n", coreLoad(rows, 0), coreLoad(rows, 1)); } const char* bootOtherSlot() { diff --git a/src/platform/system_info.h b/src/platform/system_info.h index 7c7d231..1dc0c24 100644 --- a/src/platform/system_info.h +++ b/src/platform/system_info.h @@ -3,7 +3,10 @@ #include #include +#include + #include "key_value_store.h" +#include "task_stats.h" namespace roro::system_info { @@ -20,7 +23,12 @@ void printSlots(Print& out, KeyValueStore& store); // Remembers which version the running slot holds (call at boot), or the slot an update just wrote. void recordSlotVersion(KeyValueStore& store, const esp_partition_t* slot, const char* version); // FreeRTOS tasks: state, priority, lowest free stack, CPU share since boot. -void printTasks(Print& out); +// The tasks' shares since `before` was sampled (with its run-time clock). The caller lets the main +// loop run in between: sampling twice inside one command would show the loop asleep. +void printTasks(Print& out, const std::vector& before, uint32_t beforeTotal); +// Every task as FreeRTOS reports it now; returns the run-time clock (microseconds, 32 bits), to +// pair with the samples. Two of these make the shares the System App and `tasks` show. +uint32_t sampleTasks(std::vector& out); // Boots the firmware in the other app slot if it holds a valid image (a manual Rollback). // Returns an error message; on success it restarts and doesn't return. diff --git a/src/services/debug_console.cpp b/src/services/debug_console.cpp index e2ebaca..0fa8e67 100644 --- a/src/services/debug_console.cpp +++ b/src/services/debug_console.cpp @@ -17,6 +17,7 @@ #include "file_receiver.h" #include "sha256.h" #include "platform/console.h" +#include "platform/counted_client.h" #include "sd_fault.h" #include "version.h" @@ -110,7 +111,7 @@ void DebugConsole::listen() { listening = false; } if (listening) { - NetworkClient client = server.accept(); + Counted client(server.accept(), net::User::DebugConsole); if (client) { client.setNoDelay(true); if (authenticate(client)) serve(client); diff --git a/src/services/gemini_service.cpp b/src/services/gemini_service.cpp index b1842e5..fe95d69 100644 --- a/src/services/gemini_service.cpp +++ b/src/services/gemini_service.cpp @@ -12,6 +12,7 @@ #include "gemtext.h" #include "platform/console.h" #include "sha256.h" +#include "platform/counted_client.h" #include "storage_paths.h" namespace roro { @@ -544,7 +545,7 @@ void GeminiService::fetchOne(const std::string& url, GeminiPage& page, bool load auto track = [this]() { lowest_ = std::min(lowest_, esp_get_free_heap_size()); }; size_t freeBefore = esp_get_free_heap_size(); // what's left once the connection closes again - NetworkClientSecure tls; + Counted tls(net::User::Gemini); tls.setInsecure(); // trust on first use: the pinned fingerprint is what counts (Q71) tls.setTimeout(15); if (!tls.connect(u.host.c_str(), u.portOrDefault())) { diff --git a/src/services/irc_service.h b/src/services/irc_service.h index 733f650..690c958 100644 --- a/src/services/irc_service.h +++ b/src/services/irc_service.h @@ -1,6 +1,7 @@ #pragma once #include +#include "platform/counted_client.h" #include #include @@ -75,8 +76,8 @@ class IrcService : public Service { std::unique_ptr session_; SemaphoreHandle_t lock_ = nullptr; TaskHandle_t task_ = nullptr; - NetworkClientSecure tlsClient_; - NetworkClient plainClient_; + Counted tlsClient_{net::User::Irc}; // counted for the System App (S1, Q121) + Counted plainClient_{net::User::Irc}; NetworkClient* conn_ = &tlsClient_; // whichever the config asks for ReconnectPolicy backoff_; std::string partial_; diff --git a/src/services/update_service.cpp b/src/services/update_service.cpp index f6be3ba..9a2f209 100644 --- a/src/services/update_service.cpp +++ b/src/services/update_service.cpp @@ -1,4 +1,5 @@ #include "update_service.h" +#include "platform/counted_client.h" #include #include @@ -208,7 +209,7 @@ void UpdateService::listen() { } } if (listening && phase_ == Phase::Idle) { - NetworkClient client = server.accept(); + Counted client(server.accept(), net::User::Updates); if (client) { client.setNoDelay(true); NetSource src(client); diff --git a/test/test_task_stats/test_task_stats.cpp b/test/test_task_stats/test_task_stats.cpp new file mode 100644 index 0000000..6877f35 --- /dev/null +++ b/test/test_task_stats/test_task_stats.cpp @@ -0,0 +1,160 @@ +#include + +#include + +#include "task_stats.h" + +using namespace roro; + +void setUp() {} +void tearDown() {} + +static TaskSample task(uint32_t id, const char* name, uint32_t runtime, uint16_t stackFree = 2000, int core = 1) { + TaskSample t; + t.id = id; + std::snprintf(t.name, sizeof t.name, "%s", name); + t.runtime = runtime; + t.stackFree = stackFree; + t.core = static_cast(core); + t.state = 2; // blocked, unless a test says it's the one running + return t; +} + +static const TaskRow* find(const std::vector& rows, const char* name) { + for (auto& r : rows) + if (r.name == name) return &r; + return nullptr; +} + +// Q119: a task's share is its run time over the interval between two samples, in tenths of a percent. +void test_shares_over_the_interval() { + std::vector before = {task(1, "loopTask", 5000000), task(2, "IDLE1", 1000000), task(3, "IDLE0", 4000000, 240, 0), + task(4, "wifi", 900000, 4000, 0)}; + std::vector now = {task(1, "loopTask", 5810000), task(2, "IDLE1", 1170000), task(3, "IDLE0", 4780000, 240, 0), + task(4, "wifi", 1090000, 4000, 0)}; + auto rows = taskRows(before, 10000000, now, 11000000); // one second later + TEST_ASSERT_EQUAL_size_t(4, rows.size()); + TEST_ASSERT_EQUAL_UINT16(810, find(rows, "loopTask")->permille); + TEST_ASSERT_EQUAL_UINT16(170, find(rows, "IDLE1")->permille); + TEST_ASSERT_EQUAL_UINT16(780, find(rows, "IDLE0")->permille); + TEST_ASSERT_EQUAL_UINT16(190, find(rows, "wifi")->permille); + // A core's load is what its idle task didn't use. + TEST_ASSERT_EQUAL_INT(22, coreLoad(rows, 0)); + TEST_ASSERT_EQUAL_INT(83, coreLoad(rows, 1)); + TEST_ASSERT_EQUAL_INT(-1, coreLoad(rows, 2)); +} + +// FreeRTOS adds to a task's run time when it's switched out. The task doing the sampling is +// running: if nothing else wanted its core, it was never switched out and its counter hardly +// moved. Its real share is what's left of its core. +void test_the_running_task_gets_what_is_left_of_its_core() { + auto running = [](TaskSample t) { + t.state = 0; // eRunning + return t; + }; + std::vector before = {running(task(1, "loopTask", 5000000)), task(2, "IDLE1", 1000000), task(3, "radio", 100), + task(4, "IDLE0", 4000000, 240, 0), task(5, "wifi", 900000, 4000, 0)}; + std::vector now = {running(task(1, "loopTask", 5020000)), task(2, "IDLE1", 1000000), task(3, "radio", 30100), + task(4, "IDLE0", 4980000, 240, 0), task(5, "wifi", 910000, 4000, 0)}; + auto rows = taskRows(before, 0, now, 1000000); + TEST_ASSERT_EQUAL_UINT16(970, find(rows, "loopTask")->permille); // not the 2 % its counter says + TEST_ASSERT_EQUAL_UINT16(30, find(rows, "radio")->permille); + TEST_ASSERT_EQUAL_UINT16(10, find(rows, "wifi")->permille); // another core: untouched + TEST_ASSERT_EQUAL_INT(100, coreLoad(rows, 1)); + TEST_ASSERT_EQUAL_INT(2, coreLoad(rows, 0)); +} + +// When its counter did keep up (it was switched out often), nothing is added. +void test_the_running_task_keeps_its_own_count_when_it_is_higher() { + std::vector before = {task(1, "loopTask", 0), task(2, "IDLE1", 0)}; + std::vector now = {task(1, "loopTask", 600000), task(2, "IDLE1", 400000)}; + now[0].state = before[0].state = 0; + auto rows = taskRows(before, 0, now, 1000000); + TEST_ASSERT_EQUAL_UINT16(600, find(rows, "loopTask")->permille); +} + +// The counters are 32-bit microseconds: they wrap every 71 minutes. +void test_counters_wrap() { + std::vector before = {task(1, "loopTask", 0xFFFFF000u)}; + std::vector now = {task(1, "loopTask", 0x0007A120u - 0x1000u)}; // 500 ms of run time later + auto rows = taskRows(before, 0xFFFF0000u, now, 0xFFFF0000u + 1000000u); + TEST_ASSERT_EQUAL_UINT16(500, rows[0].permille); +} + +void test_tasks_come_and_go() { + std::vector before = {task(1, "loopTask", 100), task(7, "gemini", 50000)}; + std::vector now = {task(1, "loopTask", 400100), task(9, "gemini", 30000)}; // a new gemini task: another id + auto rows = taskRows(before, 0, now, 1000000); + TEST_ASSERT_EQUAL_size_t(2, rows.size()); + TEST_ASSERT_EQUAL_UINT16(400, find(rows, "loopTask")->permille); + TEST_ASSERT_EQUAL_UINT16(30, find(rows, "gemini")->permille); // all its run time is inside the interval +} + +void test_no_time_passed() { + std::vector one = {task(1, "loopTask", 100)}; + auto rows = taskRows(one, 500, one, 500); + TEST_ASSERT_EQUAL_UINT16(0, rows[0].permille); + TEST_ASSERT_EQUAL_INT(-1, coreLoad(rows, 1)); // no idle task in the sample +} + +// Q122: under 512 bytes of stack left is flagged. +void test_low_stack() { + std::vector s = {task(1, "spk_task", 0, 264), task(2, "IDLE0", 0, 240, 0), task(3, "radio", 0, 2360), + task(4, "edge", 0, 512)}; + auto rows = taskRows(s, 0, s, 1000); + TEST_ASSERT_TRUE(find(rows, "spk_task")->lowStack); + TEST_ASSERT_TRUE(find(rows, "IDLE0")->lowStack); + TEST_ASSERT_FALSE(find(rows, "radio")->lowStack); + TEST_ASSERT_FALSE(find(rows, "edge")->lowStack); +} + +void test_sorting() { + std::vector before = {task(1, "wifi", 0, 4000), task(2, "loopTask", 0, 2800), task(3, "IDLE0", 0, 240), + task(4, "irc", 0, 3600)}; + std::vector now = {task(1, "wifi", 190000, 4000), task(2, "loopTask", 810000, 2800), task(3, "IDLE0", 780000, 240), + task(4, "irc", 0, 3600)}; + auto rows = taskRows(before, 0, now, 1000000); + sortTasks(rows, TaskSort::Share); // busiest first, idle tasks last: they're what's left over + TEST_ASSERT_EQUAL_STRING("loopTask", rows[0].name.c_str()); + TEST_ASSERT_EQUAL_STRING("wifi", rows[1].name.c_str()); + TEST_ASSERT_EQUAL_STRING("irc", rows[2].name.c_str()); + TEST_ASSERT_EQUAL_STRING("IDLE0", rows[3].name.c_str()); + sortTasks(rows, TaskSort::Stack); // least stack left first + TEST_ASSERT_EQUAL_STRING("IDLE0", rows[0].name.c_str()); + TEST_ASSERT_EQUAL_STRING("loopTask", rows[1].name.c_str()); + sortTasks(rows, TaskSort::Name); // letters only, whatever the case + TEST_ASSERT_EQUAL_STRING("IDLE0", rows[0].name.c_str()); + TEST_ASSERT_EQUAL_STRING("irc", rows[1].name.c_str()); + TEST_ASSERT_EQUAL_STRING("loopTask", rows[2].name.c_str()); + TEST_ASSERT_EQUAL_STRING("wifi", rows[3].name.c_str()); +} + +// Q120: two minutes of history, the oldest sample dropped first. +void test_history() { + History h; + TEST_ASSERT_EQUAL_size_t(0, h.size()); + for (uint8_t v : {10, 20, 30}) h.push(v); + TEST_ASSERT_EQUAL_size_t(3, h.size()); + TEST_ASSERT_EQUAL_UINT8(10, h.at(0)); + TEST_ASSERT_EQUAL_UINT8(30, h.at(2)); + for (uint8_t v : {40, 50, 60}) h.push(v); + TEST_ASSERT_EQUAL_size_t(4, h.size()); + TEST_ASSERT_EQUAL_UINT8(30, h.at(0)); // oldest kept + TEST_ASSERT_EQUAL_UINT8(60, h.at(3)); // newest + h.clear(); + TEST_ASSERT_EQUAL_size_t(0, h.size()); +} + +int main() { + UNITY_BEGIN(); + RUN_TEST(test_shares_over_the_interval); + RUN_TEST(test_the_running_task_gets_what_is_left_of_its_core); + RUN_TEST(test_the_running_task_keeps_its_own_count_when_it_is_higher); + RUN_TEST(test_counters_wrap); + RUN_TEST(test_tasks_come_and_go); + RUN_TEST(test_no_time_passed); + RUN_TEST(test_low_stack); + RUN_TEST(test_sorting); + RUN_TEST(test_history); + return UNITY_END(); +} diff --git a/test/test_traffic/test_traffic.cpp b/test/test_traffic/test_traffic.cpp new file mode 100644 index 0000000..fcd24b0 --- /dev/null +++ b/test/test_traffic/test_traffic.cpp @@ -0,0 +1,54 @@ +#include + +#include "traffic.h" + +using namespace roro::net; + +void setUp() { resetTraffic(); } +void tearDown() {} + +void test_counts_per_service() { + received(User::Irc, 100); + received(User::Irc, 20); + sent(User::Irc, 7); + sent(User::Gemini, 40); + TEST_ASSERT_EQUAL_UINT32(120, traffic(User::Irc).in); + TEST_ASSERT_EQUAL_UINT32(7, traffic(User::Irc).out); + TEST_ASSERT_EQUAL_UINT32(0, traffic(User::Gemini).in); + TEST_ASSERT_EQUAL_UINT32(40, traffic(User::Gemini).out); + TEST_ASSERT_EQUAL_UINT32(0, traffic(User::Updates).in); +} + +void test_names() { + TEST_ASSERT_EQUAL_STRING("IRC", userName(User::Irc)); + TEST_ASSERT_EQUAL_STRING("Gemini", userName(User::Gemini)); + TEST_ASSERT_EQUAL_STRING("Debug Console", userName(User::DebugConsole)); + TEST_ASSERT_EQUAL_STRING("Updates", userName(User::Updates)); +} + +// Bytes a second between two readings; the counter wraps at 4 GB like any uint32. +void test_rate() { + TEST_ASSERT_EQUAL_UINT32(1000, bytesPerSecond(5000, 6000, 1000)); + TEST_ASSERT_EQUAL_UINT32(500, bytesPerSecond(0, 1000, 2000)); + TEST_ASSERT_EQUAL_UINT32(0, bytesPerSecond(7, 7, 1000)); + TEST_ASSERT_EQUAL_UINT32(20, bytesPerSecond(0xFFFFFFF6u, 10, 1000)); + TEST_ASSERT_EQUAL_UINT32(0, bytesPerSecond(1, 2, 0)); +} + +void test_sizes_for_humans() { + TEST_ASSERT_EQUAL_STRING("0 B", formatTraffic(0).c_str()); + TEST_ASSERT_EQUAL_STRING("999 B", formatTraffic(999).c_str()); + TEST_ASSERT_EQUAL_STRING("1.5 KB", formatTraffic(1536).c_str()); + TEST_ASSERT_EQUAL_STRING("12 KB", formatTraffic(12 * 1024 + 100).c_str()); + TEST_ASSERT_EQUAL_STRING("1.7 MB", formatTraffic(1774688).c_str()); + TEST_ASSERT_EQUAL_STRING("48 MB", formatTraffic(48u * 1024 * 1024).c_str()); +} + +int main() { + UNITY_BEGIN(); + RUN_TEST(test_counts_per_service); + RUN_TEST(test_names); + RUN_TEST(test_rate); + RUN_TEST(test_sizes_for_humans); + return UNITY_END(); +}