Skip to content

feat(arty): integrate demand-driven runtime diagnostics - #960

Open
Ralf Biedert (ralfbiedert) wants to merge 19 commits into
mainfrom
ralfbiedert-arty-runtime-collection
Open

Ralf Biedert (ralfbiedert) wants to merge 19 commits into
mainfrom
ralfbiedert-arty-runtime-collection

Conversation

@ralfbiedert

@ralfbiedert Ralf Biedert (ralfbiedert) commented Nov 9, 2026 •

Copy link
Copy Markdown
Collaborator

🤖

Why

Arty needs to expose its live tasks through Seismograph without tracking every poll when nobody collects or records diagnostics.

Approach

  • Register runtimes and workers, and collect snapshots of async tasks and queued or running blocking tasks on request.
  • Select ordinary or observed execution once per worker cycle. Preserve task identity, parent relationships, spawn timestamps, and completion, cancellation, and panic outcomes.
  • Keep async diagnostic metadata inside the executor's pooled task allocation. It needs no separate allocation.
  • Store each monitored blocking callback and its metadata in one shared allocation. Remove an extra queue lock when a blocking worker finishes one task and takes the next.
  • Use private monitoring wrappers in every runtime build. Enable their monitoring logic internally instead of maintaining separate submission methods.
  • Keep monitoring tests private and use Metabench for allocation and timing measurements.

The executor inspector receives both the future and its completion target. This lets Arty inspect metadata without a separate shared allocation.

Arty does not expose monitor I/O or diagnostic handles through test-util. There is no MonitorPolicy::isolated() replacement. Only Arty's own unit-test builds use private mocked monitor I/O. Other builds use native monitoring.

The branch includes main through 6230675b0. It preserves the new panic-hook API and its shutdown behavior. Unrelated documentation examples use the runtime defaults.

Performance

Matched local measurements of a queued batch of 4,096 blocking tasks showed about 9.6% lower drain time with idle monitoring. The measured interval starts after submission and includes task execution and joins. Allocation counts and bytes did not change. Small-batch timing was inconclusive. This is not a claim of a universal speedup or a lower submission cost.

Validation

After merging main, Arty and executor tests passed with all features. Arty tests also passed with only rt. Anyspawn's Arty integration tests, Seismograph runtime tests, and Arty and executor documentation tests passed.

Workspace Anvil Clippy, formatting, README generation, and spellcheck passed. Earlier CI coverage passed. The updated CI run must still establish coverage and mutation results for the current head. The previous Windows mutation run failed, so that gate is not yet resolved.

Register runtime workers and expose native async and blocking task snapshots through Seismograph. Observe task polls only when collection or recording needs them, and preserve task identity, timestamps, and terminal outcomes.

Store async diagnostic metadata in pooled executor tasks and reduce it to 56 bytes. Resolve recorded spawn descriptors lazily and reuse the event timestamp. Add monitoring integration tests and spawn benchmarks.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 9, 2026 14:04

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟡 Changes recommended

Unresolved issues drop parent links for remote and blocking spawns, report wrapped or erased future sizes instead of original sizes, and leave a timeout test dependent on real timing.

4 open issues
What changed in this PR

This PR connects Arty’s runtime and tasks to Seismograph for on-demand diagnostics, while keeping per-poll observation off when it is not needed.

Changes:

  • Adds runtime and worker registration, monitor lifecycle management, and native async and blocking task snapshots.
  • Extends executor inspection to borrow completion metadata and adds lazy spawn metadata with shared timestamps.
  • Adds monitoring tests and lifecycle and allocation benchmarks, with updated feature configuration and documentation.
