Skip to content

perf(kio): index task wakes so a poll skips capacity a burst left behind - #7513

Merged
kixelated merged 5 commits into
mainfrom
quest/m2/performance-survey/task-capacity
Nov 2, 2026
Merged

kixelated merged 5 commits into
mainfrom
quest/m2/performance-survey/task-capacity

Conversation

@kixelated

@kixelated kixelated commented Nov 1, 2026 •

Copy link
Copy Markdown
Collaborator

Problem

Advances quest/m2/performance-survey/task-capacity.md. kio::Tasks::poll swapped every wake-bit word the set had ever grown, then scanned them again to dispatch. A long-lived set paid for its historical peak on every owner poll, even with one task left. The io_uring worker polls its set every turn, and the session serving loops poll theirs on every wake. The 2026-10-22 CDN profile put Tasks<GroupServe>::poll at 1.9-2.4% self-time, the largest moq-net site.

Approach

rs/kio/src/task.rs now indexes the wake bitset in three levels:

  • Word bits, as before.
  • Chunk summary, a new AtomicU64 per 1,024-slot chunk. Bit w marks word w as nonzero.
  • Top word: Shared::ready, where bit c % 64 marks chunk c as having a marked summary.

A wake marks the level above only when it makes a level nonzero. A poll clears each level before it reads the level below. So a wake into a level that is still nonzero is either taken by that poll, or covered by the mark that level's first wake left for the next poll. An owner poll with nothing woken is now one swap, whatever the peak.

What stays the same:

  • The snapshot is still taken in full before any task runs, so a mid-pass wake still lands in the next pass.
  • It is kept as sorted (word, bits) pairs, so dispatch keeps the same rotated slot order from next.
  • Up to 64 chunks (65,536 slots) the top word is exact. Past that, one bit covers every 64th chunk (one swap each), and the pairs are sorted.
  • SlotWaker now keeps only its slot index and derives its bits from it, which saves 8 B per slot.

Benches, both picked up by the nightly kio leg (criterion kio --no-fail-fast -p kio --bench '*' in sh/gh/nightly.sh):

  • New tasks_capacity_{idle,survivor,sparse,full,churn} groups in rs/kio/benches/tasks.rs. They sweep historical peak (1, 1,024, 16,384, 65,536) against the tasks that are live and woken now.
  • New rs/kio/benches/task_capacity.rs table: retained bytes after a burst, allocations per owner poll, and bytes left after drop.

Quests:

  • The task-capacity quest is rewritten to its remaining memory half (see Decisions).
  • uring-quiescence.md previously said whichever of the two quests landed second rebases on the other. It now says to baseline its pass budget on the indexed snapshot.

Measurements

User-space instructions (perf stat --no-scale -e cpu_core/instructions/u), pinned to P-core 2 of a Core Ultra 7 270K Plus. The host was shared, with a load average of about 30 on 24 threads.

  • Each revision was built from its own git archive export, outside the checkout, with the profiling profile (fat LTO) and Rust 1.98.1.
  • The harness runs identical setup for 0 and N rounds and reports (I(N) − I(0)) / polls.
  • Base: 9b823e2e16. Candidate: this branch's task.rs. Later edits were formatting, docs and test attributes only.
  • A/A: a second base run of the idle, sparse and full shapes (at 1,024 and 65,536) matched the first within 1 instruction. A rerun of the worker matched within 1 instruction per round trip.

Owner poll after a burst, one task left (kio::Tasks alone; instructions per poll):

peak idle: nothing woken survivor woken set empty
1 349 → 152 624 → 562 373 → 175
1,024 812 → 166 1,088 → 624 837 → 189
16,384 9,528 → 166 9,803 → 625 9,552 → 189
65,536 37,415 → 166 37,691 → 625 37,440 → 189

Putting the survivor in the highest slot instead of slot 0 changes nothing material (within about 60 instructions in either revision).

16 woken per poll (instructions per poll):

peak sparse (every 64th slot live) full (every slot live)
1,024 4,335 → 4,602 (+6%) 4,260 → 3,650
16,384 13,050 → 4,582 12,976 → 3,651
65,536 40,938 → 4,583 40,864 → 3,651

Reuse paths (instructions per poll):

