refactor(core): remove hotpath profiling (#2394)

hotpath adds noticeable overhead on hot paths, so remove the optional
profiling integration while keeping direct quanta::Instant timing.

easytier/Cargo.toml

@@ -52,7 +52,6 @@ toml = "0.8.12"
 chrono = { version = "0.4.37", features = ["serde"] }
 
 guarden = "0.2"
-hotpath = { version = "0.18", default-features = false, optional = true }
 quanta = "0.12"
 
 delegate = "0.13.5"
@@ -403,17 +402,14 @@ jemalloc-prof = [
     "jemalloc-sys/stats",
 ]
 tracing = ["tokio/tracing", "dep:console-subscriber"]
-hotpath = [
-    "dep:hotpath",
-    "hotpath/hotpath",
-    "hotpath/tokio",
-    "hotpath/parking_lot",
-    "hotpath/flume",
-]
-hotpath-cpu = ["hotpath", "hotpath/hotpath-cpu"]
-hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]
 magic-dns = ["dep:hickory-client", "dep:hickory-server"]
 faketcp = ["dep:flume"]
 zstd = ["dep:zstd"]
+# Deprecated: hotpath profiling has been removed. These feature aliases are
+# retained as no-ops so existing build scripts using `--features hotpath*`
+# continue to work without pulling in any dependencies.
+hotpath = []
+hotpath-cpu = ["hotpath"]
+hotpath-alloc = ["hotpath"]
 # For Network Extension on macOS
 macos-ne = []

easytier/src/common/acl_processor.rs

@@ -6,7 +6,7 @@ use std::{
     time::{Duration, SystemTime, UNIX_EPOCH},
 };
 
-use hotpath::instant::Instant;
+use quanta::Instant;
 
 use crate::common::{config::ConfigLoader, global_ctx::ArcGlobalCtx, token_bucket::TokenBucket};
 use crate::proto::acl::*;

easytier/src/common/stats_manager.rs

@@ -1,5 +1,5 @@
 use dashmap::DashMap;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use serde::{Deserialize, Serialize};
 use std::cell::UnsafeCell;
 use std::fmt;

easytier/src/common/stun.rs

@@ -8,7 +8,7 @@ use crate::proto::common::{NatType, StunInfo};
 use anyhow::Context;
 use chrono::Local;
 use crossbeam::atomic::AtomicCell;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use rand::seq::IteratorRandom;
 use socket2::{SockAddr, SockRef};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};

easytier/src/connector/direct.rs

@@ -11,7 +11,7 @@ use std::{
     time::Duration,
 };
 