File Description
crates/​seismograph_runtime/​tests/​on_demand.rs Tests lazy spawn metadata and disabled recording.
crates/​seismograph_runtime/​src/​task.rs Adds lazy spawn descriptors and returned timestamps.
crates/​arty/​tests/​monitoring.rs Tests collection, lifecycle events, and monitor behavior.
crates/​arty/​src/​task/​scheduler.rs Adds local task metadata and adjusts remote future construction.
crates/​arty/​src/​task/​runtime_scheduler.rs Removes a wrapper from remote future construction.
crates/​arty/​src/​task/​preparation/​remote.rs Registers remote tasks with diagnostic metadata.
crates/​arty/​src/​task/​preparation/​mod.rs Exports monitoring-aware blocking preparation.
crates/​arty/​src/​task/​preparation/​blocking.rs Records blocking task outcomes.
crates/​arty/​src/​runtime/​worker/​blocking/​worker.rs Integrates blocking queue storage and worker observation.
crates/​arty/​src/​runtime/​worker/​blocking/​queue.rs Adds inspectable queued and running task storage.
crates/​arty/​src/​runtime/​worker/​blocking/​mod.rs Includes the blocking queue module.
crates/​arty/​src/​runtime/​worker/​asynchronous/​worker.rs Selects observed cycles and handles collection requests.
crates/​arty/​src/​runtime/​worker/​asynchronous/​thread.rs Enables blocking pool monitoring during startup.
crates/​arty/​src/​runtime/​worker/​asynchronous/​protocol.rs Adds the task inspection command.
crates/​arty/​src/​runtime/​monitoring/​task.rs Stores task identity, metadata, and outcome reporting.
crates/​arty/​src/​runtime/​monitoring/​runtime.rs Manages runtime registration and monitor lifetime.
crates/​arty/​src/​runtime/​monitoring/​mod.rs Organizes monitoring components.
crates/​arty/​src/​runtime/​monitoring/​asynchronous.rs Implements async worker collection and poll observation.
crates/​arty/​src/​runtime/​mod.rs Documents monitoring behavior and includes its implementation.
crates/​arty/​src/​runtime/​handle.rs Adds test diagnostics access and monitor shutdown handling.
crates/​arty/​src/​runtime/​dispatch/​core.rs Routes collection requests and reports runtime stopping.
crates/​arty/​src/​runtime/​dispatch/​client.rs Forwards diagnostic registration calls.
crates/​arty/​src/​runtime/​config/​monitor_policy.rs Adds runtime names and test monitor I/O configuration.
crates/​arty/​src/​runtime/​config/​monitor_options.rs Carries runtime diagnostics into worker startup.
crates/​arty/​src/​runtime/​builder.rs Documents monitor startup behavior and errors.
crates/​arty/​src/​runtime/​bootstrap/​startup.rs Starts diagnostics and connects them to runtime components.
crates/​arty/​src/​lib.rs Updates feature and macro documentation.
crates/​arty/​README.md Refreshes generated monitoring documentation.
crates/​arty/​Cargo.toml Adds diagnostic dependencies, feature wiring, and benchmarks.
crates/​arty/​benches/​arty_spawn_allocations.rs Measures warmed task allocation costs.
crates/​arty/​benches/​arty_inspection.rs Benchmarks task workloads across monitoring modes.
crates/​arty_executor/​tests/​inspection.rs Tests completion-target inspection and terminal delivery.
crates/​arty_executor/​src/​task.rs Passes completion targets to inspectors.
crates/​arty_executor/​src/​task_set.rs Adds completion-aware task inspection registration.
crates/​arty_executor/​src/​inspection.rs Extends inspector callbacks to borrow completion targets.
crates/​arty_executor/​src/​executor_shared.rs Updates internal inspector bounds.
Cargo.lock Records Arty’s added dependencies.

Review effort: Balanced

Comment thread crates/arty/tests/monitoring.rs Resolved
Keep the upstream task submission optimizations and register local deferred task factories with runtime monitoring. Regenerate the Arty README from the merged crate documentation.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 9, 2026 14:16

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

Task recording loses parent identities for cross-worker and nested blocking spawns and reports boxed-wrapper sizes instead of original future sizes in the block_on path.

4 open issues

Review effort: Balanced

Capture remote task parents before queueing and restore blocking task context after execution. Report the original scoped future size before erasure without enlarging ordinary async metadata. Add regression coverage and a feature-gated simulated timeout for deterministic capture recovery tests.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 9, 2026 14:31

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

Blocking-task monitoring can duplicate tasks across workers, record execution for work discarded during shutdown, and omit terminal events when recording is enabled mid-execution.

No open issues 🎉

3 previously missed issues

In code that hasn't changed since last review

Medium severity Assign task identity when recording starts during execution

crates/​arty/​src/​runtime/​monitoring/​task.rs:172

