feat(fs5.5): extend zigos benchmark stress lane

Author: adybag14-cyber

README.md

@@ -82,6 +82,8 @@ ZAR-Zig-Agent-Runtime is the Zig runtime port of OpenClaw, with parity-first del
       - `protocol.tcp_handshake_payload`
       - `runtime.state_queue_cycle`
       - `tool_service.codec_parse`
+      - `filesystem.persistence_cycle`
+      - `filesystem.overlay_read_cycle`
     - third delivered adoption slice is a ZAR-native read-only introspection overlay inspired by ZigOS `procfs` / `sysfs`:
       - `src/baremetal/virtual_fs.zig` now exposes synthetic `/proc` and `/sys` trees over existing ZAR runtime, storage, display, and network state
       - `src/baremetal/filesystem.zig` now routes `GET` / `LIST` / `STAT` requests through that overlay while rejecting writes under `/proc` and `/sys`

docs/zig-port/FS5_5_HARDWARE_DRIVERS_SYSTEMS.md

@@ -52,7 +52,7 @@ Delivered first adoption slice:
 Delivered second adoption slice:
 
 - hosted benchmark and stress lane informed by ZigOS benchmark coverage
-- `src/benchmark_suite.zig` now provides ZAR-native benchmark cases for DNS, DHCP, TCP, runtime-state queue churn, and tool-service codec parsing
+- `src/benchmark_suite.zig` now provides ZAR-native benchmark cases for DNS, DHCP, TCP, runtime-state queue churn, tool-service codec parsing, filesystem persistence churn, and virtual overlay read churn
 - `src/benchmark_main.zig` now exposes `zig build bench` with deterministic `BENCH:START` / `BENCH:CASE` / `BENCH:END` output
 - `scripts/benchmark-smoke-check.ps1` now provides the strict hosted smoke gate for the benchmark lane
 - CI and release preview now run the benchmark smoke lane without regressing the normal hosted/bare-metal matrix

docs/zig-port/PHASE_CHECKLIST.md

@@ -17,7 +17,7 @@ Registry status:
 - first delivered adoption slice is clean-room `E1000` protocol reuse through `ARP` / `IPv4` / `UDP` / bounded `TCP`, not direct VFS/userspace import.
 - the clean-room `E1000` slice now ships `src/baremetal/e1000.zig`, `src/baremetal/pci.zig` discovery + decode enablement, `src/pal/net.zig` backend selection across `RTL8139` + `E1000`, host regressions for init/MAC/TX/RX/export state plus `ARP` / `IPv4` / `UDP` / `DHCP` / `DNS` / bounded `TCP`, and the live QEMU proofs `scripts/baremetal-qemu-e1000-probe-check.ps1`, `scripts/baremetal-qemu-e1000-arp-probe-check.ps1`, `scripts/baremetal-qemu-e1000-ipv4-probe-check.ps1`, `scripts/baremetal-qemu-e1000-udp-probe-check.ps1`, `scripts/baremetal-qemu-e1000-dhcp-probe-check.ps1`, `scripts/baremetal-qemu-e1000-dns-probe-check.ps1`, and `scripts/baremetal-qemu-e1000-tcp-probe-check.ps1` on top of `scripts/qemu-e1000-dgram-echo.ps1`.
 - bounded framed tool-service reuse is now closed over `E1000` through `scripts/baremetal-qemu-e1000-tool-service-probe-check.ps1`, and bounded `HTTP` / `HTTPS` transport reuse remains closed through `scripts/baremetal-qemu-e1000-http-post-probe-check.ps1` and `scripts/baremetal-qemu-e1000-https-post-probe-check.ps1`.
