(2+3+4) concurrency / dpdk

[daniel-noland]

Summary

Introduce a parking_lot-shaped facade over Mutex / RwLock, ship the four backends together (std / parking_lot / shuttle / loom), and rewire the data-path crates through it in a single atomic step.

The four pieces are bundled because a partial sweep leaves the workspace in a state where the facade and its consumers disagree on whether Mutex::lock returns LockResult<Guard> or a naked guard. The shuttle/loom wrappers strip LockResult in exactly the same poison-as-panic shape as the std wrapper, so splitting them re-introduces that disagreement under the test/shuttle and test/loom CI jobs.

std::sync wrapper (poison-as-panic)

• New concurrency::sync module exposing Mutex / RwLock with a parking_lot-shaped naked-guard surface backed by a poison-as-panic wrapper around std::sync. Workspace policy treats a crashed thread as a crashed process: poison surfacing inside a lock acquire panics through concurrency::sync::poisoned() rather than handing back a possibly-torn LockResult.
• One cold #[inline(never)] fn poisoned() -> ! keeps the hot path branch-free; the wrapper is a single match per acquire.
• RwLock::upgradable_read is implemented as exclusive write() for now -- sound but lossy. Documented at the backend module level.
• Arc, Weak, atomics, Condvar, mpsc, OnceLock, etc. are re-exported from std::sync unchanged.

parking_lot as the production default

• Adds a parking_lot Cargo feature (enabled by default) and concurrency/src/sync/parking_lot_backend.rs -- a zero-cost re-export of parking_lot::{Mutex, RwLock} plus the std re-exports for everything parking_lot doesn't ship.
• Backend routing in concurrency/src/sync/mod.rs picks parking_lot_backend when feature = "parking_lot" is on, falls back to std_backend otherwise.
• _strict_provenance feature overrides parking_lot and routes through std_backend: parking_lot_core::word_lock uses integer-to-pointer casts that -Zmiri-strict-provenance rejects, and the CI miri job (--features=_strict_provenance) exercises the fallback slot, which needs std::sync underneath.
• Workspace Cargo.toml gets a tokio parking_lot override entry so the tokio parking_lot feature is enabled workspace-wide.

shuttle backend

• concurrency/src/sync/shuttle_backend.rs mirrors std_backend.rs: a thin poison-as-panic wrap around shuttle::sync::{Mutex, RwLock} returning naked guards, plus re-exports for Arc / Weak / atomics / Condvar / mpsc that pass through unchanged. OnceLock falls back to std::sync because shuttle doesn't ship one.
• Three feature flags share one dep:shuttle, arranged as a chain (shuttle_dfs -> shuttle_pct -> shuttle):
  • shuttle -- random scheduler (default first choice).
  • shuttle_pct -- PCT, biases toward rare interleavings.
  • shuttle_dfs -- DFS, exhaustive small-state exploration.
    Same backend, scheduler chosen at runtime (by concurrency::stress, added in the follow-on PR). The chain means a single feature = "shuttle" cfg check is true under every variant, so the routing in sync/mod.rs collapses to single-feature checks (no any(shuttle, shuttle_pct, shuttle_dfs) chains).

loom backend

• concurrency/src/sync/loom_backend.rs mirrors the std and shuttle wrappers: poison-as-panic around loom::sync::{Mutex, RwLock} returning naked guards, with LockResult / TryLockError / OnceLock etc. re-exported from std::sync because loom doesn't ship them.
• Loom 0.7 has no Weak<T> and no Arc::downgrade. The backend adds a local Arc<T> wrapper that adds downgrade plus a Weak<T> shim that holds a strong clone of the inner loom::sync::Arc until the Weak itself drops. Documented quirks (Weak::upgrade always succeeds after a downgrade, Arc::weak_count panics rather than silently returning 0, last Arc drop does not free when a Weak is live) are explicit at the module level -- silent fallbacks would let assertions pass for the wrong reason on every backend.
• sync/mod.rs routes the loom feature ahead of every other backend.