peak churn: 16 short tasks through the drained set, per poll (two per round) repeat burst of peak tasks, per poll (two per burst)
1 5,127 → 5,098 768 → 715
1,024 5,544 → 5,178 428,323 → 429,755 (+0.3%)
16,384 14,259 → 5,242 7,082,026 → 7,103,636 (+0.3%)
65,536 42,147 → 5,242 28,374,413 → 28,460,342 (+0.3%)

Steady polls allocate nothing in either revision.

Consumer: io_uring worker after a spawn burst. A moq_uring::Worker spawned peak tasks that all finished, then ran one-datagram round trips (3 turns each). User instructions per round trip:

peak base candidate
0 3,818 3,823
1,024 5,134 3,895
16,384 22,055 3,893
65,536 76,198 3,893

Memory (unchanged in kind; see Decisions). Retained heap after a drained burst, from the task_capacity bench with an 8-byte task:

  • About 184 B per peak slot, whatever is still live: 188,912 B at 1,024 and 12,085,304 B at 65,536.
  • The candidate keeps 4% less than base at 65,536 (12,150,792 vs 12,666,376 B in the harness), from the smaller SlotWaker.
  • Bytes after drop are 0.

Wall clock, from a Criterion smoke run on the loaded host (indicative only): tasks_capacity_idle takes 15-20 ns at every peak. The quest's base measurement was 4,831 ns at 65,536.

Validation

  • New wakes_past_64_chunks_run_in_slot_order: 66 chunks of tasks. Woken slots that share top-word bits each run exactly once, in ascending rotated slot order. No other task runs, and an idle poll runs nothing.
  • New concurrent_wakes_are_never_lost: 4 threads wake 3 chunks of tasks while the owner polls. Every task's last poll must see its last wake.
    • Mutation check: clearing the chunk summary after taking its words, instead of before (a real lost-wake race), fails it. It passed 300 of 300 release runs.
    • Under cfg(miri) it shrinks to 16 rounds, ahead of the Miri nightly in moq-dev/moq#7315. The 66-chunk test is ignored under Miri.
  • The existing kio task tests pass unchanged. That covers mid-pass wakes, stale-waker single polls, self-wake rotation, batch holds and coalesced owner wakes.
  • nix develop -c quest gate just check passes on 141960d652: 10,543 tests, lint and quest. Only the flake check was skipped: this host's Nix builder cannot create user namespaces.
  • After merging origin/main (bf4e726f66): cargo test -p kio --all-targets (182 tests) and just rs check -p kio pass. The merged toolchain flagged clippy::type_complexity on the after_burst bench helper's opaque return type, which cannot be aliased on stable; it now carries an #[expect] with that reason.

Impact

  • Public API: none. Wire: none.
  • Wake path: the wake that makes a word nonzero now does one more fetch_or (the chunk summary), and a chunk's first such wake does another (the top word). That is what the +6% on the sparse 1,024-slot shape pays for.
  • Small sets: a chunk grows by 8 B, the snapshot no longer scales with capacity, and a 1-task set keeps 905 → 841 B.

Choices made without asking

  • A fixed 64-bit top word, folded by chunk % 64 past 64 chunks, rather than a growable top level. Wakers hold no pointer that would have to move, and sets up to 65,536 slots are exact.
  • Accepted +6% on sparse wakes in a small set (16 words woken among 16) for the flat cost elsewhere.
  • Shrunk SlotWaker to its slot index, since it is the per-slot allocation this quest is about.
  • Instructions come from an uncommitted harness. Its source is below, so the run can be repeated. The committed benches give the nightly wall-clock and allocation signal.

Decisions

Settled 2026-11-01 by the maintainer.

  1. What to do with the memory half of the quest. This PR fixes poll CPU. The set still keeps about 184 B per peak slot, plus size_of::<T>(), after a burst drains.

    • ✅ (a) Land this as is. The quest file is rewritten to the memory half: reclaimable slot chunks, measured against repeat-burst cost and the real consumers' task sizes. The CPU half was the measured production hotspot. The memory cost has no production measurement yet, and reclaiming it trades away the cheap burst reuse shown above.
    • (b) Treat retained capacity as justified, and delete the quest in this PR.
    • (c) Implement chunk reclaim in this PR. That means picking an allocation order (lowest free slot rather than LIFO) and a hysteresis policy, then measuring both against repeat bursts.

    The quest's Plan records the same answer.