If a blocking function starts before observation and recording is enabled while it runs, this guard drops its completion event because no task identity was assigned. The same guard affects panic and cancellation outcomes. Initialize the identity lazily when terminal recording is enabled, without inventing a spawn timestamp or poll start, and cover this transition with channel-controlled synchronization.

Medium severity Deduplicate tasks observed in both ready and running batches

crates/​arty/​src/​runtime/​worker/​blocking/​queue.rs:224

If worker 0 reports a queued task and another worker dequeues it before its provider runs, one capture contains the same ID as both Ready and Running. collection::capture_with concatenates these batches without deduplication, so the CLI associates the task with both workers. Take one shared pool sample per capture, or merge duplicate IDs while preserving the newer observation before returning the snapshot.

Medium severity Skip poll events for queued tasks discarded during shutdown

crates/​arty/​src/​runtime/​worker/​blocking/​worker.rs:102

Queued functions discarded during shutdown still receive TaskPollStarted and TaskPollFinished: these hooks run before the shutdown check inside job.body (spawn_blocking, lines 221–225). This records execution time for a user function that never runs. Move poll observation into the branch that executes the function, and assert that queued cancellation emits no poll events.

4 resolved since last review

Review effort: Balanced

Comment thread crates/arty/Cargo.toml Resolved
@codecov

codecov Bot commented Nov 9, 2026 •

Copy link
Copy Markdown

Codecov Report

✅ All modified and coverable lines are covered by tests.
✅ Project coverage is 100.0%. Comparing base (ff31146) to head (38ab799).
⚠️ Report is 7 commits behind head on main.

Additional details and impacted files
@@            Coverage Diff             @@
##             main     #960      +/-   ##
==========================================
  Coverage   100.0%   100.0%              
==========================================
  Files         798      145     -653     
  Lines       68902    10548   -58354     
==========================================
- Hits        68902    10548   -58354     
Flag Coverage Δ
linux 100.0% <100.0%> (ø)
linux-arm 100.0% <100.0%> (ø)
scheduled ?
windows 100.0% <100.0%> (ø)

Flags with carried forward coverage won't be shown. Click here to find out more.

☔ View full report in Codecov by Harness.
📢 Have feedback on the report? Share it here.

🚀 New features to boost your workflow:
  • ❄️ Test Analytics: Detect flaky tests, report on failures, and find test suite problems.

Record real terminal outcomes when recording starts during execution. Keep one task row across shared-queue transitions and skip poll events for shutdown cancellations.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 9, 2026 15:13
@ralfbiedert

Copy link
Copy Markdown
Collaborator Author

Blocking-task monitoring can duplicate tasks across workers, record execution for work discarded during shutdown, and omit terminal events when recording is enabled mid-execution.

Fixed in b2929a4. Terminal events now assign task identities when recording starts during execution, without fabricating spawn or poll events. This also covers async tasks. Captures collapse duplicate task IDs and keep the running observation with its execution worker. Blocking workers check shutdown before poll observation, so discarded functions emit cancellation without poll events.

Added channel-controlled success, panic, and cancellation regressions, plus both provider-order cases for duplicate capture rows. The affected suites, telemetry-disabled Arty tests, Clippy, formatting, README generation, and spelling checks pass locally.

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

Unsafe executor-payload borrowing and blocking-pool synchronization changes require maintainer review of concurrency and lifetime safety, with full CI and runtime-analysis results still unverified.

No open issues 🎉

Review effort: Balanced

@martintmk

martintmk commented Nov 9, 2026 •

Copy link
Copy Markdown
Member

Posted by an AI agent

Warning: Incomplete review

The original eleven-area full review covers 4cdc6693661c6da567c69c3e9253362275bd3912. Prior bounded revalidation covers b2929a40fa156ae417bfa6821bc3e265fd60dd65. This findings-only refresh covers 69134976253318e747c32026ec3566579c4421d9.

I read the complete one-commit, 36-file delta and the current source needed to recheck the existing findings. The later commit received no new-finding review. No overall verdict is given for the current head. Current API and integration-test classifications were not repeated. Fresh Linux benchmark coverage compares the merge base with this head and finished at 11/09/2026 17:23:45. This does not repeat the current-head API or integration-test assessments.