Workspace transition

• Sweep the data-path crates (flow-entry, flow-filter, nat, net, pipeline, routing, stats) to consume dataplane_concurrency::sync::{Arc, Mutex, RwLock, atomic, ...} instead of std::sync::* / parking_lot::* directly.
• Call sites drop the .unwrap() / .expect("poisoned") noise the LockResult-shaped surface forced, since the facade returns naked guards. Same shape as the existing parking_lot::Mutex consumers.
• concurrency_mode(std) annotations at QSBR-touching test sites in nat::stateful::apalloc::test_alloc, routing::fib::test, and flow-entry::flow_table::table::tests keep the existing std-only feature gating intact.
• nat::portfw::flow_state::get_packet_port_fw_state simplification: the explicit drop(guard) dance before debug! calls is removed (per the recorded author intent that it isn't worth the code complexity); the guard now drops implicitly at the end of scope.

The sweep is mostly mechanical (use rewrites and .unwrap() removal). The semantic change is one step: every consumer now gets the facade-routed primitives, so flipping the loom/shuttle features at the top of the workspace is now meaningful.

PR 2 of 3 in the concurrency facade stack (the original 4-PR plan collapsed the shuttle-only and loom-only PRs into this one because the wrappers, the workspace sweep, and the consumer changes can't be independently merged without leaving CI red). Depends on #1539 -- absorb-quiescent. The follow-on PR (#1544) adds #[concurrency::test], the stress dispatcher, and the thread::scope shim.

[mvachhar]

You need to resolve merge conflicts here so while you are doing that, you should also clean up the commits a bit. There are some changes related to the move of QSBR into concurrency in the second commit when they should be in the first. I think AI should be able to fix that pretty easily so it is worth doing. If it takes too long, it isn't worht it and we can merge as is.

[daniel-noland]

You need to resolve merge conflicts here so while you are doing that, you should also clean up the commits a bit. There are some changes related to the move of QSBR into concurrency in the second commit when they should be in the first. I think AI should be able to fix that pretty easily so it is worth doing. If it takes too long, it isn't worht it and we can merge as is.

Sure. Can scrub it a bit

Err, sorry, #1539 (absorb) is already merged, the QSBR-move-related hunks that leaked into commit 2 are stuck here. There's no commit 1 left on this branch to fold them into

[Copilot]

Pull request overview

This PR introduces a parking_lot-shaped synchronization facade in dataplane-concurrency (concurrency::sync) with selectable backends (std, parking_lot default, shuttle, loom), then performs a workspace-wide migration of datapath crates to consume the facade (and the new Slot/SlotOption publication types) so the workspace builds consistently across backends without LockResult/poison-handling noise.

Changes:

• Add concurrency::sync with backend routing and poison-as-panic wrappers (std/shuttle/loom) plus a zero-cost parking_lot backend.
• Add/extend concurrency::slot::{Slot, SlotOption} and migrate arc-swap call sites to the facade where needed.
• Sweep datapath crates (nat/net/pipeline/routing/stats/flow-*) to use concurrency::sync::{Arc, Mutex, RwLock, atomic, thread} and remove .unwrap() / .expect("poisoned") from lock acquisitions.

Reviewed changes

Copilot reviewed 52 out of 53 changed files in this pull request and generated no comments.

Show a summary per file

File	Description
stats/src/vpc_stats.rs	Drop LockResult unwraps on locks
routing/src/fib/test.rs	Reduce miri workload; gate stdout
routing/src/fib/fibtable.rs	Switch Arc to facade type
routing/src/atable/resolver.rs	Switch atomics/thread/Arc to facade
pipeline/src/static_nf.rs	Switch Arc to facade type
pipeline/src/sample_nfs.rs	Replace ArcSwapOption with SlotOption
pipeline/src/pipeline.rs	Switch Arc/atomics to facade type
pipeline/Cargo.toml	Replace arc-swap dep with concurrency
net/src/packet/stats.rs	Switch atomics to facade re-export
net/src/flows/flow_info.rs	Switch atomics to facade re-export; drop unwraps
net/src/flows/display.rs	Assume naked-guard locks; use facade Weak
net/src/flows/atomic_instant.rs	Switch Ordering import to facade
nat/src/stateful/test.rs	Disable traced_test under miri; drop unwraps
nat/src/stateful/nf.rs	Drop lock unwraps; simplify write path
nat/src/stateful/icmp_handling.rs	Drop lock unwraps on reads
nat/src/stateful/flows.rs	Drop lock unwraps; simplify guards
nat/src/stateful/apalloc/test_alloc.rs	Route shuttle test via facade sync/thread
nat/src/stateful/apalloc/port_alloc.rs	Drop lock unwraps across bitmap/map ops
nat/src/stateful/apalloc/mod.rs	Remove unreachable unwrap on idle timeout
nat/src/stateful/apalloc/display.rs	Update display to new read() signature
nat/src/stateful/apalloc/alloc.rs	Change read() to return guard; idle_timeout non-Option
nat/src/stateful/allocator_writer.rs	Replace ArcSwapOption with SlotOption
nat/src/portfw/test.rs	Drop lock unwraps in tests
nat/src/portfw/portfwtable/portforwarder.rs	Switch Arc to facade type (incl tests)
nat/src/portfw/portfwtable/objects.rs	Switch Arc/atomics to facade types
nat/src/portfw/nf.rs	Switch Arc/Weak; drop lock unwraps
nat/src/portfw/icmp_handling.rs	Drop lock unwraps on reads
nat/src/portfw/flow_state.rs	Switch Arc/Weak; simplify write guards
nat/src/icmp_handler/nf.rs	Switch Arc to facade type; drop unwrap
nat/src/common/mod.rs	Switch Arc/atomics to facade types
nat/Cargo.toml	Add shuttle scheduler feature chain
flow-filter/src/tests.rs	Switch Arc to facade; drop unwraps
flow-filter/src/lib.rs	Switch Arc to facade; drop unwraps
flow-filter/Cargo.toml	Add concurrency dependency
flow-entry/src/flow_table/table.rs	Use facade OnceLock/locks; simplify try_read loop
flow-entry/src/flow_table/nf_lookup.rs	Disable traced_test under miri
flow-entry/src/flow_table/display.rs	Adjust to try_read -> Option facade
flow-entry/Cargo.toml	Add shuttle scheduler feature chain
concurrency/tests/quiescent_protocol.rs	Update docs/imports; use facade sync/thread
concurrency/tests/quiescent_properties.rs	Update docs/imports; use facade sync/atomics
concurrency/src/sync/std_backend.rs	Add std poison-as-panic wrapper backend
concurrency/src/sync/shuttle_backend.rs	Add shuttle poison-as-panic wrapper backend
concurrency/src/sync/parking_lot_backend.rs	Add zero-cost parking_lot backend re-export
concurrency/src/sync/mod.rs	Add backend routing logic/priorities
concurrency/src/sync/loom_backend.rs	Add loom wrapper + Arc/Weak shim
concurrency/src/slot.rs	Add SlotOption; unify slot APIs across backends
concurrency/src/quiescent.rs	Migrate QSBR internals to naked-guard locks
concurrency/src/lib.rs	Expose sync module; remove old pub use ...::sync
concurrency/Cargo.toml	Default to parking_lot; add shuttle feature chain
common/src/cliprovider.rs	Add Slot/SlotOption provider impls
common/Cargo.toml	Add concurrency dependency
Cargo.toml	Workspace deps + tokio parking_lot exception docs
Cargo.lock	Lockfile updates for new deps/features

[Fredi-raspall]

What is the reason to call it slot / slotoption instead of the original ?