Review

Codex gpt-6-astra, medium effort (quest review --deep --base origin/main), session 01a1962d-68ba-7ff2-8bba-f1d1147046ff.

  • Round 1 on 0f9f840d7a: 0 findings.
  • Round 2 on 141960d652 (quest text correction only): 0 findings.
  • Head 36e475bf81: local review skipped under the simple-review rule (moq-dev/quest#364). Since round 2 the branch has only a conflict-free merge of origin/main, the recorded decision in the quest Plan, and one #[expect(clippy::type_complexity)] attribute on a bench helper. None touches behavior, public API, wire format, security code, or unsafe. No online-reviewer threads were open.

Follow-ups

  • The rewritten task-capacity quest owns memory reclaim.
  • The io_uring worker comparison above is a one-off harness. A worker_turns variant after a spawn burst would give the consumer path its own nightly series. That is optional, since the kio groups already cover the mechanism.
Harness: rs/kio/examples/capacity.rs (uncommitted)
//! Deterministic task-capacity harness: `capacity <scenario> <peak> <rounds>`.
//!
//! Runs identical setup, then `rounds` measured owner polls. Instructions per poll
//! come from `perf stat` on (I(N) - I(0)) / N; this binary prints allocator stats.
use std::{
	alloc::{GlobalAlloc, Layout, System},
	hint::black_box,
	sync::{
		Arc, Mutex,
		atomic::{AtomicBool, AtomicIsize, AtomicUsize, Ordering},
	},
	task::{Poll, Waker},
};

struct Counter;
static LIVE: AtomicIsize = AtomicIsize::new(0);
static ALLOCS: AtomicUsize = AtomicUsize::new(0);

unsafe impl GlobalAlloc for Counter {
	unsafe fn alloc(&self, l: Layout) -> *mut u8 {
		LIVE.fetch_add(l.size() as isize, Ordering::Relaxed);
		ALLOCS.fetch_add(1, Ordering::Relaxed);
		unsafe { System.alloc(l) }
	}
	unsafe fn alloc_zeroed(&self, l: Layout) -> *mut u8 {
		LIVE.fetch_add(l.size() as isize, Ordering::Relaxed);
		ALLOCS.fetch_add(1, Ordering::Relaxed);
		unsafe { System.alloc_zeroed(l) }
	}
	unsafe fn realloc(&self, p: *mut u8, l: Layout, n: usize) -> *mut u8 {
		LIVE.fetch_add(n as isize - l.size() as isize, Ordering::Relaxed);
		ALLOCS.fetch_add(1, Ordering::Relaxed);
		unsafe { System.realloc(p, l, n) }
	}
	unsafe fn dealloc(&self, p: *mut u8, l: Layout) {
		LIVE.fetch_sub(l.size() as isize, Ordering::Relaxed);
		unsafe { System.dealloc(p, l) }
	}
}

#[global_allocator]
static A: Counter = Counter;

struct Gate {
	fired: AtomicBool,
	finish: AtomicBool,
	waker: Mutex<Option<Waker>>,
}

impl Gate {
	fn new() -> Arc<Self> {
		Arc::new(Self { fired: AtomicBool::new(false), finish: AtomicBool::new(false), waker: Mutex::new(None) })
	}
	fn fire(&self) {
		self.fired.store(true, Ordering::Release);
		if let Some(w) = self.waker.lock().unwrap().take() {
			w.wake();
		}
	}
	fn retire(&self) {
		self.finish.store(true, Ordering::Release);
		self.fire();
	}
}

fn task(gate: Arc<Gate>) -> impl FnMut(&kio::Waiter) -> Poll<()> {
	move |waiter| {
		if gate.finish.load(Ordering::Acquire) {
			return Poll::Ready(());
		}
		black_box(gate.fired.swap(false, Ordering::AcqRel));
		*gate.waker.lock().unwrap() = Some(waiter.waker().clone());
		Poll::Pending
	}
}

fn main() {
	let args: Vec<String> = std::env::args().collect();
	let scenario = args[1].as_str();
	let peak: usize = args[2].parse().unwrap();
	let rounds: usize = args[3].parse().unwrap();
	let waiter = kio::Waiter::noop();

	let base = LIVE.load(Ordering::Relaxed);
	let mut tasks = kio::Tasks::new();
	let gates: Vec<_> = (0..peak).map(|_| Gate::new()).collect();
	let gate_bytes = LIVE.load(Ordering::Relaxed) - base;
	for g in &gates {
		tasks.push(task(g.clone()));
	}
	let _ = tasks.poll(&waiter);

	// Which slots stay live after the burst.
	let live: Vec<usize> = match scenario {
		"survivor_idle" | "survivor_ready" => vec![0],
		"survivor_high_idle" | "survivor_high_ready" => vec![peak - 1],
		"sparse" => (0..peak).step_by(64).collect(),
		"full" => (0..peak).collect(),
		"empty" | "burst" | "churn" => vec![],
		_ => panic!("scenario"),
	};
	let mut keep = vec![false; peak];
	for &i in &live {
		keep[i] = true;
	}
	for (i, g) in gates.iter().enumerate() {
		if !keep[i] {
			g.retire();
		}
	}
	let _ = tasks.poll(&waiter);
	assert_eq!(tasks.len(), live.len());

	let retained = LIVE.load(Ordering::Relaxed) - base - gate_bytes - (live.len() * 0) as isize;
	let allocs0 = ALLOCS.load(Ordering::Relaxed);

	let ready = match scenario {
		"survivor_ready" | "survivor_high_ready" => 1,
		"sparse" | "full" => 16.min(live.len()),
		_ => 0,
	};
	let mut next = 0;
	let mut polls = 0usize;
	for _ in 0..rounds {
		match scenario {
			"burst" => {
				// Repeat the whole burst: push peak, poll, retire all, poll.
				let gs: Vec<_> = (0..peak).map(|_| Gate::new()).collect();
				for g in &gs {
					tasks.push(task(g.clone()));
				}
				let _ = black_box(tasks.poll(&waiter));
				for g in &gs {
					g.retire();
				}
				let _ = black_box(tasks.poll(&waiter));
				polls += 2;
			}
			"churn" => {
				// 16 short tasks through the drained set each round.
				let gs: Vec<_> = (0..16).map(|_| Gate::new()).collect();
				for g in &gs {
					tasks.push(task(g.clone()));
				}
				let _ = black_box(tasks.poll(&waiter));
				for g in &gs {
					g.retire();
				}
				let _ = black_box(tasks.poll(&waiter));
				polls += 2;
			}
			_ => {
				for _ in 0..ready {
					gates[live[next]].fire();
					next = (next + 1) % live.len();
				}
				let _ = black_box(tasks.poll(&waiter));
				polls += 1;
			}
		}
	}
	let allocs = ALLOCS.load(Ordering::Relaxed) - allocs0;
	let after = LIVE.load(Ordering::Relaxed) - base - gate_bytes;
	drop(tasks);
	drop(gates);
	let dropped = LIVE.load(Ordering::Relaxed) - base;
	println!(
		"scenario={scenario} peak={peak} rounds={rounds} polls={polls} live={} retained_after_drain={retained} retained_after_rounds={after} allocs_in_rounds={allocs} after_drop={dropped}",
		live.len()
	);
}
Harness: rs/moq-uring/examples/worker_burst.rs (uncommitted)
//! `worker_burst <peak> <rounds>`: an io_uring worker whose task set once held
//! `peak` spawned tasks (all finished), then `rounds` one-datagram round trips.
use std::net::UdpSocket;

use moq_uring::{Config, Worker, udp};

fn main() {
	let args: Vec<String> = std::env::args().collect();
	let peak: usize = args[1].parse().unwrap();
	let rounds: usize = args[2].parse().unwrap();

	let mut worker = Worker::new(Config::default()).expect("worker");
	let handle = worker.handle();
	let mut config = udp::Config::default();
	config.gro = false;
	config.gso = false;
	config.rx_buffer_len = 2048;
	config.tx_buffer_len = 2048;
	config.rx_buffers_max = 64;
	let bind = || UdpSocket::bind("127.0.0.1:0").expect("bind");
	let sender = handle.udp(bind(), config.clone()).expect("sender");
	let receiver = handle.udp(bind(), config.clone()).expect("receiver");
	let addr = receiver.local_addr().expect("addr");

	// The burst: `peak` connection-like tasks, all finished before measuring.
	for _ in 0..peak {
		handle.spawn(async {});
	}
	let round = || async {
		let mut tx = sender.acquire().await.expect("send buffer");
		tx.extend_from_slice(b"turn");
		tx.send(udp::Transmit::new(addr, 4)).expect("send");
		assert_eq!(receiver.recv().await.expect("receive").payload(), b"turn");
	};
	worker.block_on(round()).expect("worker");
	let turns0 = handle.metrics().snapshot();
	for _ in 0..rounds {
		worker.block_on(round()).expect("worker");
	}
	eprintln!("peak={peak} rounds={rounds} before={turns0:?} after={:?}", handle.metrics().snapshot());
}
Driver scripts
#!/bin/bash
# measure.sh <binary> <label>: instructions per owner poll and allocator stats.
bin=$1; label=$2
count() { taskset -c 2 perf stat --no-scale -x, -e cpu_core/instructions/u "$bin" "$@" 2>&1 >/dev/null | grep instructions | cut -d, -f1; }
for scenario in ${SCENARIOS:-survivor_idle survivor_ready survivor_high_idle survivor_high_ready empty sparse full churn burst}; do
  for peak in ${PEAKS:-1 1024 16384 65536}; do
    case $scenario in sparse|full) [ $peak -lt 1024 ] && continue;; esac
    n=20000; [ $scenario = burst ] && n=$((2000000 / (peak + 16)))
    [ $n -lt 4 ] && n=4
    i0=$(count $scenario $peak 0)
    iN=$(count $scenario $peak $n)
    stats=$(taskset -c 2 "$bin" $scenario $peak $n)
    polls=$(echo "$stats" | sed 's/.*polls=\([0-9]*\).*/\1/')
    per=$(( (iN - i0) / polls ))
    echo "$label $scenario peak=$peak ins_per_poll=$per $(echo $stats | cut -d' ' -f5-)"
  done