Target: microsoft/oxidizer / refs/heads/main. Direct target tip and actual comparison merge base: 45d4c3e74799f6ab0c94a55c436ba6a0104c7326. Prior coverage completed at 2026-11-09T15:27:18.2084012Z. Findings-only source revalidation completed at 2026-11-09T15:52:44.5052268Z.

Current unresolved findings

None from this review. The two previously unresolved findings are now fixed in the source and externally resolved:

  • Repeated-capture request retirement: each earlier capture now has a same-worker handshake before the next request. Exact task-count and completion checks precede the identity assertions.
  • Native-registry dependencies in tests and examples: unrelated paths disable monitoring, monitoring-specific construction tests use owned mocked I/O, and intentional native-monitor examples use no_run. Production defaults and security checks remain intact.

The author still defers timed-capture coverage and the blocking-limit regression. Both threads remain resolved outside this assignment. These are deferred coverage gaps, not completed fixes or proved runtime defects.

The earlier diagnostic fixes remain unchanged by this delta. The existing public dependency question is now externally resolved. No new answer or substantive design decision is inferred from that status alone. This review did not reply to or resolve any thread.

Public API changes

Could not assess the current head. This findings-only refresh did not regenerate matching API output.

The following assessment is historical. It compares 45d4c3e74799f6ab0c94a55c436ba6a0104c7326 with b2929a40fa156ae417bfa6821bc3e265fd60dd65, not the current head.

The captures show that arty::runtime::MonitorPolicy loses its #[repr(transparent)] annotation. The type exposes no public fields. Output alone does not establish a documented public layout guarantee or a breaking change. Its compatibility effect could not be reviewed within this evidence boundary.

// Base
#[repr(transparent)] pub struct arty::runtime::MonitorPolicy
// Head
pub struct arty::runtime::MonitorPolicy

Public API Additions

impl arty::runtime::MonitorPolicy {
    pub fn io(self, io: seismograph_protocol::io::MonitorIo) -> Self;
    pub fn name(self, name: impl core::convert::Into<alloc::string::String>) -> Self;
}
impl arty::runtime::Runtime {
    pub fn diagnostics(&self) -> core::option::Option<seismograph_runtime::RuntimeHandle>;
}
impl arty_executor::TaskSet {
    pub fn add_with_completion_inspection<F, R, T, D, I>(
        &self, future: F, options: arty_executor::TaskOptions, completion: T, inspect: I,
    )
    where
        F: core::future::future::Future<Output = R> + 'static,
        R: 'static,
        T: arty_executor::TaskCompletion<R>,
        D: 'static,
        I: core::ops::function::Fn(&F, &T, arty_executor::TaskState) -> core::option::Option<D> + 'static;
}

seismograph_runtime::task adds a type with three public fields and Clone, Copy, Debug, PartialEq, and Eq implementations.

// seismograph_runtime::task
pub struct TaskSpawn {
    pub descriptor: seismograph::recorder::runtime::TypeDescriptorId,
    pub id: seismograph::recorder::runtime::TaskId,
    pub timestamp: seismograph::recorder::event::EventTimestamp,
}
impl seismograph_runtime::task::EventContext {
    pub fn spawned_with(
        &self,
        descriptor: impl core::ops::function::FnOnce() -> seismograph::recorder::runtime::TypeDescriptorId,
        parent: core::option::Option<seismograph::recorder::runtime::TaskId>,
        body_size: usize,
    ) -> core::option::Option<seismograph_runtime::task::TaskSpawn>;
}
impl seismograph_runtime::RuntimeHandle {
    pub fn capture_with_timeout(
        &self, options: seismograph_runtime::snapshot::CaptureOptions,
    ) -> core::result::Result<seismograph_runtime::snapshot::Runtime, seismograph::Error>;
}

No existing trait requirements change. anyspawn and arty_tokio expose identical base and head surfaces.

Integration tests

Could not assess the current head. This findings-only refresh did not prepare a new complete base/current integration-test inventory.

The following classification and case counts are historical at b2929a40fa156ae417bfa6821bc3e265fd60dd65:

No Breaking Behavioral Changes

  • Established expectations and discovery remain intact. One test clears earlier buffers before its unchanged assertion.
  • Added 23 Arty monitoring cases, six executor inspection cases, three runtime metadata/collection cases, and TaskSpawn trait assertions. Queued cancellation now also rejects poll events.