-- second delivered adoption slice is the hosted benchmark lane through `src/benchmark_suite.zig`, `src/benchmark_main.zig`, and `scripts/benchmark-smoke-check.ps1`, with the current catalog covering DNS, DHCP, TCP, runtime-state queue churn, and tool-service codec parsing.
+- second delivered adoption slice is the hosted benchmark lane through `src/benchmark_suite.zig`, `src/benchmark_main.zig`, and `scripts/benchmark-smoke-check.ps1`, with the current catalog covering DNS, DHCP, TCP, runtime-state queue churn, tool-service codec parsing, filesystem persistence churn, and virtual overlay read churn.
 - third delivered adoption slice is a ZAR-native read-only introspection overlay through `src/baremetal/virtual_fs.zig` and `src/baremetal/filesystem.zig`, with `/proc` + `/sys` exported over existing runtime/storage/display/network state, host regressions for `GET` / `LIST` / `STAT` plus write rejection, and live `E1000` tool-service proof through `scripts/baremetal-qemu-e1000-tool-service-probe-check.ps1`.
 - fourth delivered adoption slice is a ZAR-native read-only device overlay through `src/baremetal/virtual_fs.zig` and `src/baremetal/filesystem.zig`, with `/dev` exported over existing storage/display/network device state, host regressions for `GET` / `LIST` / `STAT` plus write rejection, and live `E1000` tool-service proof through `scripts/baremetal-qemu-e1000-tool-service-probe-check.ps1`.
 - `FS5.5` framebuffer/console strict closure is now reached locally: `src/baremetal/framebuffer_console.zig` programs a real Bochs/QEMU BGA linear-framebuffer path with bounded mode support for `640x400`, `800x600`, `1024x768`, `1280x720`, and `1280x1024`, `src/baremetal/pci.zig` discovers the selected PCI display adapter as structured metadata, exposes the framebuffer BAR, and enables decode on that function, `src/baremetal/edid.zig`, `src/baremetal/display_output.zig`, and `src/baremetal/virtio_gpu.zig` now add the first real EDID-backed controller path over `virtio-gpu-pci` including exported capability flags for digital input, preferred timing, CEA, DisplayID, HDMI-vendor-data, and basic-audio metadata when present plus EDID-derived connector inference, bounded per-output entry export, and bounded resource-create/attach/set-scanout/flush behavior, `src/pal/framebuffer.zig` exposes the surface plus supported-mode enumeration and display-output state through the PAL, host regressions in `src/baremetal/framebuffer_console.zig`, `src/baremetal/virtio_gpu.zig`, `src/baremetal_main.zig`, and `src/baremetal/display_output.zig` prove framebuffer state, display-output state, adapter metadata, supported-mode enumeration, glyph pixel updates, bounded mode switching, present counters, non-zero scanout pixels, connector inference from EDID capability flags, and the output-entry table, and the live QEMU+GDB proofs `scripts/baremetal-qemu-framebuffer-console-probe-check.ps1` and `scripts/baremetal-qemu-virtio-gpu-display-probe-check.ps1` now read back real MMIO banner pixels plus BGA adapter metadata and real `virtio-gpu-pci` EDID/controller capability state with non-zero scanout pixels and validated output-entry metadata over the freestanding PVH artifact; real HDMI/DisplayPort connector-specific scanout paths remain future depth and are not claimed here.

docs/zig-port/PORT_PLAN.md

@@ -23,7 +23,7 @@ Full-stack replacement execution reference:
   - `src/pal/net.zig` now routes the same raw-frame PAL seam through selectable `RTL8139` and `E1000` backends without regressing the existing RTL8139 path
   - `scripts/baremetal-qemu-e1000-arp-probe-check.ps1`, `scripts/baremetal-qemu-e1000-ipv4-probe-check.ps1`, `scripts/baremetal-qemu-e1000-udp-probe-check.ps1`, `scripts/baremetal-qemu-e1000-dhcp-probe-check.ps1`, `scripts/baremetal-qemu-e1000-dns-probe-check.ps1`, and `scripts/baremetal-qemu-e1000-tcp-probe-check.ps1` now prove live QEMU `E1000` ARP request transmission, IPv4 frame encode/decode, UDP datagram encode/decode, DHCP discover encode/decode, DNS query/response exchange, bounded TCP handshake/payload/teardown, and TX/RX counter advance over the freestanding PVH artifact
   - bounded framed tool-service reuse is now closed over `E1000` through `scripts/baremetal-qemu-e1000-tool-service-probe-check.ps1`, and bounded `HTTP` / `HTTPS` transport reuse remains closed through host regressions plus `scripts/baremetal-qemu-e1000-http-post-probe-check.ps1` and `scripts/baremetal-qemu-e1000-https-post-probe-check.ps1`