done
#!/bin/bash
# measure_worker.sh <binary> <label>: user instructions per datagram round trip.
# RLIMIT_MEMLOCK is shared with every other io_uring user on the host, so a
# failed ring setup is retried.
bin=$1; label=$2
count() {
  for attempt in $(seq 60); do
    out=$(taskset -c 2 perf stat --no-scale -x, -e cpu_core/instructions/u "$bin" "$@" 2>&1 >/dev/null)
    if ! echo "$out" | grep -q "worker:"; then
      echo "$out" | grep instructions | cut -d, -f1
      return
    fi
    sleep 1
  done
  echo FAIL
}
n=20000
for peak in ${PEAKS:-0 1024 16384 65536}; do
  i0=$(count $peak 0)
  iN=$(count $peak $n)
  echo "$label worker peak=$peak ins_per_round=$(( (iN - i0) / n )) i0=$i0 iN=$iN"
done

(Written by Claude Opus 5.5)

🤖 Generated with Claude Code

kixelated and others added 3 commits November 1, 2026 00:41
Tasks::poll swapped every wake-bit word the set ever grew, so a
long-lived set paid for its historical peak on every owner poll. A
three-level index (word bits, a per-chunk summary, one top word in the
shared state) lets a poll swap only woken words: an idle poll is one
swap at any peak. The snapshot is still taken in full before any task
runs, in ascending slot order from the rotation point.