Benchmarks

Status: complete. Fresh Linux measurements compare 45d4c3e with 691349762 for all 71 native cases across three targets.

arty / arty_contention

Benchmark / case Instructions before Instructions after Change Change %
arty_contention/nested_retained_waker/Arty/concurrency_w1 6149 6379 +230 +3.74%
arty_contention/nested_retained_waker/Arty/concurrency_w8 7251 7599 +348 +4.80%
arty_contention/nested_retained_waker/Tokio/concurrency_w1 9821 9821 0 +0.00%
arty_contention/nested_retained_waker/Tokio/concurrency_w8 9982 9982 0 +0.00%
arty_contention/relocated_cache/Arty/concurrency_w1 6278 6561 +283 +4.51%
arty_contention/relocated_cache/Arty/concurrency_w8 7380 7663 +283 +3.83%
arty_contention/relocated_cache/Tokio/concurrency_w1 11591 11639 +48 +0.41%
arty_contention/relocated_cache/Tokio/concurrency_w8 11751 11799 +48 +0.41%

arty / arty_scheduling

Benchmark / case Instructions before Instructions after Change Change %
arty_scheduling/tasks/Arty/blocking_w1_n1 1275 1464 +189 +14.82%
arty_scheduling/tasks/Arty/blocking_w1_n20 17354 21784 +4430 +25.53%
arty_scheduling/tasks/Arty/blocking_w4_n1 1273 1462 +189 +14.85%
arty_scheduling/tasks/Arty/blocking_w4_n20 17381 19759 +2378 +13.68%
arty_scheduling/tasks/Arty/nested_w1_n1 764 792 +28 +3.66%
arty_scheduling/tasks/Arty/nested_w1_n20 764 792 +28 +3.66%
arty_scheduling/tasks/Arty/nested_w4_n1 764 792 +28 +3.66%
arty_scheduling/tasks/Arty/nested_w4_n20 764 792 +28 +3.66%
arty_scheduling/tasks/Arty/spawn_w1_n1 1043 1068 +25 +2.40%
arty_scheduling/tasks/Arty/spawn_w1_n20 11550 12050 +500 +4.33%
arty_scheduling/tasks/Arty/spawn_w4_n1 1043 1068 +25 +2.40%
arty_scheduling/tasks/Arty/spawn_w4_n20 13867 14367 +500 +3.61%
arty_scheduling/tasks/Arty/timeout_w1_n1 1029 1062 +33 +3.21%
arty_scheduling/tasks/Arty/timeout_w1_n20 1029 1062 +33 +3.21%
arty_scheduling/tasks/Arty/timeout_w4_n1 3075 3195 +120 +3.90%
arty_scheduling/tasks/Arty/timeout_w4_n20 3075 3195 +120 +3.90%
arty_scheduling/tasks/Arty/timer_w1_n1 1043 1068 +25 +2.40%
arty_scheduling/tasks/Arty/timer_w1_n20 11550 12050 +500 +4.33%
arty_scheduling/tasks/Arty/timer_w4_n1 1043 1068 +25 +2.40%
arty_scheduling/tasks/Arty/timer_w4_n20 14722 14933 +211 +1.43%
arty_scheduling/tasks/Arty/wake_w1_n1 971 1106 +135 +13.90%
arty_scheduling/tasks/Arty/wake_w1_n20 11805 12183 +378 +3.20%
arty_scheduling/tasks/Arty/wake_w4_n1 1089 1106 +17 +1.56%
arty_scheduling/tasks/Arty/wake_w4_n20 12772 13153 +381 +2.98%
arty_scheduling/tasks/Arty/yield_w1_n1 1043 1068 +25 +2.40%
arty_scheduling/tasks/Arty/yield_w1_n20 11550 12050 +500 +4.33%
arty_scheduling/tasks/Arty/yield_w4_n1 1043 1068 +25 +2.40%
arty_scheduling/tasks/Arty/yield_w4_n20 13867 14485 +618 +4.46%
arty_scheduling/tasks/Tokio/blocking_w1_n1 982 982 0 +0.00%
arty_scheduling/tasks/Tokio/blocking_w1_n20 22677 23007 +330 +1.46%
arty_scheduling/tasks/Tokio/blocking_w4_n1 982 982 0 +0.00%
arty_scheduling/tasks/Tokio/blocking_w4_n20 24301 24336 +35 +0.14%
arty_scheduling/tasks/Tokio/nested_w1_n1 1010 1010 0 +0.00%
arty_scheduling/tasks/Tokio/nested_w1_n20 873 1010 +137 +15.69%
arty_scheduling/tasks/Tokio/nested_w4_n1 995 995 0 +0.00%
arty_scheduling/tasks/Tokio/nested_w4_n20 995 995 0 +0.00%
arty_scheduling/tasks/Tokio/spawn_w1_n1 1190 1190 0 +0.00%
arty_scheduling/tasks/Tokio/spawn_w1_n20 25994 26111 +117 +0.45%
arty_scheduling/tasks/Tokio/spawn_w4_n1 1187 1017 -170 -14.32%
arty_scheduling/tasks/Tokio/spawn_w4_n20 26008 26130 +122 +0.47%
arty_scheduling/tasks/Tokio/timeout_w1_n1 1431 1431 0 +0.00%
arty_scheduling/tasks/Tokio/timeout_w1_n20 1431 1431 0 +0.00%
arty_scheduling/tasks/Tokio/timeout_w4_n1 4332 4332 0 +0.00%
arty_scheduling/tasks/Tokio/timeout_w4_n20 4336 4336 0 +0.00%
arty_scheduling/tasks/Tokio/timer_w1_n1 1224 1224 0 +0.00%
arty_scheduling/tasks/Tokio/timer_w1_n20 25697 25697 0 +0.00%
arty_scheduling/tasks/Tokio/timer_w4_n1 1224 1224 0 +0.00%
arty_scheduling/tasks/Tokio/timer_w4_n20 25975 25565 -410 -1.58%
arty_scheduling/tasks/Tokio/wake_w1_n1 1252 1252 0 +0.00%
arty_scheduling/tasks/Tokio/wake_w1_n20 25605 25605 0 +0.00%
arty_scheduling/tasks/Tokio/wake_w4_n1 1237 1237 0 +0.00%
arty_scheduling/tasks/Tokio/wake_w4_n20 25571 25729 +158 +0.62%
arty_scheduling/tasks/Tokio/yield_w1_n1 1190 1190 0 +0.00%
arty_scheduling/tasks/Tokio/yield_w1_n20 25994 25999 +5 +0.02%
arty_scheduling/tasks/Tokio/yield_w4_n1 1070 1175 +105 +9.81%
arty_scheduling/tasks/Tokio/yield_w4_n20 26118 26118 0 +0.00%