-  - second delivered adoption slice is the hosted benchmark lane through `src/benchmark_suite.zig`, `src/benchmark_main.zig`, and `scripts/benchmark-smoke-check.ps1`
+  - second delivered adoption slice is the hosted benchmark lane through `src/benchmark_suite.zig`, `src/benchmark_main.zig`, and `scripts/benchmark-smoke-check.ps1`, with the current catalog covering DNS, DHCP, TCP, runtime-state queue churn, tool-service codec parsing, filesystem persistence churn, and virtual overlay read churn
   - third delivered adoption slice is a ZAR-native read-only introspection overlay through `src/baremetal/virtual_fs.zig` and `src/baremetal/filesystem.zig`, exposing `/proc` + `/sys` over the existing runtime/storage/display/network state, reusing the existing builtin and typed `GET` / `LIST` / `STAT` tool-service surface, and proving the same overlay live over `scripts/baremetal-qemu-e1000-tool-service-probe-check.ps1`
   - fourth delivered adoption slice is a ZAR-native read-only device overlay through `src/baremetal/virtual_fs.zig` and `src/baremetal/filesystem.zig`, exposing `/dev` over the existing storage/display/network device state, reusing the existing builtin and typed `GET` / `LIST` / `STAT` tool-service surface, and proving the same overlay live over `scripts/baremetal-qemu-e1000-tool-service-probe-check.ps1`
 - `FS5.5` hardware-driver pivot update:

docs/zig-port/ZAR_VS_ZIGOS_BENCHMARK_SLICE_PLAN.md

@@ -38,6 +38,8 @@ Delivered benchmark cases:
 - `protocol.tcp_handshake_payload`
 - `runtime.state_queue_cycle`
 - `tool_service.codec_parse`
+- `filesystem.persistence_cycle`
+- `filesystem.overlay_read_cycle`
 
 Delivered output contract:
 
@@ -73,7 +75,11 @@ Required for closure:
 Natural next benchmark expansions:
 
 - allocator pressure benchmark lane
-- filesystem persistence throughput lane
 - NIC-path transport throughput comparisons (`RTL8139` vs `E1000`)
 - display mode-switch/present timing lane
 - future SMP stress once that track is expanded
+
+Recently delivered follow-on depth:
+
+- filesystem persistence throughput lane through `filesystem.persistence_cycle`
+- virtual overlay read churn through `filesystem.overlay_read_cycle`

src/benchmark_suite.zig

@@ -3,6 +3,7 @@ const std = @import("std");
 const dhcp = @import("protocol/dhcp.zig");
 const dns = @import("protocol/dns.zig");
 const tcp = @import("protocol/tcp.zig");
+const filesystem = @import("baremetal/filesystem.zig");
 const runtime_state = @import("runtime/state.zig");
 const codec = @import("baremetal/tool_service/codec.zig");
 
@@ -56,6 +57,18 @@ pub const all_cases = [_]Case{
         .batch_iterations = 1024,
         .runFn = benchToolServiceCodecParse,
     },
