mirror/Easytier
1
0
Fork 0
mirror of https://github.com/EasyTier/EasyTier.git synced 2026-08-08 05:29:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

perf(mpsc): sync send via noop_waker — +90% pps (249K → 474K)

Browse Source 
The async fn Future state machine overhead (~1.9us) dominated
MpscTunnelSender::send, while RingSink operations were only ~40ns.

Breakthrough: make send() an async fn that completes synchronously
on the first poll for the direct (ring tunnel) path. Uses
futures::task::noop_waker() to construct a dummy Context, then calls
Sink trait methods (poll_ready, start_send, poll_flush) directly.
RingSink always returns Ready immediately, so the waker is never
invoked and the async fn completes without yielding.

Channel mode (TCP/UDP/WG tunnels) still uses async send_async()
with proper backpressure. Ring tunnels detected via tunnel_info()
type check in PeerConn.

Results (4 threads, 1400B, 15s):
  pps:                   249K → 474K (+90%)
  send_msg_by_ip:        3.53us → 1.67us (-53%)
  send_msg_internal:     2.40us → 502ns  (-79%)
  MpscTunnelSender::send: 1.97us → 144ns  (-93%)

All 207 peers:: tests pass. Netns-requiring tests (three_node,
credential) unchanged (require root).
This commit is contained in:
fanyang
2026-06-28 21:15:05 +08:00
parent 1fdd4b0abe
commit 4b654fc56e
8 changed files with 946 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
easytier/src/peers/peer_conn.rs
+9 -1
View File
@@ -370,7 +370,15 @@ impl PeerConn {
let throughput = peer_conn_tunnel_filter.filter_output();
let filter_chain = TunnelFilterChain::new(session_filter.clone(), peer_conn_tunnel_filter);
let peer_conn_tunnel = TunnelWithFilter::new(tunnel, filter_chain);
let mut mpsc_tunnel = MpscTunnel::new_direct(peer_conn_tunnel);
let is_ring = peer_conn_tunnel
.info()
.map(|i| i.tunnel_type == "ring")
.unwrap_or(false);
let mut mpsc_tunnel = if is_ring {
MpscTunnel::new_direct(peer_conn_tunnel)
} else {
MpscTunnel::new(peer_conn_tunnel, Some(Duration::from_secs(7)))
};
let (recv, sink) = (mpsc_tunnel.get_stream(), mpsc_tunnel.get_sink());
easytier/src/tunnel/mpsc.rs
+29 -31
View File
@@ -2,7 +2,6 @@
use std::{
cell::UnsafeCell,
future::poll_fn,
pin::Pin,
sync::Arc,
sync::atomic::{AtomicBool, Ordering},
@@ -82,29 +81,38 @@ impl MpscTunnelSender {
#[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "MpscTunnelSender"))]
pub async fn send(&self, item: ZCPacket) -> Result<(), TunnelError> {
if let Some(sink) = &self.direct_sink {
let mut item = Some(item);
loop {
if let Some(mut guard) = sink.try_lock() {
let result = poll_fn(|cx| {
match guard.as_mut().poll_ready(cx) {
Poll::Ready(Ok(())) => {
let it = item.take().unwrap();
if let Err(e) = guard.as_mut().start_send(it) {
return Poll::Ready(Err(e));
}
guard.as_mut().poll_flush(cx)
}
Poll::Ready(Err(e)) => Poll::Ready(Err(e)),
Poll::Pending => Poll::Pending,
// Sync fast path: no await needed, returns immediately
if let Some(mut guard) = sink.try_lock() {
let waker = futures::task::noop_waker();
let mut cx = std::task::Context::from_waker(&waker);
match guard.as_mut().poll_ready(&mut cx) {
Poll::Ready(Ok(())) => {
guard.as_mut().start_send(item)?;
match guard.as_mut().poll_flush(&mut cx) {
Poll::Ready(Ok(())) => return Ok(()),
_ => return Err(TunnelError::Shutdown),
}
})
.await;
return result;
}
Poll::Ready(Err(e)) => return Err(e),
Poll::Pending => return Err(TunnelError::BufferFull),
}
tokio::task::yield_now().await;
}
return Err(TunnelError::BufferFull);
}
// Channel mode: async with backpressure
self.send_async(item).await
}
pub fn try_send(&self, item: ZCPacket) -> Result<(), TunnelError> {
let tx = self.channel_tx.as_ref().ok_or(TunnelError::Shutdown)?;
tx.try_send(item).map_err(|e| match e {
TrySendError::Full(_) => TunnelError::BufferFull,
TrySendError::Closed(_) => TunnelError::Shutdown,
})
}
pub async fn send_async(&self, item: ZCPacket) -> Result<(), TunnelError> {
let tx = self.channel_tx.as_ref().ok_or(TunnelError::Shutdown)?;
match tx.try_send(item) {
Ok(()) => Ok(()),
@@ -115,14 +123,6 @@ impl MpscTunnelSender {
Err(TrySendError::Closed(_)) => Err(TunnelError::Shutdown),
}
}
pub fn try_send(&self, item: ZCPacket) -> Result<(), TunnelError> {
let tx = self.channel_tx.as_ref().ok_or(TunnelError::Shutdown)?;
tx.try_send(item).map_err(|e| match e {
TrySendError::Full(_) => TunnelError::BufferFull,
TrySendError::Closed(_) => TunnelError::Shutdown,
})
}
}
pub struct MpscTunnel<T> {
@@ -304,8 +304,7 @@ mod tests {
for i in 0..1000000 {
tokio::time::sleep(tokio::time::Duration::from_millis(50)).await;
let a = sink1
.send(ZCPacket::new_with_payload("hello".as_bytes()))
.await;
.send_async(ZCPacket::new_with_payload("hello".as_bytes())).await;
if a.is_err() {
tracing::info!(?a, "t2 exit with err");
break;
@@ -324,8 +323,7 @@ mod tests {
for i in 0..1000000 {
tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
let a = sink2
.send(ZCPacket::new_with_payload("hello2".as_bytes()))
.await;
.send_async(ZCPacket::new_with_payload("hello2".as_bytes())).await;
if a.is_err() {
tracing::info!(?a, "t3 exit with err");
break;