arty_executor / ae_basic_operations

Benchmark / case Instructions before Instructions after Change Change %
ae_basic_operations/execute_cycle/execute_cycle/idle 7003 7003 0 +0.00%
ae_basic_operations/execute_cycle/execute_cycle/pending_task 13252 13252 0 +0.00%
ae_basic_operations/task/add_task/ready 1939 1939 0 +0.00%
ae_basic_operations/task/self_waking_task/borrowed_waker_polls_4 31351 31367 +16 +0.05%
ae_basic_operations/task/self_waking_task/cloned_waker_polls_4 31454 31397 -57 -0.18%
ae_basic_operations/waker/clone_during_cycle/pending_task 13276 13276 0 +0.00%
ae_basic_operations/waker/retained_after_executor_drop/wake_by_ref 59 59 0 +0.00%

Allocations: unavailable (not measured by this run).

All 32 Arty cases used more instructions in this run. Arty blocking cases increased by 13.68% to 25.53%. These results do not identify a specific avoidable source defect.

These are one-pass simulated instruction counts, not elapsed times. Worker scheduling can affect the threaded Arty and Tokio cases. Metabench's combined case status also includes cache metrics and must not be read as an instruction-only verdict.

The 16 Criterion-only cases and four allocation cases remain outside native Gungraun coverage. No timing or allocation engine ran.

Raw reports and commands are retained in the review handoff.

Human review and delivery