+    .{
+        .name = "filesystem.persistence_cycle",
+        .description = "Bare-metal filesystem create/write/read/stat/delete churn on the active backend",
+        .batch_iterations = 96,
+        .runFn = benchFilesystemPersistenceCycle,
+    },
+    .{
+        .name = "filesystem.overlay_read_cycle",
+        .description = "Virtual /proc,/sys,/dev overlay list/read churn through the filesystem surface",
+        .batch_iterations = 128,
+        .runFn = benchFilesystemOverlayReadCycle,
+    },
 };
 
 pub fn list(writer: anytype) !void {
@@ -307,11 +320,77 @@ fn benchToolServiceCodecParse(iterations: usize) !u64 {
     return checksum;
 }
 
+fn benchFilesystemPersistenceCycle(iterations: usize) !u64 {
+    filesystem.resetForTest();
+    try filesystem.init();
+
+    var checksum: u64 = 0;
+    var dir_buffer: [64]u8 = undefined;
+    var file_buffer: [96]u8 = undefined;
+    var payload_buffer: [64]u8 = undefined;
+
+    for (0..iterations) |idx| {
+        const tick: u64 = @intCast(idx + 1);
+        const dir = try std.fmt.bufPrint(&dir_buffer, "/bench/{d}", .{idx % 16});
+        const file = try std.fmt.bufPrint(&file_buffer, "{s}/state.txt", .{dir});
+        const payload = try std.fmt.bufPrint(&payload_buffer, "bench-payload-{d}", .{idx});
+
+        try filesystem.createDirPath(dir);
+        try filesystem.writeFile(file, payload, tick);
+
+        const stat = try filesystem.statSummary(file);
+        const listing = try filesystem.listDirectoryAlloc(std.heap.page_allocator, dir, 256);
+        defer std.heap.page_allocator.free(listing);
+        const readback = try filesystem.readFileAlloc(std.heap.page_allocator, file, 256);
+        defer std.heap.page_allocator.free(readback);
+
+        checksum +%= stat.size;
+        checksum +%= listing.len;
+        checksum +%= readback.len;
+        checksum +%= stat.entry_id;
+        checksum +%= tick;
+
+        try filesystem.deleteFile(file, tick + 1);
+        try filesystem.deleteTree(dir, tick + 2);
+    }
+
+    return checksum;
+}
+
+fn benchFilesystemOverlayReadCycle(iterations: usize) !u64 {
+    filesystem.resetForTest();
+    try filesystem.init();
+
+    var checksum: u64 = 0;
+    for (0..iterations) |_| {
+        const root_listing = try filesystem.listDirectoryAlloc(std.heap.page_allocator, "/", 256);
+        defer std.heap.page_allocator.free(root_listing);
+        const dev_listing = try filesystem.listDirectoryAlloc(std.heap.page_allocator, "/dev", 256);
+        defer std.heap.page_allocator.free(dev_listing);
+        const dev_storage = try filesystem.readFileAlloc(std.heap.page_allocator, "/dev/storage/state", 512);
+        defer std.heap.page_allocator.free(dev_storage);
+        const proc_runtime = try filesystem.readFileAlloc(std.heap.page_allocator, "/proc/runtime/snapshot", 1024);
+        defer std.heap.page_allocator.free(proc_runtime);
+        const sys_storage = try filesystem.readFileAlloc(std.heap.page_allocator, "/sys/storage/state", 512);
+        defer std.heap.page_allocator.free(sys_storage);
+
+        checksum +%= root_listing.len;
+        checksum +%= dev_listing.len;
+        checksum +%= dev_storage.len;
+        checksum +%= proc_runtime.len;
+        checksum +%= sys_storage.len;
+    }
+
+    return checksum;
+}
+
 test "benchmark catalog includes expected protocol and runtime cases" {
     try std.testing.expect(findCase("protocol.dns_roundtrip") != null);
     try std.testing.expect(findCase("protocol.tcp_handshake_payload") != null);
     try std.testing.expect(findCase("runtime.state_queue_cycle") != null);
     try std.testing.expect(findCase("tool_service.codec_parse") != null);
+    try std.testing.expect(findCase("filesystem.persistence_cycle") != null);
+    try std.testing.expect(findCase("filesystem.overlay_read_cycle") != null);
 }
 
 test "benchmark suite writes markers for filtered run" {