-use hotpath::instant::Instant;
+use quanta::Instant;
 
 use crate::{
     common::{

easytier/src/connector/manual.rs

@@ -6,7 +6,7 @@ use std::{
 };
 
 use dashmap::DashSet;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use tokio::{sync::mpsc, task::JoinSet, time::timeout};
 
 use crate::{

easytier/src/connector/tcp_hole_punch.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use anyhow::{Context, Error};
-use hotpath::instant::Instant;
+use quanta::Instant;
 use rand::Rng as _;
 use tokio::task::JoinSet;
 

easytier/src/connector/udp_hole_punch/both_easy_sym.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use anyhow::Context;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use tokio::sync::Mutex;
 use tokio_util::task::AbortOnDropHandle;
 

easytier/src/connector/udp_hole_punch/common.rs

@@ -7,7 +7,7 @@ use std::{
 use crossbeam::atomic::AtomicCell;
 use dashmap::{DashMap, DashSet};
 use guarden::defer;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use rand::seq::SliceRandom as _;
 use tokio::{net::UdpSocket, sync::Mutex, task::JoinSet};
 use tracing::{Instrument, Level, instrument};

easytier/src/connector/udp_hole_punch/cone.rs

@@ -1,7 +1,7 @@
 use std::{sync::Arc, time::Duration};
 
 use anyhow::Context;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use tokio::net::UdpSocket;
 use tokio_util::task::AbortOnDropHandle;
 

easytier/src/connector/udp_hole_punch/mod.rs

@@ -8,8 +8,8 @@ use both_easy_sym::{PunchBothEasySymHoleClient, PunchBothEasySymHoleServer};
 use common::{PunchHoleServerCommon, UdpNatType, UdpPunchClientMethod};
 use cone::{PunchConeHoleClient, PunchConeHoleServer};
 use dashmap::DashMap;
-use hotpath::instant::Instant;
 use once_cell::sync::Lazy;
+use quanta::Instant;
 use sym_to_cone::{PunchSymToConeHoleClient, PunchSymToConeHoleServer};
 use tokio::{sync::Mutex, task::JoinHandle};
 

easytier/src/connector/udp_hole_punch/sym_to_cone.rs

@@ -10,7 +10,7 @@ use std::{
 
 use anyhow::Context;
 use guarden::defer;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use rand::{Rng, seq::SliceRandom};
 use tokio::{net::UdpSocket, sync::RwLock};
 use tokio_util::task::AbortOnDropHandle;

easytier/src/easytier-core.rs

@@ -1,11 +1,5 @@
 use easytier::core;
 
-#[cfg(all(
-    feature = "hotpath-alloc",
-    any(feature = "jemalloc", feature = "mimalloc")
-))]
-compile_error!("feature `hotpath-alloc` cannot be enabled together with `jemalloc` or `mimalloc`");
-
 #[cfg(all(feature = "mimalloc", not(feature = "jemalloc")))]
 use mimalloc::MiMalloc;
 
@@ -30,16 +24,6 @@ pub static malloc_conf: &[u8] = b"retain:false\0";
 rust_i18n::i18n!("locales", fallback = "en");
 
 #[tokio::main(flavor = "current_thread")]
-#[cfg_attr(
-    all(
-        feature = "hotpath",
-        not(all(
-            feature = "hotpath-alloc",
-            any(feature = "jemalloc", feature = "mimalloc")
-        ))
-    ),
-    hotpath::main
-)]
 async fn main() -> std::process::ExitCode {
     core::main().await
 }

easytier/src/gateway/icmp_proxy.rs

@@ -7,13 +7,13 @@ use std::{
 };
 
 use anyhow::Context;
-use hotpath::instant::Instant;
 use pnet::packet::{
     Packet,
     icmp::{self, IcmpCode, IcmpTypes, MutableIcmpPacket, echo_reply::MutableEchoReplyPacket},
     ip::IpNextHeaderProtocols,
     ipv4::Ipv4Packet,
 };