The current combined human-review status is undetermined because the two required classifications were not refreshed. The historical combined decision at b2929a40fa156ae417bfa6821bc3e265fd60dd65 remains required because of public API additions. No new label decision or label write follows from that historical result. The required label remains unapplied by this review.

At the 11/09/2026 16:34:00 to 11/09/2026 16:34:09 observation, current-head CI had 11 failed checks. Check counts: 11 completed, failure; 34 completed, success; 3 in_progress; 1 queued. The Linux fast-check log reports that Arty's Cargo.toml is not sorted/formatted. The Linux ARM coverage log reports 14 uncovered Arty lines and one uncovered Seismograph Runtime line. The repeated-capture identity case passes in that ARM run. These are provider CI results, not tests run by this review. Other failed-check causes are not diagnosed here.

The existing COMMENT review remains unchanged at b2929a40fa156ae417bfa6821bc3e265fd60dd65. This refresh updates only this rolling report. It submits no new immutable review or approval.

@martintmk martintmk left a comment

Copy link
Copy Markdown
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Posted by an AI agent

Posted four non-blocking findings. The current review report records the original full review at 4cdc6693661c6da567c69c3e9253362275bd3912 and bounded revalidation at b2929a40fa156ae417bfa6821bc3e265fd60dd65. This is a comment-only revalidation with no overall verdict. Public API additions require human review. Benchmark measurements remain unavailable.

Wait for the collection request slot to retire before another capture. Assert complete snapshots before comparing task identities.

Disable native monitoring in scheduling tests and examples. Inject owned monitor I/O in enabled-policy construction tests and compile native-monitor examples without running them.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 9, 2026 15:43

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

Changes to cross-thread shutdown and the unsafe pooled-task lifecycle require human concurrency review and cross-platform runtime validation beyond mocked-monitor unit tests.

No open issues 🎉

Review effort: Balanced

Merge origin/main and retain completion-target inspection through the new task builder without adding task allocations.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 12, 2026 15:32

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

The queue synchronization, shutdown, and unsafe executor payload-borrowing changes require cross-platform and runtime-analysis validation that remains unverified for this commit.

No open issues 🎉

Review effort: Balanced

Merge main, retain native task collection, and adapt new executor regression tests to the task registration builder. Adopt the upstream Gamma migration without retaining obsolete cargo-mutants configuration or attributes.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 12, 2026 17:43

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

Changes to blocking-queue synchronization, native monitor lifecycle, and unsafe completion metadata access need human review because the cross-platform CI and runtime-analysis matrix remains unverified.

No open issues 🎉

Review effort: Balanced

@github-advanced-security github-advanced-security AI left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

cargo-gamma found more than 20 potential problems in the proposed changes. Check the Files changed tab for more details.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 13, 2026 07:49

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

Borrowed executor completion payloads across crates and the new synchronized blocking-execution queue warrant human review alongside the outstanding runtime-analysis and platform CI results.

No open issues 🎉

Review effort: Balanced

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 13, 2026 09:45

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

Unsafe executor-payload borrowing and blocking-pool synchronization changes warrant human review, particularly with incomplete coverage and an unverified platform/runtime-analysis matrix.

No open issues 🎉

Review effort: Balanced

Comment thread crates/arty/src/lib.rs Resolved
Comment thread crates/arty/src/task/handle/error.rs Resolved
Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Preserve panic hooks, startup test seams, and demand-driven monitoring during reconciliation.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 16, 2026 17:24

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🟡 Changes recommended

The monitor-enabled integration test uses real sockets or named pipes and the user's registry rather than the unit-test mock, leaving ordinary test runs dependent on host storage and permissions.

1 open issue

Review effort: Balanced

Comment thread crates/arty/tests/test_macro.rs Resolved
Run the enabled test macro with private mocked monitor I/O. Preserve integration compile coverage without opening native monitor endpoints.

Co-authored-by: Copilot App <223556219+Copilot@users.noreply.github.com>
Copilot AI balanced review requested due to automatic review settings November 16, 2026 17:42

Copilot AI left a comment

Copy link
Copy Markdown
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

🔵 Needs a closer look

Human assessment is needed to evaluate monitoring’s rejection of previously accepted empty runtime names and doctests that depend on host storage and permissions.

No open issues 🎉

1 resolved since last review

Review effort: Balanced

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

4 participants