The per-slot waker keeps only its slot index (8 B smaller). New
tasks_capacity_* bench groups sweep historical peak against live and
woken tasks, and the task_capacity bench reports retained bytes. The
quest is rewritten to its remaining memory half.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@kixelated kixelated changed the title Task polling recovers after a burst perf(kio): index task wakes so a poll skips capacity a burst left behind Nov 1, 2026
kixelated and others added 2 commits November 1, 2026 14:34
The maintainer picked (a) on 2026-11-01: land the CPU half as is and keep
the quest for the memory half. The merged toolchain flags the after_burst
return type, which cannot be aliased on stable.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@kixelated
kixelated marked this pull request as ready for review November 1, 2026 22:37
@coderabbitai

coderabbitai Bot commented Nov 1, 2026

Copy link
Copy Markdown
Contributor

Warning

Review limit reached

You've used all free OSS reviews for now. Wait for the free limit to reset to keep reviewing this public repository.

Next included review available in 52 minutes.

Check out review usage here.

View limit details

Limit details: You’ve used all 4 included reviews currently available.

Learn how review limits work.

Review configuration:

Run configuration
  • Source mode: Auto
  • Repository: Unavailable
  • Branch: Unavailable
  • File: No configuration file from this repository applied
  • Commit: Unavailable
  • Layers: Organization UI
  • Review profile: CHILL
  • Plan: Advanced
  • Run ID: f0605d9f-de93-4ced-9a43-38e68a5df478
