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/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,