+use quanta::Instant;
 use socket2::Socket;
 use tokio::{
     sync::{Mutex, mpsc::UnboundedSender},

easytier/src/gateway/ip_reassembler.rs

@@ -1,8 +1,8 @@
 use dashmap::DashMap;
-use hotpath::instant::Instant;
 use pnet::packet::Packet;
 use pnet::packet::ip::IpNextHeaderProtocol;
 use pnet::packet::ipv4::{self, Ipv4Flags, Ipv4Packet, MutableIpv4Packet};
+use quanta::Instant;
 use std::net::Ipv4Addr;
 use std::time::Duration;
 

easytier/src/gateway/quic_proxy.rs

@@ -1018,7 +1018,7 @@ impl TcpProxyRpc for QuicProxyDstRpcService {
 mod tests {
     use super::*;
     use bytes::Buf;
-    use hotpath::instant::Instant;
+    use quanta::Instant;
 
     /// Helper function: Create a pair of interconnected QuicSockets.
     /// Data sent by socket_a will enter socket_b's rx, and vice versa.

easytier/src/gateway/socks5.rs

@@ -9,9 +9,9 @@ use std::{
 };
 
 use crossbeam::atomic::AtomicCell;
-use hotpath::instant::Instant;
 #[cfg(feature = "kcp")]
 use kcp_sys::{endpoint::KcpEndpoint, stream::KcpStream};
+use quanta::Instant;
 use tokio_util::sync::{CancellationToken, DropGuard};
 use tokio_util::task::AbortOnDropHandle;
 

easytier/src/gateway/socks5/dataplane.rs

@@ -26,7 +26,7 @@ use std::{
 };
 
 use anyhow::Context as _;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use tokio::io::{AsyncRead, AsyncWrite};
 
 use crate::{common::error::Error, gateway::fast_socks5::server::AsyncTcpConnector};

easytier/src/gateway/tcp_proxy.rs

@@ -3,12 +3,12 @@ use cidr::Ipv4Inet;
 use core::panic;
 use crossbeam::atomic::AtomicCell;
 use dashmap::DashMap;
-use hotpath::instant::Instant;
 use pnet::packet::MutablePacket;
 use pnet::packet::Packet;
 use pnet::packet::ip::IpNextHeaderProtocols;
 use pnet::packet::ipv4::{Ipv4Packet, MutableIpv4Packet};
 use pnet::packet::tcp::{MutableTcpPacket, TcpPacket, ipv4_checksum};
+use quanta::Instant;
 use socket2::{SockRef, TcpKeepalive};
 use std::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
 use std::sync::atomic::{AtomicBool, AtomicU16};

easytier/src/gateway/udp_proxy.rs

@@ -8,13 +8,13 @@ use bytes::{BufMut, BytesMut};
 use cidr::Ipv4Inet;
 use crossbeam::atomic::AtomicCell;
 use dashmap::DashMap;
-use hotpath::instant::Instant;
 use pnet::packet::{
     Packet,
     ip::IpNextHeaderProtocols,
     ipv4::Ipv4Packet,
     udp::{self, MutableUdpPacket},
 };
+use quanta::Instant;
 use tokio::sync::mpsc::{Receiver, Sender, channel, error::TrySendError};
 use tokio::{
     net::UdpSocket,

easytier/src/hotpath_off.rs

@@ -1,40 +0,0 @@
-//! No-op stand-in for the `hotpath` macros used by this crate, selected when
-//! the `hotpath` feature is disabled.
-//!
-//! Keeping `hotpath` as an optional dependency means default builds do not pull
-//! the profiler (or any of its transitive dependencies) into the dependency
-//! graph. These macros expand to their input unchanged, mirroring `hotpath`'s
-//! own disabled mode so call sites compile identically with or without the
-//! feature.
-//!
-//! The macros are `#[macro_export]`-ed so that `lib.rs`' `extern crate self as
-//! hotpath` alias exposes them through the same `hotpath::...` paths used when
-//! the feature is enabled.
-
-/// No-op mirroring `hotpath::channel!`: returns the channel expression
-/// unchanged (dropping any optional trailing `label`/`log`/`capacity` args).
-#[doc(hidden)]
-#[macro_export]
-macro_rules! channel {
-    ($expr:expr $(, $($rest:tt)*)?) => {
-        $expr
-    };
-}
-
-/// No-op mirroring `hotpath::mutex!`: returns the expression unchanged.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! mutex {
-    ($expr:expr $(, $($rest:tt)*)?) => {
-        $expr
-    };
-}
-
-/// No-op mirroring `hotpath::rw_lock!`: returns the expression unchanged.
-#[doc(hidden)]
-#[macro_export]
-macro_rules! rw_lock {
-    ($expr:expr $(, $($rest:tt)*)?) => {
-        $expr
-    };
-}

easytier/src/instance/proxy_cidrs_monitor.rs

@@ -3,7 +3,7 @@ use std::sync::{Arc, Weak};
 
 use crate::common::global_ctx::{ArcGlobalCtx, GlobalCtxEvent};
 use crate::peers::peer_manager::PeerManager;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use tokio_util::task::AbortOnDropHandle;
 
 /// ProxyCidrsMonitor monitors changes in proxy CIDRs from peer routes

easytier/src/lib.rs

@@ -5,29 +5,10 @@ use std::io;
 use clap::Command;
 use clap_complete::{Generator, Shell};
 
-// When the `hotpath` feature is off, alias the current crate as `hotpath` so
-// call sites keep using `hotpath::...` paths, and provide a local no-op shim
-// for the profiling macros. This keeps `hotpath` an optional dependency: the
-// profiler is absent from the dependency graph entirely in default builds.
-#[cfg(not(feature = "hotpath"))]
-extern crate self as hotpath;
-#[cfg(not(feature = "hotpath"))]
-mod hotpath_off;
-
-// When the `hotpath` feature is off, expose a local `instant` module backed by
-// `quanta::Instant` so call sites can uniformly write `use hotpath::instant::Instant;`
-// regardless of whether the feature is enabled. With the feature on, the real
-// `hotpath` crate provides the same path (also `quanta::Instant` on Linux), so
-// the two modes resolve to the identical type.
-#[cfg(not(feature = "hotpath"))]
-pub mod instant {
-    pub type Instant = quanta::Instant;
-}
-
 // Re-export `Instant` at the crate root so public APIs that expose it
 // (e.g. `Route::get_peer_info_last_update_time`) reference a deliberate
 // public type rather than leaking an inaccessible one.
-pub use hotpath::instant::Instant;
+pub use quanta::Instant;
 
 mod arch;
 mod gateway;

easytier/src/peers/acl_filter.rs

@@ -7,11 +7,11 @@ use std::{
 
 use arc_swap::ArcSwap;
 use dashmap::DashMap;
-use hotpath::instant::Instant;
 use pnet::packet::ipv6::Ipv6Packet;
 use pnet::packet::{
     Packet as _, ip::IpNextHeaderProtocols, ipv4::Ipv4Packet, tcp::TcpPacket, udp::UdpPacket,
 };
+use quanta::Instant;
 
 use crate::proto::acl::{AclStats, Protocol};
 use crate::tunnel::packet_def::PacketType;
@@ -404,7 +404,7 @@ mod tests {
         sync::Arc,
     };
 
-    use hotpath::instant::Instant;
+    use quanta::Instant;
 
     use crate::{
         common::acl_processor::PacketInfo,

easytier/src/peers/mod.rs

@@ -59,7 +59,7 @@ type BoxNicPacketFilter = Box<dyn NicPacketFilter + Send + Sync>;
 pub type PacketRecvChan = tokio::sync::mpsc::Sender<ZCPacket>;
 pub type PacketRecvChanReceiver = tokio::sync::mpsc::Receiver<ZCPacket>;
 pub fn create_packet_recv_chan() -> (PacketRecvChan, PacketRecvChanReceiver) {
-    hotpath::channel!(tokio::sync::mpsc::channel(128))
+    tokio::sync::mpsc::channel(128)
 }
 pub async fn recv_packet_from_chan(
     packet_recv_chan_receiver: &mut PacketRecvChanReceiver,

easytier/src/peers/peer.rs

@@ -207,7 +207,6 @@ impl Peer {
             .map(|conn| conn.clone())
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "Peer"))]
     pub async fn send_msg(&self, msg: ZCPacket) -> Result<(), Error> {
         let Some(conn) = self.select_conn().await else {
             return Err(Error::PeerNoConnectionError(self.peer_node_id));

easytier/src/peers/peer_conn.rs

@@ -11,9 +11,6 @@ use std::{
     },
 };
 
-#[cfg(feature = "hotpath")]
-use hotpath::wrap::tokio::sync::Mutex;
-#[cfg(not(feature = "hotpath"))]
 use tokio::sync::Mutex;
 
 use base64::Engine as _;
@@ -384,12 +381,12 @@ impl PeerConn {
             session_filter,
             noise_handshake_result: None,
 
-            tunnel: Arc::new(hotpath::mutex!(tokio::sync::Mutex::new(Box::new(
-                guard!([mut mpsc_tunnel] mpsc_tunnel.close()),
-            )
-                as Box<dyn Any + Send + 'static>))),
+            tunnel: Arc::new(Mutex::new(
+                Box::new(guard!([mut mpsc_tunnel] mpsc_tunnel.close()))
+                    as Box<dyn Any + Send + 'static>,
+            )),
             sink,
-            recv: hotpath::mutex!(tokio::sync::Mutex::new(Some(recv))),
+            recv: Mutex::new(Some(recv)),
             tunnel_info,
 
             tasks: JoinSet::new(),
@@ -1466,7 +1463,6 @@ impl PeerConn {
         });
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "PeerConn"))]
     pub async fn send_msg(&self, msg: ZCPacket) -> Result<(), Error> {
         Ok(self.sink.send(msg).await?)
     }

easytier/src/peers/peer_conn_ping.rs

@@ -6,7 +6,7 @@ use std::{
     time::Duration,
 };
 
-use hotpath::instant::Instant;
+use quanta::Instant;
 use rand::{Rng, thread_rng};
 use tokio::{
     sync::broadcast,

easytier/src/peers/peer_manager.rs

@@ -2,7 +2,7 @@ use anyhow::Context;
 use async_trait::async_trait;
 use cidr::{Ipv4Cidr, Ipv6Cidr};
 use dashmap::DashMap;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use std::collections::BTreeSet;
 use std::{
     fmt::Debug,
@@ -11,9 +11,6 @@ use std::{
     time::{Duration, SystemTime},
 };
 
-#[cfg(feature = "hotpath")]
-use hotpath::wrap::tokio::sync::{Mutex, RwLock};
-#[cfg(not(feature = "hotpath"))]
 use tokio::sync::{Mutex, RwLock};
 use tokio::{
     sync::mpsc::{self, UnboundedReceiver, UnboundedSender},
@@ -279,8 +276,8 @@ impl PeerManager {
         let rpc_tspt = Arc::new(RpcTransport {
             my_peer_id,
             peers: Arc::downgrade(&peers),
-            foreign_peers: hotpath::mutex!(tokio::sync::Mutex::new(None)),
-            packet_recv: hotpath::mutex!(tokio::sync::Mutex::new(peer_rpc_tspt_recv)),
+            foreign_peers: Mutex::new(None),
+            packet_recv: Mutex::new(peer_rpc_tspt_recv),
             peer_rpc_tspt_sender,
             encryptor: encryptor.clone(),
             is_secure_mode_enabled,
@@ -412,21 +409,17 @@ impl PeerManager {
             global_ctx,
             nic_channel,
 
-            tasks: hotpath::mutex!(tokio::sync::Mutex::new(JoinSet::new())),
+            tasks: Mutex::new(JoinSet::new()),
 
-            packet_recv: Arc::new(hotpath::mutex!(tokio::sync::Mutex::new(Some(packet_recv)))),
+            packet_recv: Arc::new(Mutex::new(Some(packet_recv))),
 
             peers,
 
             peer_rpc_mgr,
             peer_rpc_tspt: rpc_tspt,
 
-            peer_packet_process_pipeline: Arc::new(hotpath::rw_lock!(tokio::sync::RwLock::new(
-                Vec::new()
-            ))),
-            nic_packet_process_pipeline: Arc::new(hotpath::rw_lock!(tokio::sync::RwLock::new(
-                Vec::new()
-            ))),
+            peer_packet_process_pipeline: Arc::new(RwLock::new(Vec::new())),
+            nic_packet_process_pipeline: Arc::new(RwLock::new(Vec::new())),
 
             route_algo_inst,
 
@@ -437,7 +430,7 @@ impl PeerManager {
             encryptor,
             data_compress_algo,
 
-            exit_nodes: hotpath::rw_lock!(tokio::sync::RwLock::new(exit_nodes)),
+            exit_nodes: RwLock::new(exit_nodes),
 
             reserved_my_peer_id_map: DashMap::new(),
             recent_have_traffic: Arc::new(DashMap::new()),
@@ -1444,7 +1437,6 @@ impl PeerManager {
         self.get_route().get_foreign_network_summary().await
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "PeerManager"))]
     async fn run_nic_packet_process_pipeline(&self, data: &mut ZCPacket) -> bool {
         // Enforce ACL for outbound (NIC-originated) packets. If ACL denies, stop processing.
         if !self.global_ctx.get_acl_filter().process_packet_with_acl(
@@ -1530,7 +1522,6 @@ impl PeerManager {
         result
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "PeerManager"))]
     async fn send_msg_internal(
         peers: &Arc<PeerMap>,
         foreign_network_client: &Arc<ForeignNetworkClient>,
@@ -2207,7 +2198,7 @@ mod tests {
     use base64::Engine;
     use std::{collections::HashMap, fmt::Debug, sync::Arc, time::Duration};
 
-    use hotpath::instant::Instant;
+    use quanta::Instant;
 
     use crate::{
         common::{

easytier/src/peers/peer_map.rs

@@ -132,7 +132,6 @@ impl PeerMap {
         peer_id == self.my_peer_id || self.peer_map.contains_key(&peer_id)
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "PeerMap"))]
     pub async fn send_msg_directly(&self, msg: ZCPacket, dst_peer_id: PeerId) -> Result<(), Error> {
         if dst_peer_id == self.my_peer_id {
             let packet_send = self.packet_send.clone();
@@ -164,7 +163,6 @@ impl PeerMap {
         Ok(())
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "PeerMap"))]
     pub async fn get_gateway_peer_id(
         &self,
         dst_peer_id: PeerId,

easytier/src/peers/peer_ospf_route.rs

@@ -13,7 +13,6 @@ use arc_swap::ArcSwap;
 use cidr::{IpCidr, Ipv4Cidr, Ipv6Cidr, Ipv6Inet};
 use crossbeam::atomic::AtomicCell;
 use dashmap::DashMap;
-use hotpath::instant::Instant;
 use ordered_hash_map::OrderedHashMap;
 use parking_lot::{RwLock, lock_api::RwLockUpgradableReadGuard};
 use petgraph::{
@@ -25,6 +24,7 @@ use petgraph::{
 use prefix_trie::PrefixMap;
 use prost::Message;
 use prost_reflect::{DynamicMessage, ReflectMessage};
+use quanta::Instant;
 use tokio::{
     select,
     sync::Mutex,
@@ -1394,7 +1394,6 @@ impl RouteTable {
         }
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "RouteTable"))]
     fn get_next_hop(&self, dst_peer_id: PeerId) -> Option<NextHopInfo> {
         if self.suppressed_peer_ids.contains_key(&dst_peer_id) {
             return None;
@@ -1402,7 +1401,6 @@ impl RouteTable {
         self.get_topology_next_hop(dst_peer_id)
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "RouteTable"))]
     fn get_topology_next_hop(&self, dst_peer_id: PeerId) -> Option<NextHopInfo> {
         let cur_version = self.next_hop_map_version.get();
         self.next_hop_map.get(&dst_peer_id).and_then(|x| {

easytier/src/peers/peer_session.rs

@@ -7,7 +7,7 @@ use std::time::Duration;
 use anyhow::anyhow;
 use crossbeam::atomic::AtomicCell;
 use dashmap::DashMap;
-use hotpath::instant::Instant;
+use quanta::Instant;
 
 use super::secure_datagram::{SecureDatagramDirection, SecureDatagramSession};
 use crate::{
@@ -376,7 +376,6 @@ impl PeerSession {
         }
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "PeerSession"))]
     pub fn encrypt_payload(
         &self,
         sender_peer_id: PeerId,
@@ -390,7 +389,6 @@ impl PeerSession {
             .encrypt_payload(Self::dir_for_sender(sender_peer_id, receiver_peer_id), pkt)
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "PeerSession"))]
     pub fn decrypt_payload(
         &self,
         sender_peer_id: PeerId,

easytier/src/peers/relay_peer_map.rs

@@ -1,8 +1,8 @@
 use std::sync::Arc;
 
 use dashmap::DashMap;
-use hotpath::instant::Instant;
 use prost::Message;
+use quanta::Instant;
 use snow::params::NoiseParams;
 use tokio::sync::{Mutex, OwnedMutexGuard, oneshot};
 use tokio::time::{Duration, timeout};

easytier/src/peers/route_trait.rs

@@ -1,7 +1,7 @@
 use cidr::Ipv6Inet;
 use cidr::{Ipv4Cidr, Ipv6Cidr};
 use dashmap::DashMap;
-use hotpath::instant::Instant;
+use quanta::Instant;
 use std::{
     collections::BTreeSet,
     net::{Ipv4Addr, Ipv6Addr},

easytier/src/peers/secure_datagram.rs

@@ -701,10 +701,6 @@ impl SecureDatagramSession {
         false
     }
 
-    #[cfg_attr(
-        feature = "hotpath",
-        hotpath::measure(impl_type = "SecureDatagramSession")
-    )]
     pub fn encrypt_payload(
         &self,
         dir: SecureDatagramDirection,
@@ -723,10 +719,6 @@ impl SecureDatagramSession {
         Ok(())
     }
 
-    #[cfg_attr(
-        feature = "hotpath",
-        hotpath::measure(impl_type = "SecureDatagramSession")
-    )]
     pub fn decrypt_payload(
         &self,
         dir: SecureDatagramDirection,

easytier/src/proto/rpc_impl/client.rs

@@ -5,8 +5,8 @@ use std::sync::{Arc, Mutex};
 use bytes::Bytes;
 use dashmap::DashMap;
 use guarden::defer;
-use hotpath::instant::Instant;
 use prost::Message;
+use quanta::Instant;
 use tokio::sync::mpsc;
 use tokio::task::JoinSet;
 use tokio::time::timeout;

easytier/src/proto/rpc_impl/packet.rs

@@ -1,6 +1,6 @@
 use prost::{Message as _, length_delimiter_len};
 
-use hotpath::instant::Instant;
+use quanta::Instant;
 
 use crate::{
     common::{PeerId, compressor::DefaultCompressor},

easytier/src/proto/rpc_impl/server.rs

@@ -5,8 +5,8 @@ use std::{
 
 use bytes::Bytes;
 use dashmap::DashMap;
-use hotpath::instant::Instant;
 use prost::Message;
+use quanta::Instant;
 use tokio::{task::JoinSet, time::timeout};
 use tokio_stream::StreamExt;
 

easytier/src/tunnel/fake_tcp/stack.rs

@@ -159,7 +159,7 @@ impl Socket {
         ack: Option<u32>,
         state: State,
     ) -> (Socket, flume::Sender<Bytes>) {
-        let (incoming_tx, incoming_rx) = hotpath::channel!(flume::bounded(MPMC_BUFFER_LEN));
+        let (incoming_tx, incoming_rx) = flume::bounded(MPMC_BUFFER_LEN);
 
         (
             Socket {

easytier/src/tunnel/mpsc.rs

@@ -43,7 +43,7 @@ pub struct MpscTunnel<T> {
 
 impl<T: Tunnel> MpscTunnel<T> {
     pub fn new(tunnel: T, send_timeout: Option<Duration>) -> Self {
-        let (tx, mut rx) = hotpath::channel!(channel(32));
+        let (tx, mut rx) = channel(32);
         let (stream, mut sink) = tunnel.split();
 
         let task = tokio::spawn(async move {
@@ -66,7 +66,6 @@ impl<T: Tunnel> MpscTunnel<T> {
         }
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "MpscTunnel"))]
     async fn forward_one_round(
         rx: &mut Receiver<ZCPacket>,
         sink: &mut Pin<Box<dyn ZCPacketSink>>,
@@ -80,7 +79,6 @@ impl<T: Tunnel> MpscTunnel<T> {
         }
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "MpscTunnel"))]
     async fn forward_one_round_no_timeout(
         rx: &mut Receiver<ZCPacket>,
         sink: &mut Pin<Box<dyn ZCPacketSink>>,
@@ -98,7 +96,6 @@ impl<T: Tunnel> MpscTunnel<T> {
         sink.flush().await
     }
 
-    #[cfg_attr(feature = "hotpath", hotpath::measure(impl_type = "MpscTunnel"))]
     async fn forward_one_round_with_timeout(
         rx: &mut Receiver<ZCPacket>,
         sink: &mut Pin<Box<dyn ZCPacketSink>>,

easytier/src/tunnel/ring.rs

@@ -11,7 +11,7 @@ use async_trait::async_trait;
 use futures::{Sink, SinkExt, Stream, StreamExt};
 use once_cell::sync::Lazy;
 
-use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender};
+use tokio::sync::mpsc::{UnboundedReceiver, UnboundedSender, unbounded_channel};
 
 use uuid::Uuid;
 
@@ -196,8 +196,7 @@ pub struct RingTunnelListener {
 
 impl RingTunnelListener {
     pub fn new(key: url::Url) -> Self {
-        let (conn_sender, conn_receiver) =
-            hotpath::channel!(tokio::sync::mpsc::unbounded_channel());
+        let (conn_sender, conn_receiver) = unbounded_channel();
         RingTunnelListener {
             listener_addr: key,
             conn_sender,

easytier/src/tunnel/udp.rs

@@ -15,7 +15,9 @@ use zerocopy::{AsBytes, FromBytes};
 
 use tokio::{
     net::UdpSocket,
-    sync::mpsc::{Receiver, Sender, UnboundedReceiver, UnboundedSender},
+    sync::mpsc::{
+        Receiver, Sender, UnboundedReceiver, UnboundedSender, channel, unbounded_channel,
+    },
     task::JoinSet,
 };
 use tokio_util::task::AbortOnDropHandle;
@@ -673,9 +675,8 @@ pub struct UdpTunnelListener {
 
 impl UdpTunnelListener {
     pub fn new(addr: url::Url) -> Self {
-        let (close_event_send, close_event_recv) =
-            hotpath::channel!(tokio::sync::mpsc::unbounded_channel());
-        let (conn_send, conn_recv) = hotpath::channel!(tokio::sync::mpsc::channel(100));
+        let (close_event_send, close_event_recv) = unbounded_channel();
+        let (conn_send, conn_recv) = channel(100);
         Self {
             addr: addr.clone(),
             socket: None,
@@ -915,8 +916,7 @@ impl UdpTunnelConnector {
             "udp build tunnel for connector"
         );
 
-        let (close_event_sender, mut close_event_recv) =
-            hotpath::channel!(tokio::sync::mpsc::unbounded_channel());
+        let (close_event_sender, mut close_event_recv) = unbounded_channel();
 
         let ring_recv = RingStream::new(ring_for_send_udp.clone());
         let ring_sender = RingSink::new(ring_for_recv_udp.clone());

easytier/src/tunnel/wireguard.rs

@@ -6,7 +6,7 @@ use std::{
     time::Duration,
 };
 
-use hotpath::instant::Instant;
+use quanta::Instant;
 
 use super::{
     FromUrl, IpVersion, Tunnel, TunnelError, TunnelInfo, TunnelListener, TunnelUrl, ZCPacketSink,
@@ -37,7 +37,11 @@ use crossbeam::atomic::AtomicCell;
 use dashmap::DashMap;
 use futures::{SinkExt, StreamExt, stream::FuturesUnordered};
 use rand::RngCore;
-use tokio::{net::UdpSocket, sync::Mutex, task::JoinSet};
+use tokio::{
+    net::UdpSocket,
+    sync::{Mutex, mpsc::unbounded_channel},
+    task::JoinSet,
+};
 
 const MAX_PACKET: usize = 2048;
 
@@ -470,7 +474,7 @@ pub struct WgTunnelListener {
 
 impl WgTunnelListener {
     pub fn new(addr: url::Url, config: WgConfig) -> Self {
-        let (conn_send, conn_recv) = hotpath::channel!(tokio::sync::mpsc::unbounded_channel());
+        let (conn_send, conn_recv) = unbounded_channel();
         WgTunnelListener {
             addr,
             config,