Commits

Reviewing files that changed from the base of the PR and between bf4e726 and 36e475b.

Files selected for processing: 7
  • quest/m2/perf/uring-quiescence.md
  • quest/m2/performance-survey/README.md
  • quest/m2/performance-survey/task-capacity.md
  • rs/kio/Cargo.toml
  • rs/kio/benches/task_capacity.rs
  • rs/kio/benches/tasks.rs
  • rs/kio/src/task.rs
  • Autofix · Keep fixing CodeRabbit findings and required CI, and resolving merge conflicts

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

Share

@kixelated kixelated left a comment

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

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

Automated review by review (OpenAI)

Reviewed commit: 36e475bf81306e978a27c631a699fb9d20c4d549.

No actionable bugs found. Checked the hierarchical wake marking/clearing order, folded top-word collisions beyond 64 chunks, sparse snapshot ordering and rotation, stale-slot reuse, and the capacity benchmarks/tests. No prior published review findings to carry forward.

Direction: the small index addresses the historical-capacity scan at its source without changing public API, wire format, or one-pass scheduling. Keeping the fixed top word rather than adding a growable hierarchy is a reasonable complexity tradeoff; above 65,536 slots, active polls still visit the chunks sharing a top bit. Separating memory reclamation preserves the existing cheap reuse and stale-waker ownership model.

Verification: GitHub source inspection only; I did not run tests, concurrency tooling, or reproduce the performance measurements.

(Written by OpenAI)

@pullfrog pullfrog Bot 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.

✅ No new issues found.

Reviewed changes

Reviewed the full diff at 36e475bf8, with a focus on the new wake-index algorithm and its concurrency guarantees.

  • rs/kio/src/task.rs — three-level wake index: Chunk.summary marks nonzero words and Shared.ready marks chunks with a marked summary; a wake marks a level above only when it makes that level nonzero, and a poll clears top → summary → word before reading down. Verified the lost-wake invariant by hand: a nonzero word implies its summary was set or a poll already owns the word (which will swap it), and a set summary implies the top bit is set or a poll owns the chunk. The > WORD_BITS sort threshold is exactly where a top bit aliases two chunks, so partition_point plus the wrap masks always see ascending word indices. Rotation and mid-pass snapshot semantics are preserved.
  • SlotWaker shrink: keeps only the absolute slot index and derives word/bit/chunk; the 8 B/slot saving and the extra fetch_ors are bounded and as described.
  • Tests: wakes_past_64_chunks_run_in_slot_order covers aliasing past 64 chunks and rotated order; concurrent_wakes_are_never_lost stresses cross-thread wakes against owner polls. I ran cargo test -p kio --lib task:: on the head — 17 passed, including both new tests.
  • Benches: tasks_capacity_* groups and the task_capacity retained-bytes table; the LIFO/reuse shapes match the quest's deferral of memory reclaim.
  • Quest docs: task-capacity.md is correctly rewritten to the memory half, and the README.md / uring-quiescence.md cross-references are consistent.

No public API or wire impact. The deferred memory half and the optional worker-bench follow-up are recorded as a maintainer decision in the quest, not blockers.

Pullfrog  | Fix it ➔ | View workflow run | Using deepseek-v4.1-flash (free via Pullfrog for OSS) | 𝕏

@kixelated
kixelated enabled auto-merge (squash) November 1, 2026 22:43
@kixelated
kixelated added this pull request to the merge queue Nov 2, 2026
Merged via the queue into main with commit 1b85866 Nov 2, 2026
7 checks passed
@kixelated
kixelated deleted the quest/m2/performance-survey/task-capacity branch November 2, 2026 09:24
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant