session manager support output fieldstat

46 files changed, 3234 insertions, 3167 deletions

diff --git a/infra/packet_io/pcap_io.c b/infra/packet_io/pcap_io.c
index ba294f9..3a3cf4e 100644
--- a/infra/packet_io/pcap_io.c
+++ b/infra/packet_io/pcap_io.c
@@ -333,7 +333,7 @@ static void *pcap_io_thread(void *arg)
             fclose(fp);
         }
     }
-    PCAP_IO_LOG_FATAL("pcap io thread read all pcap files");
+    PACKET_IO_LOG_FATAL("pcap io thread read all pcap files (files: %lu, pkts: %lu)", pcap_io->read_pcap_files, ATOMIC_READ(&pcap_io->read_pcap_pkts));
 
 erro_out:
     while (ATOMIC_READ(&pcap_io->io_thread_need_exit) == 0)
@@ -346,7 +346,7 @@ erro_out:
         usleep(1000); // 1ms
     }
 
-    PCAP_IO_LOG_FATAL("pcap io thread exit (read_pcap_files: %lu, read_pcap_pkts: %lu)", pcap_io->read_pcap_files, ATOMIC_READ(&pcap_io->read_pcap_pkts));
+    PACKET_IO_LOG_FATAL("pcap io thread exit");
     ATOMIC_SET(&pcap_io->io_thread_is_runing, 0);
 
     return NULL;
diff --git a/infra/packet_manager/packet_manager.c b/infra/packet_manager/packet_manager.c
index 5623107..be36103 100644
--- a/infra/packet_manager/packet_manager.c
+++ b/infra/packet_manager/packet_manager.c
@@ -36,6 +36,10 @@ struct packet_manager
     struct packet_manager_runtime *runtime[MAX_THREAD_NUM];
 };
 
+/******************************************************************************
+ * packet manager runtime
+ ******************************************************************************/
+
 const char *packet_stage_to_str(enum packet_stage stage)
 {
     switch (stage)
diff --git a/infra/session_manager/CMakeLists.txt b/infra/session_manager/CMakeLists.txt
index a045740..0fa2260 100644
--- a/infra/session_manager/CMakeLists.txt
+++ b/infra/session_manager/CMakeLists.txt
@@ -5,12 +5,14 @@ add_library(session_manager
     session_timer.c
     session_filter.c
     session_transition.c
-    session_manager_runtime.c
     session_manager.c
+    session_manager_cfg.c
+    session_manager_rte.c
+    session_manager_stat.c
 )
 target_include_directories(session_manager PUBLIC ${CMAKE_CURRENT_LIST_DIR})
 target_include_directories(session_manager PUBLIC ${CMAKE_SOURCE_DIR}/infra/)
 target_include_directories(session_manager PUBLIC ${CMAKE_SOURCE_DIR}/include)
-target_link_libraries(session_manager timeout packet_manager tcp_reassembly mq exdata)
+target_link_libraries(session_manager timeout packet_manager tcp_reassembly mq exdata fieldstat4)
 
 add_subdirectory(test)
\ No newline at end of file
diff --git a/infra/session_manager/session_filter.c b/infra/session_manager/session_filter.c
index 6fe0ef1..8a3c40f 100644
--- a/infra/session_manager/session_filter.c
+++ b/infra/session_manager/session_filter.c
@@ -1,4 +1,3 @@
-#include "tuple.h"
 #include "dablooms.h"
 #include "session_filter.h"
 
diff --git a/infra/session_manager/session_filter.h b/infra/session_manager/session_filter.h
index 13f5236..f8be6a2 100644
--- a/infra/session_manager/session_filter.h
+++ b/infra/session_manager/session_filter.h
@@ -5,11 +5,10 @@ extern "C"
 {
 #endif
 
+#include "tuple.h"
+
 struct session_filter *session_filter_new(uint32_t capacity, uint32_t timeout, double error_rate, uint64_t now);
 void session_filter_free(struct session_filter *filter);
-
-// return 1: found
-// reutrn 0: no found
 int session_filter_lookup(struct session_filter *filter, const struct tuple6 *key, uint64_t now);
 void session_filter_add(struct session_filter *filter, const struct tuple6 *key, uint64_t now);
 
diff --git a/infra/session_manager/session_internal.h b/infra/session_manager/session_internal.h
index 51413dc..34cba4a 100644
--- a/infra/session_manager/session_internal.h
+++ b/infra/session_manager/session_internal.h
@@ -10,9 +10,10 @@ extern "C"
 #include "tuple.h"
 #include "uthash.h"
 #include "timeout.h"
+#include "tcp_reassembly.h"
 #include "packet_internal.h"
 #include "stellar/session.h"
-#include "tcp_reassembly.h"
+#include "session_manager_stat.h"
 
 // output format: "${src_addr}:${src_port}-${dst_addr}:${dst_port}-${ip_proto}-${domain}"
 // output max len: (46 + 1 + 5) + 1 + (46 + 1 + 5) + 1 + 1 + 1 + 20 = 129
@@ -50,7 +51,7 @@ struct session
     struct tcp_segment empty_seg;
     TAILQ_ENTRY(session) lru_tqe;
     TAILQ_ENTRY(session) free_tqe;
-    TAILQ_ENTRY(session) evicte_tqe;
+    TAILQ_ENTRY(session) evc_tqe;
     UT_hash_handle hh1;
     UT_hash_handle hh2;
     UT_hash_handle hh3;
@@ -68,7 +69,7 @@ struct session
     enum session_type sess_type;
     enum session_state state;
     enum closing_reason reason;
-    struct session_manager_runtime *sess_mgr_rt;
+    struct session_manager_rte *sess_mgr_rte;
     struct session_manager_stat *sess_mgr_stat;
 };
 
diff --git a/infra/session_manager/session_manager.c b/infra/session_manager/session_manager.c
index 7fd0805..83f84c0 100644
--- a/infra/session_manager/session_manager.c
+++ b/infra/session_manager/session_manager.c
@@ -1,365 +1,376 @@
 #include <assert.h>
-#include <stdlib.h>
-
-#include "stellar/packet.h"
-#include "stellar/session.h"
 
 #include "utils_internal.h"
 #include "session_internal.h"
-#include "session_manager_runtime.h"
-
-#define MAX_CLEANED_SESS 1024
+#include "session_manager_log.h"
+#include "session_manager_cfg.h"
+#include "session_manager_rte.h"
+#include "session_manager_stat.h"
+#include "fieldstat/fieldstat_easy.h"
+
+#define SYNC_STAT_INTERVAL_MS 1000
+#define CLEAN_SESSION_BURST 1024
 #define SESSION_MANAGER_MODULE_NAME "session_manager_module"
 
 #pragma GCC diagnostic ignored "-Wunused-parameter"
-#pragma GCC diagnostic ignored "-Wunused-function"
 
-struct session_manager_schema
+struct session_manager_sche
 {
-    struct exdata_schema *exdata;
-    struct mq_schema *mq;
-
-    int pkt_exdata_idx;
-
-    int topic_id_tcp;
-    int topic_id_udp;
-    int topic_id_ctrl_pkt;
-    int topic_id_tcp_stream;
+     int pkt_ex_id;
+     int sess_msg_id_tcp;
+     int sess_msg_id_udp;
+     int sess_msg_id_ctrl;
+     int sess_msg_id_stream;
+
+     struct mq_schema *mq_sche;
+     struct exdata_schema *ex_sche;
 };
 
 struct session_manager
 {
-    struct session_manager_config *cfg;
-    struct session_manager_schema *schema;
-    struct session_manager_runtime *runtime[MAX_THREAD_NUM];
-    struct stellar_module_manager *mod_mgr;
+     int stat_idx[SESS_MGR_STAT_MAX];
+     struct fieldstat_easy *fs;
+     struct session_manager_cfg *cfg;
+     struct session_manager_sche *sche;
+     struct session_manager_rte *rte[MAX_THREAD_NUM];
+     struct mq_runtime *mq[MAX_THREAD_NUM];
+     struct stellar_module_manager *mod_mgr;
 };
 
 /******************************************************************************
- * callback
+ * session manager sche
  ******************************************************************************/
 
-static void on_session_message_dispatch(int topic_id, void *msg, on_msg_cb_func *cb, void *cb_args, void *dispatch_args)
+static void clean_closed_session(struct session_manager *sess_mgr, uint16_t thread_id, uint64_t now_ms)
 {
-    struct session *sess = (struct session *)msg;
-    struct packet *pkt = (struct packet *)session_get0_current_packet(sess);
-    enum session_state state = session_get_current_state(sess);
-
-    ((on_session_message_callback *)(void *)cb)(sess, state, pkt, cb_args);
+     struct session *sess = NULL;
+     struct session *cleaned[CLEAN_SESSION_BURST] = {NULL};
+     struct mq_runtime *mq_rte = sess_mgr->mq[thread_id];
+     struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id];
+
+     uint64_t used = session_manager_rte_clean_session(sess_mgr_rte, now_ms, cleaned, CLEAN_SESSION_BURST);
+     for (uint64_t i = 0; i < used; i++)
+     {
+          sess = cleaned[i];
+          assert(session_get_current_state(sess) == SESSION_STATE_CLOSED);
+          session_set_current_packet(sess, NULL);
+          session_set_flow_type(sess, FLOW_TYPE_NONE);
+
+          if (session_get_type(sess) == SESSION_TYPE_TCP)
+          {
+               mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_stream, &sess->empty_seg);
+               mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_ctrl, sess);
+               mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_tcp, sess);
+          }
+          else
+          {
+               mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_ctrl, sess);
+               mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_udp, sess);
+          }
+     }
 }
 
-static void on_tcp_payload_message_dispatch(int topic_id, void *msg, on_msg_cb_func *cb, void *cb_args, void *dispatch_args)
+static void on_sess_msg_dispatch(int sess_msg_id, void *msg, on_msg_cb_func *msg_cb, void *msg_cb_args, void *dispatch_args)
 {
-    struct tcp_segment *seg = (struct tcp_segment *)msg;
-    struct session *sess = (struct session *)seg->user_data;
-    enum session_state state = session_get_current_state(sess);
+     struct session *sess = (struct session *)msg;
+     struct packet *pkt = (struct packet *)session_get0_current_packet(sess);
+     enum session_state state = session_get_current_state(sess);
 
-    ((on_tcp_payload_callback *)(void *)cb)(sess, state, seg->data, seg->len, cb_args);
+     ((on_session_message_callback *)(void *)msg_cb)(sess, state, pkt, msg_cb_args);
 }
 
-static void on_tcp_payload_message_free(void *msg, void *args)
+static void on_tcp_payload_msg_dispatch(int sess_msg_id, void *msg, on_msg_cb_func *msg_cb, void *msg_cb_args, void *dispatch_args)
 {
-    struct tcp_segment *seg = (struct tcp_segment *)msg;
-    struct session *sess = (struct session *)seg->user_data;
+     struct tcp_segment *seg = (struct tcp_segment *)msg;
+     struct session *sess = (struct session *)seg->user_data;
+     enum session_state state = session_get_current_state(sess);
 
-    session_free_tcp_segment(sess, seg);
+     ((on_tcp_payload_callback *)(void *)msg_cb)(sess, state, seg->data, seg->len, msg_cb_args);
 }
 
-static void on_session_message_free(void *msg, void *args)
+static void on_sess_msg_free(void *msg, void *args)
 {
-    struct session *sess = (struct session *)msg;
-
-    if (session_get_current_state(sess) == SESSION_STATE_CLOSED)
-    {
-        struct session_manager *sess_mgr = (struct session_manager *)args;
-        int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr);
-        struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id];
-
-        char buffer[4096] = {0};
-        session_to_str(sess, 0, buffer, sizeof(buffer));
-        SESSION_MANAGER_LOG_INFO("session free: %s", buffer);
-
-        struct exdata_runtime *exdata_rt = (struct exdata_runtime *)session_get_user_data(sess);
-        exdata_runtime_free(exdata_rt);
-        session_manager_runtime_free_session(sess_mgr_rt, sess);
-    }
+     struct session *sess = (struct session *)msg;
+
+     if (session_get_current_state(sess) == SESSION_STATE_CLOSED)
+     {
+          struct session_manager *sess_mgr = (struct session_manager *)args;
+          int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr);
+          struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id];
+
+          char buffer[4096] = {0};
+          session_to_str(sess, 0, buffer, sizeof(buffer));
+          SESSION_MANAGER_LOG_INFO("session free: %s", buffer);
+
+          struct exdata_runtime *exdata_rt = (struct exdata_runtime *)session_get_user_data(sess);
+          exdata_runtime_free(exdata_rt);
+          session_manager_rte_free_session(sess_mgr_rte, sess);
+     }
+}
+
+static void on_tcp_payload_msg_free(void *msg, void *args)
+{
+     struct tcp_segment *seg = (struct tcp_segment *)msg;
+     struct session *sess = (struct session *)seg->user_data;
+
+     session_free_tcp_segment(sess, seg);
 }
 
 static void on_packet_forward(struct packet *pkt, enum packet_stage stage, void *args)
 {
-    struct session_manager *sess_mgr = (struct session_manager *)args;
-    int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr);
-    struct mq_runtime *mq_rt = stellar_module_manager_get_mq_runtime(sess_mgr->mod_mgr);
-    struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id];
-
-    /*
-     * We use the system's real time instead of monotonic time for the following reasons:
-     *     -> Session creation/closure times require real time (e.g., for logging session activities).
-     *     -> Session ID generation relies on real time        (e.g., for reverse calculating session creation time from the session ID).
-     *
-     * Note: Modifying the system time will affect the timing wheel, impacting session expiration, and TCP reassembly expiration.
-     * Suggestion: After modifying the system time, restart the service to ensure consistent timing.
-     */
-    uint64_t now_ms = clock_get_real_time_ms();
-
-    struct tuple6 key;
-    struct tcp_segment *seg = NULL;
-    struct session *sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, pkt);
-    if (sess == NULL)
-    {
-        if (packet_is_ctrl(pkt))
-        {
-            goto fast_path;
-        }
-
-        sess = session_manager_runtime_new_session(sess_mgr_rt, pkt, now_ms);
-        if (sess == NULL)
-        {
-            goto fast_path;
-        }
-        else
-        {
-            session_set_user_data(sess, exdata_runtime_new(sess_mgr->schema->exdata));
-            goto slow_path;
-        }
-    }
-    else
-    {
-        if (packet_is_ctrl(pkt))
-        {
-            goto ctrl_path;
-        }
-
-        if (session_manager_runtime_update_session(sess_mgr_rt, sess, pkt, now_ms) == -1)
-        {
-            goto fast_path;
-        }
-        else
-        {
-            goto slow_path;
-        }
-    }
+     struct session_manager *sess_mgr = (struct session_manager *)args;
+     int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr);
+     struct mq_runtime *mq_rte = sess_mgr->mq[thread_id];
+     struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id];
+
+     /*
+      * We use the system's real time instead of monotonic time for the following reasons:
+      *     -> Session creation/closure times require real time (e.g., for logging session activities).
+      *     -> Session ID generation relies on real time        (e.g., for reverse calculating session creation time from the session ID).
+      *
+      * Note: Modifying the system time will affect the timing wheel, impacting session expiration, and TCP reassembly expiration.
+      * Suggestion: After modifying the system time, restart the service to ensure consistent timing.
+      */
+     uint64_t now_ms = clock_get_real_time_ms();
+
+     struct tuple6 key;
+     struct tcp_segment *seg = NULL;
+     struct session *sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, pkt);
+     if (sess == NULL)
+     {
+          if (packet_is_ctrl(pkt))
+          {
+               goto fast_path;
+          }
+
+          sess = session_manager_rte_new_session(sess_mgr_rte, pkt, now_ms);
+          if (sess == NULL)
+          {
+               goto fast_path;
+          }
+          else
+          {
+               session_set_user_data(sess, exdata_runtime_new(sess_mgr->sche->ex_sche));
+               goto slow_path;
+          }
+     }
+     else
+     {
+          if (packet_is_ctrl(pkt))
+          {
+               goto ctrl_path;
+          }
+
+          if (session_manager_rte_update_session(sess_mgr_rte, sess, pkt, now_ms) == -1)
+          {
+               goto fast_path;
+          }
+          else
+          {
+               goto slow_path;
+          }
+     }
 
 ctrl_path:
-    session_set_current_packet(sess, pkt);
-    packet_get_innermost_tuple6(pkt, &key);
-    if (tuple6_cmp(session_get_tuple6(sess), &key) == 0)
-    {
-        session_set_flow_type(sess, FLOW_TYPE_C2S);
-    }
-    else
-    {
-        session_set_flow_type(sess, FLOW_TYPE_S2C);
-    }
-    packet_set_exdata(pkt, sess_mgr->schema->pkt_exdata_idx, sess);
-    mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_ctrl_pkt, sess);
-    return;
+     session_set_current_packet(sess, pkt);
+     packet_get_innermost_tuple6(pkt, &key);
+     if (tuple6_cmp(session_get_tuple6(sess), &key) == 0)
+     {
+          session_set_flow_type(sess, FLOW_TYPE_C2S);
+     }
+     else
+     {
+          session_set_flow_type(sess, FLOW_TYPE_S2C);
+     }
+     packet_set_exdata(pkt, sess_mgr->sche->pkt_ex_id, sess);
+     mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_ctrl, sess);
+     return;
 
 slow_path:
-    if (session_get_type(sess) == SESSION_TYPE_TCP)
-    {
-        mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_tcp, sess);
-        while ((seg = session_get_tcp_segment(sess)))
-        {
-            mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_tcp_stream, seg);
-        }
-    }
-    else
-    {
-        mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_udp, sess);
-    }
-    packet_set_exdata(pkt, sess_mgr->schema->pkt_exdata_idx, sess);
-    return;
+     if (session_get_type(sess) == SESSION_TYPE_TCP)
+     {
+          mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_tcp, sess);
+          while ((seg = session_get_tcp_segment(sess)))
+          {
+               mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_stream, seg);
+          }
+     }
+     else
+     {
+          mq_runtime_publish_message(mq_rte, sess_mgr->sche->sess_msg_id_udp, sess);
+     }
+     packet_set_exdata(pkt, sess_mgr->sche->pkt_ex_id, sess);
+     return;
 
 fast_path:
-    packet_set_exdata(pkt, sess_mgr->schema->pkt_exdata_idx, NULL);
-    return;
+     packet_set_exdata(pkt, sess_mgr->sche->pkt_ex_id, NULL);
+     return;
 }
 
 static void on_packet_output(struct packet *pkt, enum packet_stage stage, void *args)
 {
-    struct session_manager *sess_mgr = (struct session_manager *)args;
-    int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr);
-    struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id];
-
-    struct session *sess = (struct session *)packet_get_exdata(pkt, sess_mgr->schema->pkt_exdata_idx);
-    if (sess)
-    {
-        struct tuple6 key;
-        enum flow_type flow = FLOW_TYPE_NONE;
-        packet_get_innermost_tuple6(pkt, &key);
-        if (tuple6_cmp(session_get_tuple6(sess), &key) == 0)
-        {
-            flow = FLOW_TYPE_C2S;
-        }
-        else
-        {
-            flow = FLOW_TYPE_S2C;
-        }
-
-        int is_ctrl = packet_is_ctrl(pkt);
-        uint16_t len = packet_get_raw_len(pkt);
-        switch (packet_get_action(pkt))
-        {
-        case PACKET_ACTION_DROP:
-            session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1);
-            session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len);
-            break;
-        case PACKET_ACTION_FORWARD:
-            session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1);
-            session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len);
-            break;
-        default:
-            assert(0);
-            break;
-        }
-
-        session_set_current_packet(sess, NULL);
-        session_set_flow_type(sess, FLOW_TYPE_NONE);
-    }
-
-    if (packet_get_origin(pkt) == NULL)
-    {
-        session_manager_runtime_record_duplicated_packet(sess_mgr_rt, pkt);
-    }
-}
-
-static void publish_session_closed_message_batch(struct session_manager *sess_mgr, uint16_t thread_id, uint64_t now_ms)
-{
-    struct session *sess = NULL;
-    struct session *cleaned[MAX_CLEANED_SESS] = {NULL};
-    struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id];
-    struct mq_runtime *mq_rt = stellar_module_manager_get_mq_runtime(sess_mgr->mod_mgr);
-
-    uint64_t used = session_manager_runtime_clean_session(sess_mgr_rt, now_ms, cleaned, MAX_CLEANED_SESS);
-    for (uint64_t i = 0; i < used; i++)
-    {
-        sess = cleaned[i];
-        assert(session_get_current_state(sess) == SESSION_STATE_CLOSED);
-        session_set_current_packet(sess, NULL);
-        session_set_flow_type(sess, FLOW_TYPE_NONE);
-
-        if (session_get_type(sess) == SESSION_TYPE_TCP)
-        {
-            mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_tcp_stream, &sess->empty_seg);
-            mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_ctrl_pkt, sess);
-            mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_tcp, sess);
-        }
-        else
-        {
-            mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_ctrl_pkt, sess);
-            mq_runtime_publish_message(mq_rt, sess_mgr->schema->topic_id_udp, sess);
-        }
-    }
+     struct session_manager *sess_mgr = (struct session_manager *)args;
+     int thread_id = stellar_module_manager_get_thread_id(sess_mgr->mod_mgr);
+     struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id];
+
+     struct session *sess = (struct session *)packet_get_exdata(pkt, sess_mgr->sche->pkt_ex_id);
+     if (sess)
+     {
+          struct tuple6 key;
+          enum flow_type flow = FLOW_TYPE_NONE;
+          packet_get_innermost_tuple6(pkt, &key);
+          if (tuple6_cmp(session_get_tuple6(sess), &key) == 0)
+          {
+               flow = FLOW_TYPE_C2S;
+          }
+          else
+          {
+               flow = FLOW_TYPE_S2C;
+          }
+
+          int is_ctrl = packet_is_ctrl(pkt);
+          uint16_t len = packet_get_raw_len(pkt);
+          switch (packet_get_action(pkt))
+          {
+          case PACKET_ACTION_DROP:
+               session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_PACKETS_DROPPED : STAT_RAW_PACKETS_DROPPED), 1);
+               session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_BYTES_DROPPED : STAT_RAW_BYTES_DROPPED), len);
+               break;
+          case PACKET_ACTION_FORWARD:
+               session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_PACKETS_TRANSMITTED : STAT_RAW_PACKETS_TRANSMITTED), 1);
+               session_inc_stat(sess, flow, (is_ctrl ? STAT_CONTROL_BYTES_TRANSMITTED : STAT_RAW_BYTES_TRANSMITTED), len);
+               break;
+          default:
+               assert(0);
+               break;
+          }
+
+          session_set_current_packet(sess, NULL);
+          session_set_flow_type(sess, FLOW_TYPE_NONE);
+     }
+
+     if (packet_get_origin(pkt) == NULL)
+     {
+          session_manager_rte_record_duplicated_packet(sess_mgr_rte, pkt);
+     }
 }
 
 static void on_polling(struct stellar_module_manager *mod_mgr, void *args)
 {
-    uint64_t now_ms = clock_get_real_time_ms();
-    struct session_manager *sess_mgr = (struct session_manager *)args;
-    int thread_id = stellar_module_manager_get_thread_id(mod_mgr);
-
-    publish_session_closed_message_batch(sess_mgr, thread_id, now_ms);
-    // TODO
-    // ouput stat to fs4
+     uint64_t now_ms = clock_get_real_time_ms();
+     struct session_manager *sess_mgr = (struct session_manager *)args;
+     int thread_id = stellar_module_manager_get_thread_id(mod_mgr);
+     struct session_manager_rte *sess_mgr_rte = sess_mgr->rte[thread_id];
+     struct session_manager_stat *sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
+
+     clean_closed_session(sess_mgr, thread_id, now_ms);
+
+     static __thread uint64_t last_sync_stat_ms = 0;
+     static __thread struct session_manager_stat last_stat = {0};
+     if (now_ms - last_sync_stat_ms >= SYNC_STAT_INTERVAL_MS)
+     {
+          for (int i = 0; i < SESS_MGR_STAT_MAX; i++)
+          {
+               uint64_t val = session_manager_stat_get(sess_mgr_stat, i) - session_manager_stat_get(&last_stat, i);
+               fieldstat_easy_counter_incrby(sess_mgr->fs, thread_id, sess_mgr->stat_idx[i], NULL, 0, val);
+          }
+          last_stat = *sess_mgr_stat;
+          last_sync_stat_ms = now_ms;
+     }
 }
 
-/******************************************************************************
- * session manager schema
- ******************************************************************************/
-
-void session_manager_schema_free(struct session_manager_schema *sess_mgr_schema)
+static void session_manager_sche_free(struct session_manager_sche *sess_mgr_schema)
 {
-    if (sess_mgr_schema)
-    {
-        if (sess_mgr_schema->mq)
-        {
-            mq_schema_destroy_topic(sess_mgr_schema->mq, sess_mgr_schema->topic_id_tcp);
-            mq_schema_destroy_topic(sess_mgr_schema->mq, sess_mgr_schema->topic_id_udp);
-            mq_schema_destroy_topic(sess_mgr_schema->mq, sess_mgr_schema->topic_id_ctrl_pkt);
-            mq_schema_destroy_topic(sess_mgr_schema->mq, sess_mgr_schema->topic_id_tcp_stream);
-        }
-        exdata_schema_free(sess_mgr_schema->exdata);
-
-        free(sess_mgr_schema);
-        sess_mgr_schema = NULL;
-    }
+     if (sess_mgr_schema)
+     {
+          if (sess_mgr_schema->mq_sche)
+          {
+               mq_schema_destroy_topic(sess_mgr_schema->mq_sche, sess_mgr_schema->sess_msg_id_tcp);
+               mq_schema_destroy_topic(sess_mgr_schema->mq_sche, sess_mgr_schema->sess_msg_id_udp);
+               mq_schema_destroy_topic(sess_mgr_schema->mq_sche, sess_mgr_schema->sess_msg_id_ctrl);
+               mq_schema_destroy_topic(sess_mgr_schema->mq_sche, sess_mgr_schema->sess_msg_id_stream);
+          }
+          exdata_schema_free(sess_mgr_schema->ex_sche);
+
+          free(sess_mgr_schema);
+          sess_mgr_schema = NULL;
+     }
 }
 
-struct session_manager_schema *session_manager_schema_new(struct packet_manager *pkt_mgr, struct mq_schema *mq, void *sess_mgr)
+static struct session_manager_sche *session_manager_sche_new(struct packet_manager *pkt_mgr, struct mq_schema *mq_sche, void *sess_mgr)
 {
-    if (packet_manager_subscribe(pkt_mgr, PACKET_STAGE_FORWARD, on_packet_forward, sess_mgr))
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to subscribe PACKET_STAGE_FORWARD");
-        return NULL;
-    }
-    if (packet_manager_subscribe(pkt_mgr, PACKET_STAGE_OUTPUT, on_packet_output, sess_mgr))
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to subscribe PACKET_STAGE_OUTPUT");
-        return NULL;
-    }
-
-    struct session_manager_schema *sess_mgr_schema = calloc(1, sizeof(struct session_manager_schema));
-    if (sess_mgr_schema == NULL)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to allocate memory for session_manager_schema");
-        return NULL;
-    }
-
-    sess_mgr_schema->exdata = exdata_schema_new();
-    if (sess_mgr_schema->exdata == NULL)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to create exdata_schema");
-        goto error_out;
-    }
-
-    sess_mgr_schema->mq = mq;
-    sess_mgr_schema->pkt_exdata_idx = packet_manager_new_packet_exdata_index(pkt_mgr, "session_manager", NULL, NULL);
-    if (sess_mgr_schema->pkt_exdata_idx == -1)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to create packet exdata index");
-        goto error_out;
-    }
-
-    /*
-     * Publish session closed messages to multiple topics.
-     * Each topic has its own session message free callback.
-     * To prevent the same session from being freeed multiple times,
-     * only TCP/UDP topics register session message free callbacks,
-     * and other topics do not register session message callbacks;
-     *
-     * Restriction: MQ ensures that the session message free order is consistent with the publishing order
-     */
-    sess_mgr_schema->topic_id_tcp = mq_schema_create_topic(sess_mgr_schema->mq, "SESSIOM_MANAGER_TOPIC_TCP", &on_session_message_dispatch, NULL, &on_session_message_free, sess_mgr);
-    if (sess_mgr_schema->topic_id_tcp == -1)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to create topic SESSIOM_MANAGER_TOPIC_FREE");
-        goto error_out;
-    }
-    sess_mgr_schema->topic_id_udp = mq_schema_create_topic(sess_mgr_schema->mq, "SESSIOM_MANAGER_TOPIC_UDP", &on_session_message_dispatch, NULL, &on_session_message_free, sess_mgr);
-    if (sess_mgr_schema->topic_id_udp == -1)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to create topic SESSIOM_MANAGER_TOPIC_UDP");
-        goto error_out;
-    }
-    sess_mgr_schema->topic_id_ctrl_pkt = mq_schema_create_topic(sess_mgr_schema->mq, "SESSIOM_MANAGER_TOPIC_CTRL_PKT", &on_session_message_dispatch, NULL, NULL, NULL);
-    if (sess_mgr_schema->topic_id_ctrl_pkt == -1)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to create topic SESSIOM_MANAGER_TOPIC_CTRL_PKT");
-        goto error_out;
-    }
-    sess_mgr_schema->topic_id_tcp_stream = mq_schema_create_topic(sess_mgr_schema->mq, "SESSIOM_MANAGER_TOPIC_TCP_STREAM", &on_tcp_payload_message_dispatch, NULL, &on_tcp_payload_message_free, sess_mgr);
-    if (sess_mgr_schema->topic_id_tcp_stream == -1)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to create topic SESSIOM_MANAGER_TOPIC_TCP_STREAM");
-        goto error_out;
-    }
-
-    return sess_mgr_schema;
+     if (packet_manager_subscribe(pkt_mgr, PACKET_STAGE_FORWARD, on_packet_forward, sess_mgr))
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to subscribe PACKET_STAGE_FORWARD");
+          return NULL;
+     }
+     if (packet_manager_subscribe(pkt_mgr, PACKET_STAGE_OUTPUT, on_packet_output, sess_mgr))
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to subscribe PACKET_STAGE_OUTPUT");
+          return NULL;
+     }
+
+     struct session_manager_sche *sess_mgr_schema = calloc(1, sizeof(struct session_manager_sche));
+     if (sess_mgr_schema == NULL)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to allocate memory for session_manager_sche");
+          return NULL;
+     }
+
+     sess_mgr_schema->ex_sche = exdata_schema_new();
+     if (sess_mgr_schema->ex_sche == NULL)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create exdata_schema");
+          goto error_out;
+     }
+
+     sess_mgr_schema->mq_sche = mq_sche;
+     sess_mgr_schema->pkt_ex_id = packet_manager_new_packet_exdata_index(pkt_mgr, "session_manager", NULL, NULL);
+     if (sess_mgr_schema->pkt_ex_id == -1)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create packet exdata index");
+          goto error_out;
+     }
+
+     /*
+      * Publish session closed messages to multiple topics.
+      * Each topic has its own session message free callback.
+      * To prevent the same session from being freeed multiple times,
+      * only TCP/UDP topics register session message free callbacks,
+      * and other topics do not register session message callbacks;
+      *
+      * Restriction: MQ ensures that the session message free order is consistent with the publishing order
+      */
+     sess_mgr_schema->sess_msg_id_tcp = mq_schema_create_topic(sess_mgr_schema->mq_sche, "SESSION_MESSAGE_TCP", &on_sess_msg_dispatch, NULL, &on_sess_msg_free, sess_mgr);
+     if (sess_mgr_schema->sess_msg_id_tcp == -1)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create topic SESSION_MESSAGE_FREE");
+          goto error_out;
+     }
+     sess_mgr_schema->sess_msg_id_udp = mq_schema_create_topic(sess_mgr_schema->mq_sche, "SESSION_MESSAGE_UDP", &on_sess_msg_dispatch, NULL, &on_sess_msg_free, sess_mgr);
+     if (sess_mgr_schema->sess_msg_id_udp == -1)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create topic SESSION_MESSAGE_UDP");
+          goto error_out;
+     }
+     sess_mgr_schema->sess_msg_id_ctrl = mq_schema_create_topic(sess_mgr_schema->mq_sche, "SESSION_MESSAGE_CTRL_PKT", &on_sess_msg_dispatch, NULL, NULL, NULL);
+     if (sess_mgr_schema->sess_msg_id_ctrl == -1)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create topic SESSION_MESSAGE_CTRL_PKT");
+          goto error_out;
+     }
+     sess_mgr_schema->sess_msg_id_stream = mq_schema_create_topic(sess_mgr_schema->mq_sche, "SESSION_MESSAGE_TCP_STREAM", &on_tcp_payload_msg_dispatch, NULL, &on_tcp_payload_msg_free, sess_mgr);
+     if (sess_mgr_schema->sess_msg_id_stream == -1)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create topic SESSION_MESSAGE_TCP_STREAM");
+          goto error_out;
+     }
+
+     return sess_mgr_schema;
 
 error_out:
-    session_manager_schema_free(sess_mgr_schema);
-    return NULL;
+     session_manager_sche_free(sess_mgr_schema);
+     return NULL;
 }
 
 /******************************************************************************
@@ -368,130 +379,145 @@ error_out:
 
 void session_manager_free(struct session_manager *sess_mgr)
 {
-    if (sess_mgr)
-    {
-        session_manager_schema_free(sess_mgr->schema);
-        session_manager_config_free(sess_mgr->cfg);
-        free(sess_mgr);
-    }
+     if (sess_mgr)
+     {
+          if (sess_mgr->sche)
+          {
+               session_manager_sche_free(sess_mgr->sche);
+          }
+          if (sess_mgr->fs)
+          {
+               fieldstat_easy_free(sess_mgr->fs);
+          }
+          if (sess_mgr->cfg)
+          {
+               session_manager_cfg_free(sess_mgr->cfg);
+          }
+          free(sess_mgr);
+     }
 }
 
-struct session_manager *session_manager_new(struct stellar_module_manager *mod_mgr, struct packet_manager *pkt_mgr, struct mq_schema *mq_schema, const char *toml_file)
+static struct session_manager *session_manager_new(struct packet_manager *pkt_mgr, struct mq_schema *mq_schema, const char *toml_file)
 {
-    struct session_manager *sess_mgr = calloc(1, sizeof(struct session_manager));
-    if (sess_mgr == NULL)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to allocate memory for session_manager");
-        return NULL;
-    }
-
-    sess_mgr->cfg = session_manager_config_new(toml_file);
-    if (sess_mgr->cfg == NULL)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to create session_manager_config");
-        goto error_out;
-    }
-    session_manager_config_print(sess_mgr->cfg);
-
-    sess_mgr->schema = session_manager_schema_new(pkt_mgr, mq_schema, sess_mgr);
-    if (sess_mgr->schema == NULL)
-    {
-        goto error_out;
-    }
-
-    stellar_module_manager_polling_subscribe(mod_mgr, on_polling, sess_mgr);
-
-    return sess_mgr;
+     struct session_manager *sess_mgr = calloc(1, sizeof(struct session_manager));
+     if (sess_mgr == NULL)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to allocate memory for session_manager");
+          return NULL;
+     }
+
+     sess_mgr->cfg = session_manager_cfg_new(toml_file);
+     if (sess_mgr->cfg == NULL)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create session_manager_cfg");
+          goto error_out;
+     }
+     session_manager_cfg_print(sess_mgr->cfg);
+
+     sess_mgr->fs = fieldstat_easy_new(sess_mgr->cfg->thread_num, "session_manager", NULL, 0);
+     if (sess_mgr->fs == NULL)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create fieldstat_easy");
+          goto error_out;
+     }
+     for (int i = 0; i < SESS_MGR_STAT_MAX; i++)
+     {
+          sess_mgr->stat_idx[i] = fieldstat_easy_register_counter(sess_mgr->fs, sess_mgr_stat_str[i]);
+     }
+     if (fieldstat_easy_enable_auto_output(sess_mgr->fs, "session_manager.fs4", 2) != 0)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to enable auto output");
+          goto error_out;
+     }
+
+     sess_mgr->sche = session_manager_sche_new(pkt_mgr, mq_schema, sess_mgr);
+     if (sess_mgr->sche == NULL)
+     {
+          goto error_out;
+     }
+
+     return sess_mgr;
 
 error_out:
-    session_manager_free(sess_mgr);
-    return NULL;
+     session_manager_free(sess_mgr);
+     return NULL;
 }
 
 int session_manager_new_session_exdata_index(struct session_manager *sess_mgr, const char *name, exdata_free *func, void *arg)
 {
-    assert(sess_mgr);
-    assert(name);
-
-    return exdata_schema_new_index(sess_mgr->schema->exdata, name, func, arg);
+     assert(sess_mgr);
+     assert(name);
+     assert(func);
+     return exdata_schema_new_index(sess_mgr->sche->ex_sche, name, func, arg);
 }
 
 int session_manager_subscribe_tcp(struct session_manager *sess_mgr, on_session_message_callback *cb, void *args)
 {
-    assert(sess_mgr);
-    assert(cb);
-
-    return mq_schema_subscribe(sess_mgr->schema->mq, sess_mgr->schema->topic_id_tcp, (on_msg_cb_func *)(void *)cb, args);
+     assert(sess_mgr);
+     assert(cb);
+     return mq_schema_subscribe(sess_mgr->sche->mq_sche, sess_mgr->sche->sess_msg_id_tcp, (on_msg_cb_func *)(void *)cb, args);
 }
 
 int session_manager_subscribe_udp(struct session_manager *sess_mgr, on_session_message_callback *cb, void *args)
 {
-    assert(sess_mgr);
-    assert(cb);
-
-    return mq_schema_subscribe(sess_mgr->schema->mq, sess_mgr->schema->topic_id_udp, (on_msg_cb_func *)(void *)cb, args);
+     assert(sess_mgr);
+     assert(cb);
+     return mq_schema_subscribe(sess_mgr->sche->mq_sche, sess_mgr->sche->sess_msg_id_udp, (on_msg_cb_func *)(void *)cb, args);
 }
 
 int session_manager_subscribe_control_packet(struct session_manager *sess_mgr, on_session_message_callback *cb, void *args)
 {
-    assert(sess_mgr);
-    assert(cb);
-
-    return mq_schema_subscribe(sess_mgr->schema->mq, sess_mgr->schema->topic_id_ctrl_pkt, (on_msg_cb_func *)(void *)cb, args);
+     assert(sess_mgr);
+     assert(cb);
+     return mq_schema_subscribe(sess_mgr->sche->mq_sche, sess_mgr->sche->sess_msg_id_ctrl, (on_msg_cb_func *)(void *)cb, args);
 }
 
 int session_manager_subscribe_tcp_stream(struct session_manager *sess_mgr, on_tcp_payload_callback *cb, void *args)
 {
-    assert(sess_mgr);
-    assert(cb);
-
-    return mq_schema_subscribe(sess_mgr->schema->mq, sess_mgr->schema->topic_id_tcp_stream, (on_msg_cb_func *)(void *)cb, args);
+     assert(sess_mgr);
+     assert(cb);
+     return mq_schema_subscribe(sess_mgr->sche->mq_sche, sess_mgr->sche->sess_msg_id_stream, (on_msg_cb_func *)(void *)cb, args);
 }
 
-int session_manager_init(struct session_manager *sess_mgr, uint16_t thread_id)
+int session_manager_init(struct session_manager *sess_mgr, uint16_t thread_id, struct mq_runtime *mq_rte)
 {
-    assert(sess_mgr);
-    assert(thread_id < sess_mgr->cfg->thread_num);
-    uint64_t now_ms = clock_get_real_time_ms();
-
-    sess_mgr->cfg->session_id_seed = sess_mgr->cfg->instance_id << 8 | thread_id;
-    struct session_manager_runtime *sess_mgr_rt = session_manager_runtime_new(sess_mgr->cfg, now_ms);
-    if (sess_mgr_rt == NULL)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to create session_manager_runtime");
-        return -1;
-    }
-    else
-    {
-        sess_mgr->runtime[thread_id] = sess_mgr_rt;
-        return 0;
-    }
+     assert(sess_mgr);
+     uint64_t now_ms = clock_get_real_time_ms();
+
+     sess_mgr->cfg->session_id_seed = sess_mgr->cfg->instance_id << 8 | thread_id;
+     sess_mgr->mq[thread_id] = mq_rte;
+     sess_mgr->rte[thread_id] = session_manager_rte_new(sess_mgr->cfg, now_ms);
+     if (sess_mgr->rte[thread_id] == NULL)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create session_manager_rte");
+          return -1;
+     }
+     else
+     {
+          return 0;
+     }
 }
 
 void session_manager_clean(struct session_manager *sess_mgr, uint16_t thread_id)
 {
-    assert(sess_mgr);
-    assert(thread_id < sess_mgr->cfg->thread_num);
-
-    struct mq_runtime *mq_rt = stellar_module_manager_get_mq_runtime(sess_mgr->mod_mgr);
-    struct session_manager_runtime *sess_mgr_rt = sess_mgr->runtime[thread_id];
-    if (sess_mgr_rt == NULL)
-    {
-        return;
-    }
-
-    struct session_manager_stat *stat = session_manager_runtime_get_stat(sess_mgr_rt);
-    while (stat->tcp_sess_used || stat->udp_sess_used)
-    {
-        publish_session_closed_message_batch(sess_mgr, thread_id, UINT64_MAX);
-        // here we need to dispatch the message to ensure that the session is cleaned up
-        mq_runtime_dispatch(mq_rt);
-    }
-
-    SESSION_MANAGER_LOG_INFO("runtime: %p, idx: %d, will be cleaned", sess_mgr_rt, thread_id);
-    session_manager_runtime_print_stat(sess_mgr_rt);
-    session_manager_runtime_free(sess_mgr_rt);
-    sess_mgr_rt = NULL;
+     assert(sess_mgr);
+
+     struct mq_runtime *mq_rte = sess_mgr->mq[thread_id];
+     if (sess_mgr->rte[thread_id] == NULL)
+     {
+          return;
+     }
+
+     struct session_manager_stat *stat = session_manager_rte_get_stat(sess_mgr->rte[thread_id]);
+     while (stat->tcp_sess_used || stat->udp_sess_used)
+     {
+          clean_closed_session(sess_mgr, thread_id, UINT64_MAX);
+          // here we need to dispatch the message to ensure that the session is cleaned up
+          mq_runtime_dispatch(mq_rte);
+     }
+
+     session_manager_rte_free(sess_mgr->rte[thread_id]);
+     sess_mgr->rte[thread_id] = NULL;
 }
 
 /******************************************************************************
@@ -500,78 +526,81 @@ void session_manager_clean(struct session_manager *sess_mgr, uint16_t thread_id)
 
 struct session_manager *stellar_module_get_session_manager(struct stellar_module_manager *mod_mgr)
 {
-    assert(mod_mgr);
-    struct stellar_module *sess_mgr_mod = stellar_module_manager_get_module(mod_mgr, SESSION_MANAGER_MODULE_NAME);
-    if (sess_mgr_mod == NULL)
-    {
-        return NULL;
-    }
-    return stellar_module_get_ctx(sess_mgr_mod);
+     assert(mod_mgr);
+     struct stellar_module *sess_mgr_mod = stellar_module_manager_get_module(mod_mgr, SESSION_MANAGER_MODULE_NAME);
+     if (sess_mgr_mod == NULL)
+     {
+          return NULL;
+     }
+     return stellar_module_get_ctx(sess_mgr_mod);
 }
 
 struct stellar_module *session_manager_on_init(struct stellar_module_manager *mod_mgr)
 {
-    assert(mod_mgr);
-    struct packet_manager *pkt_mgr = stellar_module_get_packet_manager(mod_mgr);
-    assert(pkt_mgr);
-    struct mq_schema *mq_schema = stellar_module_manager_get_mq_schema(mod_mgr);
-    assert(mq_schema);
-    const char *toml_file = stellar_module_manager_get_toml_path(mod_mgr);
-    assert(toml_file);
-
-    struct session_manager *sess_mgr = session_manager_new(mod_mgr, pkt_mgr, mq_schema, toml_file);
-    if (sess_mgr == NULL)
-    {
-        return NULL;
-    }
-
-    struct stellar_module *sess_mgr_mod = stellar_module_new(SESSION_MANAGER_MODULE_NAME, NULL);
-    if (sess_mgr_mod == NULL)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to create session_manager");
-        session_manager_free(sess_mgr);
-        return NULL;
-    }
-    stellar_module_set_ctx(sess_mgr_mod, sess_mgr);
-
-    SESSION_MANAGER_LOG_FATAL("session_manager init");
-    return sess_mgr_mod;
+     assert(mod_mgr);
+     struct packet_manager *pkt_mgr = stellar_module_get_packet_manager(mod_mgr);
+     assert(pkt_mgr);
+     struct mq_schema *mq_schema = stellar_module_manager_get_mq_schema(mod_mgr);
+     assert(mq_schema);
+     const char *toml_file = stellar_module_manager_get_toml_path(mod_mgr);
+     assert(toml_file);
+
+<<<<<<< HEAD
+     struct session_manager *sess_mgr = session_manager_new(mod_mgr, pkt_mgr, mq_schema, toml_file);
+=======
+     struct session_manager *sess_mgr = session_manager_new(pkt_mgr, mq_sche, toml_file);
+>>>>>>> 6e4d813 (bugfix sess)
+     if (sess_mgr == NULL)
+     {
+          return NULL;
+     }
+     stellar_module_manager_polling_subscribe(mod_mgr, on_polling, sess_mgr);
+
+     struct stellar_module *sess_mgr_mod = stellar_module_new(SESSION_MANAGER_MODULE_NAME, NULL);
+     if (sess_mgr_mod == NULL)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to create session_manager");
+          session_manager_free(sess_mgr);
+          return NULL;
+     }
+     stellar_module_set_ctx(sess_mgr_mod, sess_mgr);
+
+     SESSION_MANAGER_LOG_FATAL("session_manager init");
+     return sess_mgr_mod;
 }
 
-void session_manager_on_exit(struct stellar_module_manager *mod_mgr __attribute__((unused)), struct stellar_module *mod)
+void session_manager_on_exit(struct stellar_module_manager *mod_mgr, struct stellar_module *mod)
 {
-    if (mod)
-    {
-        struct session_manager *sess_mgr = stellar_module_get_ctx(mod);
-
-        session_manager_free(sess_mgr);
-        stellar_module_free(mod);
-        SESSION_MANAGER_LOG_FATAL("session_manager exit");
-    }
+     if (mod)
+     {
+          struct session_manager *sess_mgr = stellar_module_get_ctx(mod);
+          session_manager_free(sess_mgr);
+          stellar_module_free(mod);
+          SESSION_MANAGER_LOG_FATAL("session_manager exit");
+     }
 }
 
 struct stellar_module *session_manager_on_thread_init(struct stellar_module_manager *mod_mgr, int thread_id, struct stellar_module *mod)
 {
-    struct session_manager *sess_mgr = stellar_module_get_ctx(mod);
-    assert(sess_mgr);
-    assert(thread_id < sess_mgr->cfg->thread_num);
-
-    if (session_manager_init(sess_mgr, thread_id) != 0)
-    {
-        SESSION_MANAGER_LOG_ERROR("failed to int session_manager_init");
-        return NULL;
-    }
-    else
-    {
-        return mod;
-    }
+     struct session_manager *sess_mgr = stellar_module_get_ctx(mod);
+     assert(sess_mgr);
+     struct mq_runtime *mq_rte = stellar_module_manager_get_mq_runtime(mod_mgr);
+     assert(mq_rte);
+
+     if (session_manager_init(sess_mgr, thread_id, mq_rte) != 0)
+     {
+          SESSION_MANAGER_LOG_ERROR("failed to int session_manager_init");
+          return NULL;
+     }
+     else
+     {
+          return mod;
+     }
 }
 
-void session_manager_on_thread_exit(struct stellar_module_manager *mod_mgr __attribute__((unused)), int thread_id, struct stellar_module *mod)
+void session_manager_on_thread_exit(struct stellar_module_manager *mod_mgr, int thread_id, struct stellar_module *mod)
 {
-    struct session_manager *sess_mgr = stellar_module_get_ctx(mod);
-    assert(sess_mgr);
-    assert(thread_id < sess_mgr->cfg->thread_num);
-
-    session_manager_clean(sess_mgr, thread_id);
+     struct session_manager *sess_mgr = stellar_module_get_ctx(mod);
+     assert(sess_mgr);
+     session_manager_clean(sess_mgr, thread_id);
 }
\ No newline at end of file
diff --git a/infra/session_manager/session_manager_cfg.c b/infra/session_manager/session_manager_cfg.c
new file mode 100644
index 0000000..5542831
--- /dev/null
+++ b/infra/session_manager/session_manager_cfg.c
@@ -0,0 +1,128 @@
+#include "utils_internal.h"
+#include "session_manager_log.h"
+#include "session_manager_cfg.h"
+
+struct session_manager_cfg *session_manager_cfg_new(const char *toml_file)
+{
+    if (toml_file == NULL)
+    {
+        return NULL;
+    }
+
+    struct session_manager_cfg *sess_mgr_cfg = (struct session_manager_cfg *)calloc(1, sizeof(struct session_manager_cfg));
+    if (sess_mgr_cfg == NULL)
+    {
+        return NULL;
+    }
+
+    int ret = 0;
+    ret += load_toml_integer_config(toml_file, "instance.id", &sess_mgr_cfg->instance_id, 0, 4095);
+    ret += load_toml_integer_config(toml_file, "packet_io.thread_num", &sess_mgr_cfg->thread_num, 0, MAX_THREAD_NUM);
+
+    // max session number
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_session_max", &sess_mgr_cfg->tcp_session_max, RX_BURST_MAX * 2, UINT64_MAX);
+    ret += load_toml_integer_config(toml_file, "session_manager.udp_session_max", &sess_mgr_cfg->udp_session_max, RX_BURST_MAX * 2, UINT64_MAX);
+
+    // session overload
+    ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_tcp_table_limit", &sess_mgr_cfg->evict_old_on_tcp_table_limit, 0, 1);
+    ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_udp_table_limit", &sess_mgr_cfg->evict_old_on_udp_table_limit, 0, 1);
+
+    // limit
+    ret += load_toml_integer_config(toml_file, "session_manager.expire_period_ms", &sess_mgr_cfg->expire_period_ms, 0, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.expire_batch_max", &sess_mgr_cfg->expire_batch_max, 1, 1024);
+
+    // TCP timeout
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.init", &sess_mgr_cfg->tcp_timeout_ms.init, 1, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.handshake", &sess_mgr_cfg->tcp_timeout_ms.handshake, 1, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.data", &sess_mgr_cfg->tcp_timeout_ms.data, 1, 15999999000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.half_closed", &sess_mgr_cfg->tcp_timeout_ms.half_closed, 1, 604800000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.time_wait", &sess_mgr_cfg->tcp_timeout_ms.time_wait, 1, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.discard_default", &sess_mgr_cfg->tcp_timeout_ms.discard_default, 1, 15999999000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.unverified_rst", &sess_mgr_cfg->tcp_timeout_ms.unverified_rst, 1, 60000);
+
+    // UDP timeout
+    ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.data", &sess_mgr_cfg->udp_timeout_ms.data, 1, 15999999000);
+    ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.discard_default", &sess_mgr_cfg->udp_timeout_ms.discard_default, 1, 15999999000);
+
+    // duplicated packet filter
+    ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.enable", &sess_mgr_cfg->duplicated_packet_bloom_filter.enable, 0, 1);
+    ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.capacity", &sess_mgr_cfg->duplicated_packet_bloom_filter.capacity, 1, 4294967295);
+    ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.time_window_ms", &sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms, 1, 60000);
+    ret += load_toml_double_config(toml_file, "session_manager.duplicated_packet_bloom_filter.error_rate", (double *)&sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate, 0.0, 1.0);
+
+    // eviction session filter
+    ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.enable", &sess_mgr_cfg->evicted_session_bloom_filter.enable, 0, 1);
+    ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.capacity", &sess_mgr_cfg->evicted_session_bloom_filter.capacity, 1, 4294967295);
+    ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.time_window_ms", &sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms, 1, 60000);
+    ret += load_toml_double_config(toml_file, "session_manager.evicted_session_bloom_filter.error_rate", (double *)&sess_mgr_cfg->evicted_session_bloom_filter.error_rate, 0.0, 1.0);
+
+    // TCP reassembly
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.enable", &sess_mgr_cfg->tcp_reassembly.enable, 0, 1);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.timeout_ms", &sess_mgr_cfg->tcp_reassembly.timeout_ms, 1, 60000);
+    ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.buffered_segments_max", &sess_mgr_cfg->tcp_reassembly.buffered_segments_max, 2, 4096);
+
+    if (ret != 0)
+    {
+        session_manager_cfg_free(sess_mgr_cfg);
+        return NULL;
+    }
+
+    return sess_mgr_cfg;
+}
+
+void session_manager_cfg_free(struct session_manager_cfg *sess_mgr_cfg)
+{
+    if (sess_mgr_cfg)
+    {
+        free(sess_mgr_cfg);
+        sess_mgr_cfg = NULL;
+    }
+}
+
+void session_manager_cfg_print(struct session_manager_cfg *sess_mgr_cfg)
+{
+    if (sess_mgr_cfg)
+    {
+        // max session number
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_session_max                               : %lu", sess_mgr_cfg->tcp_session_max);
+        SESSION_MANAGER_LOG_INFO("session_manager.udp_session_max                               : %lu", sess_mgr_cfg->udp_session_max);
+
+        // session overload
+        SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_tcp_table_limit                  : %d", sess_mgr_cfg->evict_old_on_tcp_table_limit);
+        SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_udp_table_limit                  : %d", sess_mgr_cfg->evict_old_on_udp_table_limit);
+
+        // limit
+        SESSION_MANAGER_LOG_INFO("session_manager.expire_period_ms                              : %lu", sess_mgr_cfg->expire_period_ms);
+        SESSION_MANAGER_LOG_INFO("session_manager.expire_batch_max                              : %lu", sess_mgr_cfg->expire_batch_max);
+
+        // TCP timeout
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.init                           : %lu", sess_mgr_cfg->tcp_timeout_ms.init);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.handshake                      : %lu", sess_mgr_cfg->tcp_timeout_ms.handshake);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.data                           : %lu", sess_mgr_cfg->tcp_timeout_ms.data);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.half_closed                    : %lu", sess_mgr_cfg->tcp_timeout_ms.half_closed);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.time_wait                      : %lu", sess_mgr_cfg->tcp_timeout_ms.time_wait);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.discard_default                : %lu", sess_mgr_cfg->tcp_timeout_ms.discard_default);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.unverified_rst                 : %lu", sess_mgr_cfg->tcp_timeout_ms.unverified_rst);
+
+        // UDP timeout
+        SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.data                           : %lu", sess_mgr_cfg->udp_timeout_ms.data);
+        SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.discard_default                : %lu", sess_mgr_cfg->udp_timeout_ms.discard_default);
+
+        // duplicated packet filter
+        SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.enable         : %d", sess_mgr_cfg->duplicated_packet_bloom_filter.enable);
+        SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.capacity       : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.capacity);
+        SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.time_window_ms : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms);
+        SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.error_rate     : %f", sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate);
+
+        // eviction session filter
+        SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.enable           : %d", sess_mgr_cfg->evicted_session_bloom_filter.enable);
+        SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.capacity         : %lu", sess_mgr_cfg->evicted_session_bloom_filter.capacity);
+        SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.time_window_ms   : %lu", sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms);
+        SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.error_rate       : %f", sess_mgr_cfg->evicted_session_bloom_filter.error_rate);
+
+        // TCP reassembly
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.enable                         : %d", sess_mgr_cfg->tcp_reassembly.enable);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.timeout_ms                     : %lu", sess_mgr_cfg->tcp_reassembly.timeout_ms);
+        SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.buffered_segments_max          : %lu", sess_mgr_cfg->tcp_reassembly.buffered_segments_max);
+    }
+}
\ No newline at end of file
diff --git a/infra/session_manager/session_manager_cfg.h b/infra/session_manager/session_manager_cfg.h
new file mode 100644
index 0000000..5e28162
--- /dev/null
+++ b/infra/session_manager/session_manager_cfg.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+
+struct session_manager_cfg
+{
+    uint64_t instance_id;
+    uint64_t thread_num;
+    uint64_t session_id_seed;
+
+    uint64_t tcp_session_max;
+    uint64_t udp_session_max;
+
+    uint64_t evict_old_on_tcp_table_limit; // range: [0, 1]
+    uint64_t evict_old_on_udp_table_limit; // range: [0, 1]
+
+    uint64_t expire_period_ms; // range: [0, 60000] (ms)
+    uint64_t expire_batch_max; // range: [1, 1024]
+
+    struct
+    {
+        uint64_t init;            // range: [1, 60000] (ms)
+        uint64_t handshake;       // range: [1, 60000] (ms)
+        uint64_t data;            // range: [1, 15999999000] (ms)
+        uint64_t half_closed;     // range: [1, 604800000] (ms)
+        uint64_t time_wait;       // range: [1, 600000] (ms)
+        uint64_t discard_default; // range: [1, 15999999000] (ms)
+        uint64_t unverified_rst;  // range: [1, 600000] (ms)
+    } tcp_timeout_ms;
+
+    struct
+    {
+        uint64_t data;            // range: [1, 15999999000] (ms)
+        uint64_t discard_default; // range: [1, 15999999000] (ms)
+    } udp_timeout_ms;
+
+    struct
+    {
+        uint64_t enable;          // range: [0, 1]
+        uint64_t capacity;       // range: [1, 4294967295]
+        uint64_t time_window_ms; // range: [1, 60000] (ms)
+        double error_rate;       // range: [0.0, 1.0]
+    } duplicated_packet_bloom_filter;
+
+    struct
+    {
+        uint64_t enable;          // range: [0, 1]
+        uint64_t capacity;       // range: [1, 4294967295]
+        uint64_t time_window_ms; // range: [1, 60000] (ms)
+        double error_rate;       // range: [0.0, 1.0]
+    } evicted_session_bloom_filter;
+
+    struct
+    {
+        uint64_t enable;                 // range: [0, 1]
+        uint64_t timeout_ms;            // range: [1, 60000] (ms)
+        uint64_t buffered_segments_max; // range: [2, 4096]
+    } tcp_reassembly;
+};
+
+struct session_manager_cfg *session_manager_cfg_new(const char *toml_file);
+void session_manager_cfg_free(struct session_manager_cfg *sess_mgr_cfg);
+void session_manager_cfg_print(struct session_manager_cfg *sess_mgr_cfg);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/infra/session_manager/session_manager_log.h b/infra/session_manager/session_manager_log.h
new file mode 100644
index 0000000..68d0ac3
--- /dev/null
+++ b/infra/session_manager/session_manager_log.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "log_internal.h"
+
+#define SESSION_MANAGER_LOG_FATAL(format, ...) STELLAR_LOG_FATAL(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
+#define SESSION_MANAGER_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
+#define SESSION_MANAGER_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
+#define SESSION_MANAGER_LOG_INFO(format, ...) STELLAR_LOG_INFO(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/infra/session_manager/session_manager_rte.c b/infra/session_manager/session_manager_rte.c
new file mode 100644
index 0000000..40beac2
--- /dev/null
+++ b/infra/session_manager/session_manager_rte.c
@@ -0,0 +1,1244 @@
+#include <assert.h>
+
+#include "packet_helper.h"
+#include "packet_filter.h"
+#include "session_pool.h"
+#include "session_table.h"
+#include "session_timer.h"
+#include "session_filter.h"
+#include "session_internal.h"
+#include "session_transition.h"
+#include "session_manager_log.h"
+#include "session_manager_cfg.h"
+#include "session_manager_rte.h"
+
+struct snowflake
+{
+    uint64_t seed;
+    uint64_t sequence;
+};
+
+struct session_manager_rte
+{
+    struct session_queue evc_list;
+    struct session_pool *sess_pool;
+    struct session_table *tcp_table;
+    struct session_table *udp_table;
+    struct session_timer *sess_timer;
+
+    struct packet_filter *dup_pkt_filter;
+    struct session_filter *evc_sess_filter;
+
+    struct session_manager_cfg cfg;
+    struct session_manager_stat stat;
+
+    // only used for session_set_discard() or session_manager_rte_record_duplicated_packet(), because the function is called by plugin and has no time input.
+    uint64_t now_ms;
+    uint64_t last_clean_expired_sess_ts;
+    struct snowflake *sf;
+};
+
+/******************************************************************************
+ * snowflake
+ ******************************************************************************/
+
+static struct snowflake *snowflake_new(uint64_t seed)
+{
+    struct snowflake *sf = (struct snowflake *)calloc(1, sizeof(struct snowflake));
+    if (sf == NULL)
+    {
+        return NULL;
+    }
+
+    sf->seed = seed & 0xFFFFF;
+    sf->sequence = 0;
+
+    return sf;
+}
+
+static void snowflake_free(struct snowflake *sf)
+{
+    if (sf != NULL)
+    {
+        free(sf);
+        sf = NULL;
+    }
+}
+
+static uint64_t snowflake_generate(struct snowflake *sf, uint64_t now_sec)
+{
+    /*
+     * high -> low
+     * +------+------------------+----------------+------------------------+---------------------------+
+     * | 1bit |  12bit device_id | 8bit thread_id | 28bit timestamp in sec | 15bit sequence per thread |
+     * +------+------------------+----------------+------------------------+---------------------------+
+     */
+#define MAX_ID_PER_THREAD (32768)
+#define MAX_ID_BASE_TIME (268435456L)
+    uint64_t id = 0;
+    uint64_t id_per_thread = (sf->sequence++) % MAX_ID_PER_THREAD;
+    uint64_t id_base_time = now_sec % MAX_ID_BASE_TIME;
+
+    id = (sf->seed << 43) | (id_base_time << 15) | (id_per_thread);
+
+    return id;
+}
+
+/******************************************************************************
+ * address range
+ ******************************************************************************/
+
+static int ipv4_in_range(const struct in_addr *addr, const struct in_addr *start, const struct in_addr *end)
+{
+    return (memcmp(addr, start, sizeof(struct in_addr)) >= 0 && memcmp(addr, end, sizeof(struct in_addr)) <= 0);
+}
+
+static int ipv6_in_range(const struct in6_addr *addr, const struct in6_addr *start, const struct in6_addr *end)
+{
+    return (memcmp(addr, start, sizeof(struct in6_addr)) >= 0 && memcmp(addr, end, sizeof(struct in6_addr)) <= 0);
+}
+
+/******************************************************************************
+ * TCP reassembly
+ ******************************************************************************/
+
+static void tcp_clean(struct session_manager_rte *sess_mgr_rte, struct session *sess)
+{
+    struct tcp_reassembly *c2s_tcp_reass = sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass;
+    struct tcp_reassembly *s2c_tcp_reass = sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass;
+    struct tcp_segment *seg;
+    if (c2s_tcp_reass)
+    {
+        while ((seg = tcp_reassembly_expire(c2s_tcp_reass, UINT64_MAX)))
+        {
+            session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RELEASED, 1);
+            session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len);
+            sess_mgr_rte->stat.tcp_segs_freed++;
+            tcp_segment_free(seg);
+        }
+        tcp_reassembly_free(c2s_tcp_reass);
+    }
+    if (s2c_tcp_reass)
+    {
+        while ((seg = tcp_reassembly_expire(s2c_tcp_reass, UINT64_MAX)))
+        {
+            session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RELEASED, 1);
+            session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len);
+            sess_mgr_rte->stat.tcp_segs_freed++;
+            tcp_segment_free(seg);
+        }
+        tcp_reassembly_free(s2c_tcp_reass);
+    }
+}
+
+static int tcp_init(struct session_manager_rte *sess_mgr_rte, struct session *sess)
+{
+    if (!sess_mgr_rte->cfg.tcp_reassembly.enable)
+    {
+        return 0;
+    }
+
+    sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass = tcp_reassembly_new(sess_mgr_rte->cfg.tcp_reassembly.timeout_ms, sess_mgr_rte->cfg.tcp_reassembly.buffered_segments_max);
+    sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass = tcp_reassembly_new(sess_mgr_rte->cfg.tcp_reassembly.timeout_ms, sess_mgr_rte->cfg.tcp_reassembly.buffered_segments_max);
+    if (sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass == NULL || sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass == NULL)
+    {
+        tcp_clean(sess_mgr_rte, sess);
+        return -1;
+    }
+
+    SESSION_MANAGER_LOG_DEBUG("session %lu %s new c2s tcp tcp_reass %p, s2c tcp tcp_reass %p", session_get_id(sess), session_get0_readable_addr(sess),
+                              sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass, sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass);
+    return 0;
+}
+
+static void tcp_update(struct session_manager_rte *sess_mgr_rte, struct session *sess, enum flow_type type, const struct layer_private *tcp_layer)
+{
+    struct tcp_segment *seg;
+    struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
+    struct tcp_half *half = &sess->tcp_halfs[type];
+    uint8_t flags = tcp_hdr_get_flags(hdr);
+    uint16_t len = tcp_layer->pld_len;
+
+    if ((flags & TH_SYN) && half->isn == 0)
+    {
+        half->isn = tcp_hdr_get_seq(hdr);
+    }
+    half->flags = flags;
+    half->history |= flags;
+    half->seq = tcp_hdr_get_seq(hdr);
+    half->ack = tcp_hdr_get_ack(hdr);
+    half->len = tcp_layer->pld_len;
+
+    if (!sess_mgr_rte->cfg.tcp_reassembly.enable)
+    {
+        if (len)
+        {
+            session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
+            session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
+            sess_mgr_rte->stat.tcp_segs_input++;
+
+            session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
+            session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
+            sess_mgr_rte->stat.tcp_segs_inorder++;
+
+            half->inorder_seg.data = tcp_layer->pld_ptr;
+            half->inorder_seg.len = len;
+            half->inorder_seg_consumed = 0;
+        }
+        return;
+    }
+
+    if (unlikely(flags & TH_SYN))
+    {
+        // len > 0 is SYN with data (TCP Fast Open)
+        tcp_reassembly_set_recv_next(half->tcp_reass, len ? half->seq : half->seq + 1);
+    }
+
+    seg = tcp_reassembly_expire(half->tcp_reass, sess_mgr_rte->now_ms);
+    if (seg)
+    {
+        session_inc_stat(sess, type, STAT_TCP_SEGMENTS_EXPIRED, 1);
+        session_inc_stat(sess, type, STAT_TCP_PAYLOADS_EXPIRED, seg->len);
+        sess_mgr_rte->stat.tcp_segs_timeout++;
+
+        session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1);
+        session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len);
+        sess_mgr_rte->stat.tcp_segs_freed++;
+
+        tcp_segment_free(seg);
+    }
+
+    if (len)
+    {
+        session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
+        session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
+        sess_mgr_rte->stat.tcp_segs_input++;
+
+        uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->tcp_reass);
+        // in order
+        if (half->seq == rcv_nxt)
+        {
+            session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
+            session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
+            sess_mgr_rte->stat.tcp_segs_inorder++;
+
+            half->inorder_seg.data = tcp_layer->pld_ptr;
+            half->inorder_seg.len = len;
+            half->inorder_seg_consumed = 0;
+            tcp_reassembly_inc_recv_next(half->tcp_reass, len);
+        }
+        // retransmission
+        else if (uint32_before(uint32_add(half->seq, len), rcv_nxt))
+        {
+            session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
+            session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
+            sess_mgr_rte->stat.tcp_segs_retransmited++;
+        }
+        else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len)))
+        {
+            switch (tcp_reassembly_push(half->tcp_reass, seg, sess_mgr_rte->now_ms))
+            {
+            case -2:
+                session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
+                session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
+                sess_mgr_rte->stat.tcp_segs_retransmited++;
+                tcp_segment_free(seg);
+                break;
+            case -1:
+                session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
+                session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
+                sess_mgr_rte->stat.tcp_segs_omitted_too_many++;
+                tcp_segment_free(seg);
+                break;
+            case 0:
+                session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
+                session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
+                sess_mgr_rte->stat.tcp_segs_buffered++;
+                break;
+            case 1:
+                session_inc_stat(sess, type, STAT_TCP_SEGMENTS_OVERLAP, 1);
+                session_inc_stat(sess, type, STAT_TCP_PAYLOADS_OVERLAP, len);
+                sess_mgr_rte->stat.tcp_segs_overlapped++;
+
+                session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
+                session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
+                sess_mgr_rte->stat.tcp_segs_buffered++;
+                break;
+            default:
+                assert(0);
+                break;
+            }
+        }
+        else
+        {
+            session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
+            session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
+            sess_mgr_rte->stat.tcp_segs_omitted_too_many++;
+        }
+    }
+}
+
+/******************************************************************************
+ * flow type
+ ******************************************************************************/
+
+// TODO
+static enum flow_type identify_flow_type_by_port(uint16_t src_port, uint16_t dst_port)
+{
+    // big port is client
+    if (src_port > dst_port)
+    {
+        return FLOW_TYPE_C2S;
+    }
+    else if (src_port < dst_port)
+    {
+        return FLOW_TYPE_S2C;
+    }
+    else
+    {
+        // if port is equal, first packet is C2S
+        return FLOW_TYPE_C2S;
+    }
+}
+
+static enum flow_type identify_flow_type_by_history(const struct session *sess, const struct tuple6 *key)
+{
+    if (tuple6_cmp(session_get_tuple6(sess), key) == 0)
+    {
+        return FLOW_TYPE_C2S;
+    }
+    else
+    {
+        return FLOW_TYPE_S2C;
+    }
+}
+
+/******************************************************************************
+ * session manager rte -- session update
+ ******************************************************************************/
+
+static void session_update(struct session_manager_rte *sess_mgr_rte, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_type type)
+{
+    if (session_get_current_state(sess) == SESSION_STATE_INIT)
+    {
+        uint64_t sess_id = snowflake_generate(sess_mgr_rte->sf, sess_mgr_rte->now_ms / 1000);
+        session_set_id(sess, sess_id);
+        enum packet_direction pkt_dir = packet_get_direction(pkt);
+        if (type == FLOW_TYPE_C2S)
+        {
+            session_set_tuple6(sess, key);
+            if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External
+            {
+                session_set_direction(sess, SESSION_DIRECTION_OUTBOUND);
+            }
+            else
+            {
+                session_set_direction(sess, SESSION_DIRECTION_INBOUND);
+            }
+            tuple6_to_str(key, sess->tuple_str, sizeof(sess->tuple_str));
+        }
+        else
+        {
+            struct tuple6 out;
+            tuple6_reverse(key, &out);
+            session_set_tuple6(sess, &out);
+            if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External
+            {
+                session_set_direction(sess, SESSION_DIRECTION_INBOUND);
+            }
+            else
+            {
+                session_set_direction(sess, SESSION_DIRECTION_OUTBOUND);
+            }
+            tuple6_to_str(&out, sess->tuple_str, sizeof(sess->tuple_str));
+        }
+
+        session_set_timestamp(sess, SESSION_TIMESTAMP_START, sess_mgr_rte->now_ms);
+        switch (key->ip_proto)
+        {
+        case IPPROTO_TCP:
+            session_set_type(sess, SESSION_TYPE_TCP);
+            break;
+        case IPPROTO_UDP:
+            session_set_type(sess, SESSION_TYPE_UDP);
+            break;
+        default:
+            assert(0);
+            break;
+        }
+    }
+
+    session_inc_stat(sess, type, STAT_RAW_PACKETS_RECEIVED, 1);
+    session_inc_stat(sess, type, STAT_RAW_BYTES_RECEIVED, packet_get_raw_len(pkt));
+
+    if (!session_get_first_packet(sess, type))
+    {
+        session_set_first_packet(sess, type, packet_dup(pkt));
+        session_set_route_ctx(sess, type, packet_get_route_ctx(pkt));
+        session_set_sids(sess, type, packet_get_sids(pkt));
+    }
+
+    session_set_current_packet(sess, pkt);
+    session_set_flow_type(sess, type);
+    session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, sess_mgr_rte->now_ms);
+    session_set_current_state(sess, next_state);
+}
+
+/******************************************************************************
+ * session manager rte -- bypass packet
+ ******************************************************************************/
+
+static int session_manager_rte_bypass_packet_on_tcp_table_limit(struct session_manager_rte *sess_mgr_rte, const struct tuple6 *key)
+{
+    if (key->ip_proto == IPPROTO_TCP && sess_mgr_rte->stat.tcp_sess_used >= sess_mgr_rte->cfg.tcp_session_max)
+    {
+        sess_mgr_rte->stat.tcp_pkts_bypass_table_full++;
+        return 1;
+    }
+    return 0;
+}
+
+static int session_manager_rte_bypass_packet_on_udp_table_limit(struct session_manager_rte *sess_mgr_rte, const struct tuple6 *key)
+{
+    if (key->ip_proto == IPPROTO_UDP && sess_mgr_rte->stat.udp_sess_used >= sess_mgr_rte->cfg.udp_session_max)
+    {
+        sess_mgr_rte->stat.udp_pkts_bypass_table_full++;
+        return 1;
+    }
+    return 0;
+}
+
+static int session_manager_rte_bypass_packet_on_session_evicted(struct session_manager_rte *sess_mgr_rte, const struct tuple6 *key)
+{
+    if (sess_mgr_rte->cfg.evicted_session_bloom_filter.enable && session_filter_lookup(sess_mgr_rte->evc_sess_filter, key, sess_mgr_rte->now_ms))
+    {
+        sess_mgr_rte->stat.udp_pkts_bypass_session_evicted++;
+        return 1;
+    }
+
+    return 0;
+}
+
+static int session_manager_rte_bypass_duplicated_packet(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
+{
+    if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable == 0)
+    {
+        return 0;
+    }
+
+    enum flow_type type = identify_flow_type_by_history(sess, key);
+    if (session_get_stat(sess, type, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess))
+    {
+        if (packet_filter_lookup(sess_mgr_rte->dup_pkt_filter, pkt, sess_mgr_rte->now_ms))
+        {
+            session_inc_stat(sess, type, STAT_DUPLICATE_PACKETS_BYPASS, 1);
+            session_inc_stat(sess, type, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt));
+            switch (session_get_type(sess))
+            {
+            case SESSION_TYPE_TCP:
+                sess_mgr_rte->stat.tcp_pkts_bypass_duplicated++;
+                break;
+            case SESSION_TYPE_UDP:
+                sess_mgr_rte->stat.udp_pkts_bypass_duplicated++;
+                break;
+            default:
+                assert(0);
+                break;
+            }
+            session_set_duplicate_traffic(sess);
+
+            session_set_current_packet(sess, pkt);
+            session_set_flow_type(sess, type);
+            return 1;
+        }
+        else
+        {
+            packet_filter_add(sess_mgr_rte->dup_pkt_filter, pkt, sess_mgr_rte->now_ms);
+            return 0;
+        }
+    }
+
+    return 0;
+}
+
+/******************************************************************************
+ * session manager rte -- lookup/new/update/evicte session
+ ******************************************************************************/
+
+static void session_manager_rte_evicte_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, int reason)
+{
+    if (sess == NULL)
+    {
+        return;
+    }
+
+    // when session add to evicted queue, session lifetime is over
+    enum session_state curr_state = session_get_current_state(sess);
+    enum session_state next_state = session_transition_run(curr_state, reason);
+    session_transition_log(sess, curr_state, next_state, reason);
+    session_set_current_state(sess, next_state);
+    if (!session_get_closing_reason(sess))
+    {
+        if (reason == PORT_REUSE_EVICT)
+        {
+            session_set_closing_reason(sess, CLOSING_BY_PORT_REUSE_EVICTED);
+        }
+        if (reason == LRU_EVICT)
+        {
+            session_set_closing_reason(sess, CLOSING_BY_LRU_EVICTED);
+        }
+    }
+    session_timer_del(sess_mgr_rte->sess_timer, sess);
+    TAILQ_INSERT_TAIL(&sess_mgr_rte->evc_list, sess, evc_tqe);
+
+    switch (session_get_type(sess))
+    {
+    case SESSION_TYPE_TCP:
+        SESSION_MANAGER_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess));
+        session_table_del(sess_mgr_rte->tcp_table, sess);
+        SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, tcp);
+        sess_mgr_rte->stat.tcp_sess_evicted++;
+        break;
+    case SESSION_TYPE_UDP:
+        SESSION_MANAGER_LOG_DEBUG("evicte udp old session: %lu", session_get_id(sess));
+        session_table_del(sess_mgr_rte->udp_table, sess);
+        if (sess_mgr_rte->cfg.evicted_session_bloom_filter.enable)
+        {
+            session_filter_add(sess_mgr_rte->evc_sess_filter, session_get_tuple6(sess), sess_mgr_rte->now_ms);
+        }
+        SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, udp);
+        sess_mgr_rte->stat.udp_sess_evicted++;
+        break;
+    default:
+        assert(0);
+        break;
+    }
+}
+
+static struct session *session_manager_rte_lookup_tcp_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, const struct tuple6 *key)
+{
+    struct session *sess = session_table_find_tuple6(sess_mgr_rte->tcp_table, key, 0);
+    if (sess == NULL)
+    {
+        return NULL;
+    }
+
+    const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP);
+    const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
+    uint8_t flags = tcp_hdr_get_flags(hdr);
+    if ((flags & TH_SYN) == 0)
+    {
+        return sess;
+    }
+
+    enum flow_type type = identify_flow_type_by_history(sess, key);
+    struct tcp_half *half = &sess->tcp_halfs[type];
+    if ((half->isn && half->isn != tcp_hdr_get_seq(hdr)) ||     // recv SYN with different ISN
+        ((half->history & TH_FIN) || (half->history & TH_RST))) // recv SYN after FIN or RST
+    {
+        // TCP port reuse, evict old session
+        session_manager_rte_evicte_session(sess_mgr_rte, sess, PORT_REUSE_EVICT);
+        return NULL;
+    }
+    else
+    {
+        // TCP SYN retransmission
+        return sess;
+    }
+}
+
+static struct session *session_manager_rte_lookup_udp_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt __attribute__((unused)), const struct tuple6 *key)
+{
+    return session_table_find_tuple6(sess_mgr_rte->udp_table, key, 0);
+}
+
+static struct session *session_manager_rte_new_tcp_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, const struct tuple6 *key)
+{
+    const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP);
+    const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
+    uint8_t flags = tcp_hdr_get_flags(hdr);
+    if (!(flags & TH_SYN))
+    {
+        sess_mgr_rte->stat.tcp_pkts_bypass_session_not_found++;
+        return NULL;
+    }
+
+    // tcp table full evict old session
+    if (sess_mgr_rte->cfg.evict_old_on_tcp_table_limit && sess_mgr_rte->stat.tcp_sess_used >= sess_mgr_rte->cfg.tcp_session_max - RX_BURST_MAX)
+    {
+        struct session *evic_sess = session_table_find_lru(sess_mgr_rte->tcp_table);
+        session_manager_rte_evicte_session(sess_mgr_rte, evic_sess, LRU_EVICT);
+    }
+
+    enum flow_type type = (flags & TH_ACK) ? FLOW_TYPE_S2C : FLOW_TYPE_C2S;
+    struct session *sess = session_pool_pop(sess_mgr_rte->sess_pool);
+    if (sess == NULL)
+    {
+        assert(0);
+        return NULL;
+    }
+    session_init(sess);
+    sess->sess_mgr_rte = sess_mgr_rte;
+    sess->sess_mgr_stat = &sess_mgr_rte->stat;
+
+    enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
+    session_update(sess_mgr_rte, sess, next_state, pkt, key, type);
+    session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
+
+    if (tcp_init(sess_mgr_rte, sess) == -1)
+    {
+        assert(0);
+        session_pool_push(sess_mgr_rte->sess_pool, sess);
+        return NULL;
+    }
+    tcp_update(sess_mgr_rte, sess, type, tcp_layer);
+
+    uint64_t timeout = (flags & TH_ACK) ? sess_mgr_rte->cfg.tcp_timeout_ms.handshake : sess_mgr_rte->cfg.tcp_timeout_ms.init;
+    session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + timeout);
+    session_table_add(sess_mgr_rte->tcp_table, sess);
+
+    if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable)
+    {
+        packet_filter_add(sess_mgr_rte->dup_pkt_filter, pkt, sess_mgr_rte->now_ms);
+    }
+
+    SESS_MGR_STAT_INC(&sess_mgr_rte->stat, next_state, tcp);
+    sess_mgr_rte->stat.tcp_sess_used++;
+    sess_mgr_rte->stat.history_tcp_sessions++;
+
+    return sess;
+}
+
+static struct session *session_manager_rte_new_udp_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, const struct tuple6 *key)
+{
+    // udp table full evict old session
+    if (sess_mgr_rte->cfg.evict_old_on_udp_table_limit && sess_mgr_rte->stat.udp_sess_used >= sess_mgr_rte->cfg.udp_session_max - RX_BURST_MAX)
+    {
+        struct session *evic_sess = session_table_find_lru(sess_mgr_rte->udp_table);
+        session_manager_rte_evicte_session(sess_mgr_rte, evic_sess, LRU_EVICT);
+    }
+
+    struct session *sess = session_pool_pop(sess_mgr_rte->sess_pool);
+    if (sess == NULL)
+    {
+        assert(sess);
+        return NULL;
+    }
+    session_init(sess);
+    sess->sess_mgr_rte = sess_mgr_rte;
+    sess->sess_mgr_stat = &sess_mgr_rte->stat;
+
+    enum flow_type type = identify_flow_type_by_port(ntohs(key->src_port), ntohs(key->dst_port));
+    enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA);
+    session_update(sess_mgr_rte, sess, next_state, pkt, key, type);
+    session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
+
+    session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.udp_timeout_ms.data);
+    session_table_add(sess_mgr_rte->udp_table, sess);
+
+    SESS_MGR_STAT_INC(&sess_mgr_rte->stat, next_state, udp);
+    sess_mgr_rte->stat.udp_sess_used++;
+    sess_mgr_rte->stat.history_udp_sessions++;
+
+    return sess;
+}
+
+static int session_manager_rte_update_tcp_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
+{
+    const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP);
+    const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
+    enum flow_type type = identify_flow_type_by_history(sess, key);
+    uint8_t flags = tcp_hdr_get_flags(hdr);
+    int inputs = 0;
+    inputs |= (flags & TH_SYN) ? TCP_SYN : NONE;
+    inputs |= (flags & TH_FIN) ? TCP_FIN : NONE;
+    inputs |= (flags & TH_RST) ? TCP_RST : NONE;
+    inputs |= tcp_layer->pld_len ? TCP_DATA : NONE;
+
+    // update state
+    enum session_state curr_state = session_get_current_state(sess);
+    enum session_state next_state = session_transition_run(curr_state, inputs);
+
+    // update session
+    session_update(sess_mgr_rte, sess, next_state, pkt, key, type);
+    session_transition_log(sess, curr_state, next_state, inputs);
+
+    // update tcp
+    tcp_update(sess_mgr_rte, sess, type, tcp_layer);
+
+    // set closing reason
+    if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess))
+    {
+        if (flags & TH_FIN)
+        {
+            session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN));
+        }
+        if (flags & TH_RST)
+        {
+            session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST));
+        }
+    }
+
+    // update timeout
+    struct tcp_half *curr = &sess->tcp_halfs[type];
+    struct tcp_half *peer = &sess->tcp_halfs[(type == FLOW_TYPE_C2S ? FLOW_TYPE_S2C : FLOW_TYPE_C2S)];
+    uint64_t timeout = 0;
+    switch (next_state)
+    {
+    case SESSION_STATE_OPENING:
+        if (flags & TH_SYN)
+        {
+            timeout = (flags & TH_ACK) ? sess_mgr_rte->cfg.tcp_timeout_ms.handshake : sess_mgr_rte->cfg.tcp_timeout_ms.init;
+        }
+        else
+        {
+            timeout = sess_mgr_rte->cfg.tcp_timeout_ms.data;
+        }
+        break;
+    case SESSION_STATE_ACTIVE:
+        timeout = sess_mgr_rte->cfg.tcp_timeout_ms.data;
+        break;
+    case SESSION_STATE_CLOSING:
+        if (flags & TH_FIN)
+        {
+            timeout = (peer->history & TH_FIN) ? sess_mgr_rte->cfg.tcp_timeout_ms.time_wait : sess_mgr_rte->cfg.tcp_timeout_ms.half_closed;
+        }
+        else if (flags & TH_RST)
+        {
+            // if fin is received, the expected sequence number should be increased by 1
+            uint32_t expected = (peer->history & TH_FIN) ? peer->ack + 1 : peer->ack;
+            timeout = (expected == curr->seq) ? sess_mgr_rte->cfg.tcp_timeout_ms.time_wait : sess_mgr_rte->cfg.tcp_timeout_ms.unverified_rst;
+        }
+        else
+        {
+            timeout = sess_mgr_rte->cfg.tcp_timeout_ms.data;
+        }
+        break;
+    case SESSION_STATE_DISCARD:
+        timeout = sess_mgr_rte->cfg.tcp_timeout_ms.discard_default;
+        break;
+    default:
+        assert(0);
+        break;
+    }
+    session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + timeout);
+
+    SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, tcp);
+
+    return 0;
+}
+
+static int session_manager_rte_update_udp_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
+{
+    enum flow_type type = identify_flow_type_by_history(sess, key);
+    enum session_state curr_state = session_get_current_state(sess);
+    enum session_state next_state = session_transition_run(curr_state, UDP_DATA);
+    session_update(sess_mgr_rte, sess, next_state, pkt, key, type);
+    session_transition_log(sess, curr_state, next_state, UDP_DATA);
+
+    if (session_get_current_state(sess) == SESSION_STATE_DISCARD)
+    {
+        session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.udp_timeout_ms.discard_default);
+    }
+    else
+    {
+        session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.udp_timeout_ms.data);
+    }
+
+    SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, udp);
+
+    return 0;
+}
+
+/******************************************************************************
+ * session manager rte -- public
+ ******************************************************************************/
+
+struct session_manager_rte *session_manager_rte_new(const struct session_manager_cfg *sess_mgr_cfg, uint64_t now_ms)
+{
+    struct session_manager_rte *sess_mgr_rte = (struct session_manager_rte *)calloc(1, sizeof(struct session_manager_rte));
+    if (sess_mgr_rte == NULL)
+    {
+        return NULL;
+    }
+    memcpy(&sess_mgr_rte->cfg, sess_mgr_cfg, sizeof(struct session_manager_cfg));
+
+    sess_mgr_rte->sess_pool = session_pool_new(sess_mgr_rte->cfg.tcp_session_max + sess_mgr_rte->cfg.udp_session_max);
+    sess_mgr_rte->tcp_table = session_table_new();
+    sess_mgr_rte->udp_table = session_table_new();
+    sess_mgr_rte->sess_timer = session_timer_new(now_ms);
+    if (sess_mgr_rte->sess_pool == NULL || sess_mgr_rte->tcp_table == NULL || sess_mgr_rte->udp_table == NULL || sess_mgr_rte->sess_timer == NULL)
+    {
+        goto error;
+    }
+    if (sess_mgr_rte->cfg.evicted_session_bloom_filter.enable)
+    {
+        sess_mgr_rte->evc_sess_filter = session_filter_new(sess_mgr_rte->cfg.evicted_session_bloom_filter.capacity,
+                                                           sess_mgr_rte->cfg.evicted_session_bloom_filter.time_window_ms,
+                                                           sess_mgr_rte->cfg.evicted_session_bloom_filter.error_rate, now_ms);
+        if (sess_mgr_rte->evc_sess_filter == NULL)
+        {
+            goto error;
+        }
+    }
+    if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable)
+    {
+        sess_mgr_rte->dup_pkt_filter = packet_filter_new(sess_mgr_rte->cfg.duplicated_packet_bloom_filter.capacity,
+                                                         sess_mgr_rte->cfg.duplicated_packet_bloom_filter.time_window_ms,
+                                                         sess_mgr_rte->cfg.duplicated_packet_bloom_filter.error_rate, now_ms);
+        if (sess_mgr_rte->dup_pkt_filter == NULL)
+        {
+            goto error;
+        }
+    }
+    sess_mgr_rte->sf = snowflake_new(sess_mgr_rte->cfg.session_id_seed);
+    if (sess_mgr_rte->sf == NULL)
+    {
+        goto error;
+    }
+
+    TAILQ_INIT(&sess_mgr_rte->evc_list);
+    session_transition_init();
+    sess_mgr_rte->now_ms = now_ms;
+    sess_mgr_rte->last_clean_expired_sess_ts = now_ms;
+
+    return sess_mgr_rte;
+
+error:
+    session_manager_rte_free(sess_mgr_rte);
+    return NULL;
+}
+
+void session_manager_rte_free(struct session_manager_rte *sess_mgr_rte)
+{
+    struct session *sess;
+    if (sess_mgr_rte)
+    {
+        // free all evicted session
+        while ((sess = TAILQ_FIRST(&sess_mgr_rte->evc_list)))
+        {
+            TAILQ_REMOVE(&sess_mgr_rte->evc_list, sess, evc_tqe);
+            session_manager_rte_free_session(sess_mgr_rte, sess);
+        }
+        // free all udp session
+        while (sess_mgr_rte->udp_table && (sess = session_table_find_lru(sess_mgr_rte->udp_table)))
+        {
+            session_manager_rte_free_session(sess_mgr_rte, sess);
+        }
+        // free all tcp session
+        while (sess_mgr_rte->tcp_table && (sess = session_table_find_lru(sess_mgr_rte->tcp_table)))
+        {
+            session_manager_rte_free_session(sess_mgr_rte, sess);
+        }
+        if (sess_mgr_rte->cfg.evicted_session_bloom_filter.enable)
+        {
+            session_filter_free(sess_mgr_rte->evc_sess_filter);
+        }
+        if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable)
+        {
+            packet_filter_free(sess_mgr_rte->dup_pkt_filter);
+        }
+        snowflake_free(sess_mgr_rte->sf);
+        session_timer_free(sess_mgr_rte->sess_timer);
+        session_table_free(sess_mgr_rte->udp_table);
+        session_table_free(sess_mgr_rte->tcp_table);
+        session_pool_free(sess_mgr_rte->sess_pool);
+        free(sess_mgr_rte);
+        sess_mgr_rte = NULL;
+    }
+}
+
+struct session *session_manager_rte_new_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, uint64_t now_ms)
+{
+    sess_mgr_rte->now_ms = now_ms;
+
+    struct tuple6 key;
+    if (packet_get_innermost_tuple6(pkt, &key))
+    {
+        return NULL;
+    }
+    switch (key.ip_proto)
+    {
+    case IPPROTO_TCP:
+        if (session_manager_rte_bypass_packet_on_tcp_table_limit(sess_mgr_rte, &key))
+        {
+            return NULL;
+        }
+        return session_manager_rte_new_tcp_session(sess_mgr_rte, pkt, &key);
+    case IPPROTO_UDP:
+        if (session_manager_rte_bypass_packet_on_session_evicted(sess_mgr_rte, &key))
+        {
+            return NULL;
+        }
+        if (session_manager_rte_bypass_packet_on_udp_table_limit(sess_mgr_rte, &key))
+        {
+            return NULL;
+        }
+        return session_manager_rte_new_udp_session(sess_mgr_rte, pkt, &key);
+    default:
+        return NULL;
+    }
+}
+
+void session_manager_rte_free_session(struct session_manager_rte *sess_mgr_rte, struct session *sess)
+{
+    if (sess)
+    {
+        SESSION_MANAGER_LOG_DEBUG("session %lu closed (%s)", session_get_id(sess), closing_reason_to_str(session_get_closing_reason(sess)));
+
+        session_timer_del(sess_mgr_rte->sess_timer, sess);
+        switch (session_get_type(sess))
+        {
+        case SESSION_TYPE_TCP:
+            tcp_clean(sess_mgr_rte, sess);
+            if (session_table_find_sessid(sess_mgr_rte->tcp_table, session_get_id(sess), 0) == sess)
+            {
+                session_table_del(sess_mgr_rte->tcp_table, sess);
+            }
+            SESS_MGR_STAT_DEC(&sess_mgr_rte->stat, session_get_current_state(sess), tcp);
+            sess_mgr_rte->stat.tcp_sess_used--;
+            break;
+        case SESSION_TYPE_UDP:
+            if (session_table_find_sessid(sess_mgr_rte->udp_table, session_get_id(sess), 0) == sess)
+            {
+                session_table_del(sess_mgr_rte->udp_table, sess);
+            }
+            SESS_MGR_STAT_DEC(&sess_mgr_rte->stat, session_get_current_state(sess), udp);
+            sess_mgr_rte->stat.udp_sess_used--;
+            break;
+        default:
+            assert(0);
+            break;
+        }
+
+        packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_C2S));
+        packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_S2C));
+        session_set_first_packet(sess, FLOW_TYPE_C2S, NULL);
+        session_set_first_packet(sess, FLOW_TYPE_S2C, NULL);
+        session_clear_route_ctx(sess, FLOW_TYPE_C2S);
+        session_clear_route_ctx(sess, FLOW_TYPE_S2C);
+        session_clear_sids(sess, FLOW_TYPE_C2S);
+        session_clear_sids(sess, FLOW_TYPE_S2C);
+        session_set_current_state(sess, SESSION_STATE_INIT);
+        session_set_current_packet(sess, NULL);
+        session_set_flow_type(sess, FLOW_TYPE_NONE);
+        session_init(sess);
+        session_pool_push(sess_mgr_rte->sess_pool, sess);
+        sess = NULL;
+    }
+}
+
+struct session *session_manager_rte_lookup_session_by_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt)
+{
+    struct tuple6 key;
+    if (packet_get_innermost_tuple6(pkt, &key))
+    {
+        return NULL;
+    }
+    switch (key.ip_proto)
+    {
+    case IPPROTO_UDP:
+        return session_manager_rte_lookup_udp_session(sess_mgr_rte, pkt, &key);
+    case IPPROTO_TCP:
+        return session_manager_rte_lookup_tcp_session(sess_mgr_rte, pkt, &key);
+    default:
+        return NULL;
+    }
+}
+
+struct session *session_manager_rte_lookup_session_by_id(struct session_manager_rte *sess_mgr_rte, uint64_t sess_id)
+{
+    struct session *sess = NULL;
+    sess = session_table_find_sessid(sess_mgr_rte->tcp_table, sess_id, 1);
+    if (sess)
+    {
+        return sess;
+    }
+
+    sess = session_table_find_sessid(sess_mgr_rte->udp_table, sess_id, 1);
+    if (sess)
+    {
+        return sess;
+    }
+
+    return NULL;
+}
+
+int session_manager_rte_update_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, uint64_t now_ms)
+{
+    sess_mgr_rte->now_ms = now_ms;
+
+    struct tuple6 key;
+    if (packet_get_innermost_tuple6(pkt, &key))
+    {
+        return -1;
+    }
+    if (session_manager_rte_bypass_duplicated_packet(sess_mgr_rte, sess, pkt, &key))
+    {
+        return -1;
+    }
+    switch (session_get_type(sess))
+    {
+    case SESSION_TYPE_TCP:
+        return session_manager_rte_update_tcp_session(sess_mgr_rte, sess, pkt, &key);
+    case SESSION_TYPE_UDP:
+        return session_manager_rte_update_udp_session(sess_mgr_rte, sess, pkt, &key);
+    default:
+        return -1;
+    }
+}
+
+struct session *session_manager_rte_get_expired_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms)
+{
+    sess_mgr_rte->now_ms = now_ms;
+
+    struct session *sess = session_timer_expire(sess_mgr_rte->sess_timer, now_ms);
+    if (sess)
+    {
+        enum session_state curr_state = session_get_current_state(sess);
+        enum session_state next_state = session_transition_run(curr_state, TIMEOUT);
+        session_transition_log(sess, curr_state, next_state, TIMEOUT);
+        session_set_current_state(sess, next_state);
+
+        switch (session_get_type(sess))
+        {
+        case SESSION_TYPE_TCP:
+            SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, tcp);
+            break;
+        case SESSION_TYPE_UDP:
+            SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, udp);
+            break;
+        default:
+            assert(0);
+            break;
+        }
+
+        // next state is closed, need to free session
+        if (next_state == SESSION_STATE_CLOSED)
+        {
+            if (!session_get_closing_reason(sess))
+            {
+                session_set_closing_reason(sess, CLOSING_BY_TIMEOUT);
+            }
+            return sess;
+        }
+        // next state is closing, only update timeout
+        else
+        {
+            switch (session_get_type(sess))
+            {
+            case SESSION_TYPE_TCP:
+                session_timer_update(sess_mgr_rte->sess_timer, sess, now_ms + sess_mgr_rte->cfg.tcp_timeout_ms.data);
+                break;
+            case SESSION_TYPE_UDP:
+                session_timer_update(sess_mgr_rte->sess_timer, sess, now_ms + sess_mgr_rte->cfg.udp_timeout_ms.data);
+                break;
+            default:
+                assert(0);
+                break;
+            }
+            return NULL;
+        }
+    }
+
+    return NULL;
+}
+
+struct session *session_manager_rte_get_evicted_session(struct session_manager_rte *sess_mgr_rte)
+{
+    struct session *sess = TAILQ_FIRST(&sess_mgr_rte->evc_list);
+    if (sess)
+    {
+        TAILQ_REMOVE(&sess_mgr_rte->evc_list, sess, evc_tqe);
+    }
+    return sess;
+}
+
+uint64_t session_manager_rte_clean_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms, struct session *cleaned_sess_ptr[], uint64_t array_size)
+{
+    sess_mgr_rte->now_ms = now_ms;
+    struct session *sess = NULL;
+    uint64_t cleaned_sess_num = 0;
+    uint64_t expired_sess_num = 0;
+
+    uint8_t expired_sess_canbe_clean = 0;
+    if (now_ms - sess_mgr_rte->last_clean_expired_sess_ts >= sess_mgr_rte->cfg.expire_period_ms ||
+        now_ms == UINT64_MAX)
+    {
+        expired_sess_canbe_clean = 1;
+    }
+
+    for (uint64_t i = 0; i < array_size; i++)
+    {
+        // frist clean evicted session
+        sess = session_manager_rte_get_evicted_session(sess_mgr_rte);
+        if (sess)
+        {
+            cleaned_sess_ptr[cleaned_sess_num++] = sess;
+        }
+        // then clean expired session
+        else
+        {
+            if (expired_sess_canbe_clean && expired_sess_num < sess_mgr_rte->cfg.expire_batch_max)
+            {
+                sess_mgr_rte->last_clean_expired_sess_ts = now_ms;
+                sess = session_manager_rte_get_expired_session(sess_mgr_rte, now_ms);
+                if (sess)
+                {
+                    cleaned_sess_ptr[cleaned_sess_num++] = sess;
+                    expired_sess_num++;
+                }
+                else
+                {
+                    break;
+                }
+            }
+            else
+            {
+                break;
+            }
+        }
+    }
+
+    return cleaned_sess_num;
+}
+
+uint64_t session_manager_rte_scan_session(struct session_manager_rte *sess_mgr_rte, const struct session_scan_opts *opts, uint64_t mached_sess_id[], uint64_t array_size)
+{
+    uint64_t capacity = 0;
+    uint64_t max_loop = 0;
+    uint64_t mached_sess_num = 0;
+    const struct session *sess = NULL;
+    const struct tuple6 *tuple = NULL;
+
+    if (sess_mgr_rte == NULL || opts == NULL || mached_sess_id == NULL || array_size == 0)
+    {
+        return mached_sess_num;
+    }
+    if (opts->count == 0)
+    {
+        return mached_sess_num;
+    }
+    capacity = sess_mgr_rte->cfg.tcp_session_max + sess_mgr_rte->cfg.udp_session_max;
+    if (opts->cursor >= capacity)
+    {
+        return mached_sess_num;
+    }
+
+    max_loop = MIN(capacity, opts->cursor + opts->count);
+    for (uint64_t i = opts->cursor; i < max_loop; i++)
+    {
+        sess = session_pool_get0(sess_mgr_rte->sess_pool, i);
+        tuple = session_get_tuple6(sess);
+        if (session_get_current_state(sess) == SESSION_STATE_INIT)
+        {
+            continue;
+        }
+
+        if ((opts->flags & SESSION_SCAN_TYPE) && opts->type != session_get_type(sess))
+        {
+            continue;
+        }
+        if ((opts->flags & SESSION_SCAN_STATE) && opts->state != session_get_current_state(sess))
+        {
+            continue;
+        }
+        if ((opts->flags & SESSION_SCAN_CREATE_TIME) &&
+            (session_get_timestamp(sess, SESSION_TIMESTAMP_START) < opts->create_time_ms[0] ||
+             session_get_timestamp(sess, SESSION_TIMESTAMP_START) > opts->create_time_ms[1]))
+        {
+            continue;
+        }
+        if ((opts->flags & SESSION_SCAN_LASPKT_TIME) &&
+            (session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) < opts->laspkt_time_ms[0] ||
+             session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) > opts->laspkt_time_ms[1]))
+        {
+            continue;
+        }
+        if ((opts->flags & SESSION_SCAN_SPORT) && opts->src_port != tuple->src_port)
+        {
+            continue;
+        }
+        if ((opts->flags & SESSION_SCAN_DPORT) && opts->dst_port != tuple->dst_port)
+        {
+            continue;
+        }
+        if (opts->flags & SESSION_SCAN_SIP)
+        {
+            if (opts->addr_family != tuple->addr_family)
+            {
+                continue;
+            }
+            if ((opts->addr_family == AF_INET) && !ipv4_in_range(&tuple->src_addr.v4, &opts->src_addr[0].v4, &opts->src_addr[1].v4))
+            {
+                continue;
+            }
+            if ((opts->addr_family == AF_INET6) && !ipv6_in_range(&tuple->src_addr.v6, &opts->src_addr[0].v6, &opts->src_addr[1].v6))
+            {
+                continue;
+            }
+        }
+        if (opts->flags & SESSION_SCAN_DIP)
+        {
+            if (opts->addr_family != tuple->addr_family)
+            {
+                continue;
+            }
+            if ((opts->addr_family == AF_INET) && !ipv4_in_range(&tuple->dst_addr.v4, &opts->dst_addr[0].v4, &opts->dst_addr[1].v4))
+            {
+                continue;
+            }
+            if ((opts->addr_family == AF_INET6) && !ipv6_in_range(&tuple->dst_addr.v6, &opts->dst_addr[0].v6, &opts->dst_addr[1].v6))
+            {
+                continue;
+            }
+        }
+
+        mached_sess_id[mached_sess_num++] = session_get_id(sess);
+        if (mached_sess_num >= array_size)
+        {
+            break;
+        }
+    }
+
+    SESSION_MANAGER_LOG_DEBUG("session scan => cursor: %lu, count: %lu, mached_sess_num: %lu", opts->cursor, opts->count, mached_sess_num);
+    return mached_sess_num;
+}
+
+void session_manager_rte_record_duplicated_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt)
+{
+    if (sess_mgr_rte->cfg.duplicated_packet_bloom_filter.enable)
+    {
+        packet_filter_add(sess_mgr_rte->dup_pkt_filter, pkt, sess_mgr_rte->now_ms);
+    }
+}
+
+struct session_manager_stat *session_manager_rte_get_stat(struct session_manager_rte *sess_mgr_rte)
+{
+    return &sess_mgr_rte->stat;
+}
+
+void session_set_discard(struct session *sess)
+{
+    struct session_manager_rte *sess_mgr_rte = sess->sess_mgr_rte;
+    enum session_type type = session_get_type(sess);
+    enum session_state curr_state = session_get_current_state(sess);
+    enum session_state next_state = session_transition_run(curr_state, USER_CLOSE);
+    session_transition_log(sess, curr_state, next_state, USER_CLOSE);
+    session_set_current_state(sess, next_state);
+
+    switch (type)
+    {
+    case SESSION_TYPE_TCP:
+        session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.tcp_timeout_ms.discard_default);
+        SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, tcp);
+        break;
+    case SESSION_TYPE_UDP:
+        session_timer_update(sess_mgr_rte->sess_timer, sess, sess_mgr_rte->now_ms + sess_mgr_rte->cfg.udp_timeout_ms.discard_default);
+        SESS_MGR_STAT_UPDATE(&sess_mgr_rte->stat, curr_state, next_state, udp);
+        break;
+    default:
+        assert(0);
+        break;
+    }
+}
diff --git a/infra/session_manager/session_manager_rte.h b/infra/session_manager/session_manager_rte.h
new file mode 100644
index 0000000..de8c09c
--- /dev/null
+++ b/infra/session_manager/session_manager_rte.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include "tuple.h"
+#include "stellar/session.h"
+
+enum session_scan_flags
+{
+    SESSION_SCAN_TYPE = 1 << 0,
+    SESSION_SCAN_STATE = 1 << 1,
+    SESSION_SCAN_SIP = 1 << 2,
+    SESSION_SCAN_DIP = 1 << 3,
+    SESSION_SCAN_SPORT = 1 << 4,
+    SESSION_SCAN_DPORT = 1 << 5,
+    SESSION_SCAN_CREATE_TIME = 1 << 6,
+    SESSION_SCAN_LASPKT_TIME = 1 << 7,
+};
+
+struct session_scan_opts
+{
+    // required
+    uint32_t flags;
+    uint32_t cursor;
+    uint32_t count;
+
+    // optional
+    enum session_type type;
+    enum session_state state;
+
+    uint32_t addr_family;         // AF_INET or AF_INET6
+    union ip_address src_addr[2]; // network byte order
+    union ip_address dst_addr[2]; // network byte order
+    uint16_t src_port;            // network byte order
+    uint16_t dst_port;            // network byte order
+
+    uint64_t create_time_ms[2]; // session create time range
+    uint64_t laspkt_time_ms[2]; // last packet time range
+};
+
+struct session_manager_rte;
+struct session_manager_rte *session_manager_rte_new(const struct session_manager_cfg *sess_mgr_cfg, uint64_t now_ms);
+void session_manager_rte_free(struct session_manager_rte *sess_mgr_rte);
+
+struct session *session_manager_rte_new_session(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt, uint64_t now_ms);
+void session_manager_rte_free_session(struct session_manager_rte *sess_mgr_rte, struct session *sess);
+
+struct session *session_manager_rte_lookup_session_by_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt);
+struct session *session_manager_rte_lookup_session_by_id(struct session_manager_rte *sess_mgr_rte, uint64_t sess_id);
+int session_manager_rte_update_session(struct session_manager_rte *sess_mgr_rte, struct session *sess, const struct packet *pkt, uint64_t now_ms);
+
+struct session *session_manager_rte_get_expired_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms);
+struct session *session_manager_rte_get_evicted_session(struct session_manager_rte *sess_mgr_rte);
+
+uint64_t session_manager_rte_clean_session(struct session_manager_rte *sess_mgr_rte, uint64_t now_ms, struct session *cleaned_sess_ptr[], uint64_t array_size);
+uint64_t session_manager_rte_scan_session(struct session_manager_rte *sess_mgr_rte, const struct session_scan_opts *opts, uint64_t mached_sess_id[], uint64_t array_size);
+
+void session_manager_rte_record_duplicated_packet(struct session_manager_rte *sess_mgr_rte, const struct packet *pkt);
+
+struct session_manager_stat *session_manager_rte_get_stat(struct session_manager_rte *sess_mgr_rte);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/infra/session_manager/session_manager_runtime.c b/infra/session_manager/session_manager_runtime.c
deleted file mode 100644
index 97fbb28..0000000
--- a/infra/session_manager/session_manager_runtime.c
+++ /dev/null
@@ -1,1464 +0,0 @@
-#include <time.h>
-#include <stdlib.h>
-#include <assert.h>
-#include <errno.h>
-
-#include "utils_internal.h"
-#include "packet_helper.h"
-#include "packet_filter.h"
-#include "session_internal.h"
-#include "session_pool.h"
-#include "session_table.h"
-#include "session_timer.h"
-#include "session_filter.h"
-#include "session_transition.h"
-#include "session_manager_runtime.h"
-
-#include "stellar/exdata.h"
-
-struct snowflake
-{
-     uint64_t seed;
-     uint64_t sequence;
-};
-
-struct session_manager_runtime
-{
-     struct session_queue evicte_list;
-     struct session_pool *sess_pool;
-     struct session_timer *sess_timer;
-     struct session_table *tcp_sess_table;
-     struct session_table *udp_sess_table;
-
-     struct packet_filter *dup_pkt_filter;
-     struct session_filter *evicte_sess_filter;
-
-     struct session_manager_stat stat;
-     struct session_manager_config cfg;
-
-     /*
-      * only used for session_set_discard() or session_manager_runtime_record_duplicated_packet(),
-      * because the function is called by plugin and has no time input.
-      */
-     uint64_t now_ms;
-     uint64_t last_clean_expired_sess_ts;
-     struct snowflake *sf;
-};
-
-#define EVICTE_SESSION_BURST (RX_BURST_MAX)
-
-/******************************************************************************
- * session manager stat macro
- ******************************************************************************/
-
-#define SESS_MGR_STAT_INC(stat, state, proto)  \
-     {                                         \
-          switch ((state))                     \
-          {                                    \
-          case SESSION_STATE_OPENING:          \
-               (stat)->proto##_sess_opening++; \
-               break;                          \
-          case SESSION_STATE_ACTIVE:           \
-               (stat)->proto##_sess_active++;  \
-               break;                          \
-          case SESSION_STATE_CLOSING:          \
-               (stat)->proto##_sess_closing++; \
-               break;                          \
-          case SESSION_STATE_DISCARD:          \
-               (stat)->proto##_sess_discard++; \
-               break;                          \
-          case SESSION_STATE_CLOSED:           \
-               (stat)->proto##_sess_closed++;  \
-               break;                          \
-          default:                             \
-               break;                          \
-          }                                    \
-     }
-
-#define SESS_MGR_STAT_DEC(stat, state, proto)  \
-     {                                         \
-          switch ((state))                     \
-          {                                    \
-          case SESSION_STATE_OPENING:          \
-               (stat)->proto##_sess_opening--; \
-               break;                          \
-          case SESSION_STATE_ACTIVE:           \
-               (stat)->proto##_sess_active--;  \
-               break;                          \
-          case SESSION_STATE_CLOSING:          \
-               (stat)->proto##_sess_closing--; \
-               break;                          \
-          case SESSION_STATE_DISCARD:          \
-               (stat)->proto##_sess_discard--; \
-               break;                          \
-          case SESSION_STATE_CLOSED:           \
-               (stat)->proto##_sess_closed--;  \
-               break;                          \
-          default:                             \
-               break;                          \
-          }                                    \
-     }
-
-#define SESS_MGR_STAT_UPDATE(stat, curr, next, proto) \
-     {                                                \
-          if (curr != next)                           \
-          {                                           \
-               SESS_MGR_STAT_DEC(stat, curr, proto);  \
-               SESS_MGR_STAT_INC(stat, next, proto);  \
-          }                                           \
-     }
-
-/******************************************************************************
- * snowflake
- ******************************************************************************/
-
-static struct snowflake *snowflake_new(uint64_t seed)
-{
-     struct snowflake *sf = (struct snowflake *)calloc(1, sizeof(struct snowflake));
-     if (sf == NULL)
-     {
-          return NULL;
-     }
-
-     sf->seed = seed & 0xFFFFF;
-     sf->sequence = 0;
-
-     return sf;
-}
-
-static void snowflake_free(struct snowflake *sf)
-{
-     if (sf != NULL)
-     {
-          free(sf);
-          sf = NULL;
-     }
-}
-
-/*
- * high -> low
- *
- * +------+------------------+----------------+------------------------+---------------------------+
- * | 1bit |  12bit device_id | 8bit thread_id | 28bit timestamp in sec | 15bit sequence per thread |
- * +------+------------------+----------------+------------------------+---------------------------+
- */
-
-#define MAX_ID_PER_THREAD (32768)
-#define MAX_ID_BASE_TIME (268435456L)
-
-static uint64_t snowflake_generate(struct snowflake *sf, uint64_t now_sec)
-{
-     uint64_t id = 0;
-     uint64_t id_per_thread = (sf->sequence++) % MAX_ID_PER_THREAD;
-     uint64_t id_base_time = now_sec % MAX_ID_BASE_TIME;
-
-     id = (sf->seed << 43) | (id_base_time << 15) | (id_per_thread);
-
-     return id;
-}
-
-/******************************************************************************
- * TCP utils
- ******************************************************************************/
-
-static void tcp_clean(struct session_manager_runtime *sess_mgr_rt, struct session *sess)
-{
-     struct tcp_reassembly *c2s_tcp_reass = sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass;
-     struct tcp_reassembly *s2c_tcp_reass = sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass;
-     struct tcp_segment *seg;
-     if (c2s_tcp_reass)
-     {
-          while ((seg = tcp_reassembly_expire(c2s_tcp_reass, UINT64_MAX)))
-          {
-               session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_SEGMENTS_RELEASED, 1);
-               session_inc_stat(sess, FLOW_TYPE_C2S, STAT_TCP_PAYLOADS_RELEASED, seg->len);
-               sess_mgr_rt->stat.tcp_segs_freed++;
-               tcp_segment_free(seg);
-          }
-          tcp_reassembly_free(c2s_tcp_reass);
-     }
-     if (s2c_tcp_reass)
-     {
-          while ((seg = tcp_reassembly_expire(s2c_tcp_reass, UINT64_MAX)))
-          {
-               session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_SEGMENTS_RELEASED, 1);
-               session_inc_stat(sess, FLOW_TYPE_S2C, STAT_TCP_PAYLOADS_RELEASED, seg->len);
-               sess_mgr_rt->stat.tcp_segs_freed++;
-               tcp_segment_free(seg);
-          }
-          tcp_reassembly_free(s2c_tcp_reass);
-     }
-}
-
-static int tcp_init(struct session_manager_runtime *sess_mgr_rt, struct session *sess)
-{
-     if (!sess_mgr_rt->cfg.tcp_reassembly.enable)
-     {
-          return 0;
-     }
-
-     sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass = tcp_reassembly_new(sess_mgr_rt->cfg.tcp_reassembly.timeout_ms, sess_mgr_rt->cfg.tcp_reassembly.buffered_segments_max);
-     sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass = tcp_reassembly_new(sess_mgr_rt->cfg.tcp_reassembly.timeout_ms, sess_mgr_rt->cfg.tcp_reassembly.buffered_segments_max);
-     if (sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass == NULL || sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass == NULL)
-     {
-          tcp_clean(sess_mgr_rt, sess);
-          return -1;
-     }
-
-     SESSION_MANAGER_LOG_DEBUG("session %lu %s new c2s tcp tcp_reass %p, s2c tcp tcp_reass %p",
-                               session_get_id(sess), session_get0_readable_addr(sess),
-                               sess->tcp_halfs[FLOW_TYPE_C2S].tcp_reass,
-                               sess->tcp_halfs[FLOW_TYPE_S2C].tcp_reass);
-
-     return 0;
-}
-
-static void tcp_update(struct session_manager_runtime *sess_mgr_rt, struct session *sess, enum flow_type type, const struct layer_private *tcp_layer)
-{
-     struct tcp_segment *seg;
-     struct tcphdr *hdr = (struct tcphdr *)tcp_layer->hdr_ptr;
-     struct tcp_half *half = &sess->tcp_halfs[type];
-     uint8_t flags = tcp_hdr_get_flags(hdr);
-     uint16_t len = tcp_layer->pld_len;
-
-     if ((flags & TH_SYN) && half->isn == 0)
-     {
-          half->isn = tcp_hdr_get_seq(hdr);
-     }
-     half->flags = flags;
-     half->history |= flags;
-     half->seq = tcp_hdr_get_seq(hdr);
-     half->ack = tcp_hdr_get_ack(hdr);
-     half->len = tcp_layer->pld_len;
-
-     if (!sess_mgr_rt->cfg.tcp_reassembly.enable)
-     {
-          if (len)
-          {
-               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
-               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
-               sess_mgr_rt->stat.tcp_segs_input++;
-
-               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
-               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
-               sess_mgr_rt->stat.tcp_segs_inorder++;
-
-               half->inorder_seg.data = tcp_layer->pld_ptr;
-               half->inorder_seg.len = len;
-               half->inorder_seg_consumed = 0;
-          }
-          return;
-     }
-
-     if (unlikely(flags & TH_SYN))
-     {
-          // len > 0 is SYN with data (TCP Fast Open)
-          tcp_reassembly_set_recv_next(half->tcp_reass, len ? half->seq : half->seq + 1);
-     }
-
-     seg = tcp_reassembly_expire(half->tcp_reass, sess_mgr_rt->now_ms);
-     if (seg)
-     {
-          session_inc_stat(sess, type, STAT_TCP_SEGMENTS_EXPIRED, 1);
-          session_inc_stat(sess, type, STAT_TCP_PAYLOADS_EXPIRED, seg->len);
-          sess_mgr_rt->stat.tcp_segs_timeout++;
-
-          session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RELEASED, 1);
-          session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RELEASED, seg->len);
-          sess_mgr_rt->stat.tcp_segs_freed++;
-
-          tcp_segment_free(seg);
-     }
-
-     if (len)
-     {
-          session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RECEIVED, 1);
-          session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RECEIVED, len);
-          sess_mgr_rt->stat.tcp_segs_input++;
-
-          uint32_t rcv_nxt = tcp_reassembly_get_recv_next(half->tcp_reass);
-          // in order
-          if (half->seq == rcv_nxt)
-          {
-               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_INORDER, 1);
-               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_INORDER, len);
-               sess_mgr_rt->stat.tcp_segs_inorder++;
-
-               half->inorder_seg.data = tcp_layer->pld_ptr;
-               half->inorder_seg.len = len;
-               half->inorder_seg_consumed = 0;
-               tcp_reassembly_inc_recv_next(half->tcp_reass, len);
-          }
-          // retransmission
-          else if (uint32_before(uint32_add(half->seq, len), rcv_nxt))
-          {
-               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
-               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
-               sess_mgr_rt->stat.tcp_segs_retransmited++;
-          }
-          else if ((seg = tcp_segment_new(half->seq, tcp_layer->pld_ptr, len)))
-          {
-               switch (tcp_reassembly_push(half->tcp_reass, seg, sess_mgr_rt->now_ms))
-               {
-               case -2:
-                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_RETRANSMIT, 1);
-                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_RETRANSMIT, len);
-                    sess_mgr_rt->stat.tcp_segs_retransmited++;
-                    tcp_segment_free(seg);
-                    break;
-               case -1:
-                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
-                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
-                    sess_mgr_rt->stat.tcp_segs_omitted_too_many++;
-                    tcp_segment_free(seg);
-                    break;
-               case 0:
-                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
-                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
-                    sess_mgr_rt->stat.tcp_segs_buffered++;
-                    break;
-               case 1:
-                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_OVERLAP, 1);
-                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_OVERLAP, len);
-                    sess_mgr_rt->stat.tcp_segs_overlapped++;
-
-                    session_inc_stat(sess, type, STAT_TCP_SEGMENTS_BUFFERED, 1);
-                    session_inc_stat(sess, type, STAT_TCP_PAYLOADS_BUFFERED, len);
-                    sess_mgr_rt->stat.tcp_segs_buffered++;
-                    break;
-               default:
-                    assert(0);
-                    break;
-               }
-          }
-          else
-          {
-               session_inc_stat(sess, type, STAT_TCP_SEGMENTS_NOSPACE, 1);
-               session_inc_stat(sess, type, STAT_TCP_PAYLOADS_NOSPACE, len);
-               sess_mgr_rt->stat.tcp_segs_omitted_too_many++;
-          }
-     }
-}
-
-/******************************************************************************
- * session flow
- ******************************************************************************/
-
-static enum flow_type identify_flow_type_by_port(uint16_t src_port, uint16_t dst_port)
-{
-     // big port is client
-     if (src_port > dst_port)
-     {
-          return FLOW_TYPE_C2S;
-     }
-     else if (src_port < dst_port)
-     {
-          return FLOW_TYPE_S2C;
-     }
-     else
-     {
-          // if port is equal, first packet is C2S
-          return FLOW_TYPE_C2S;
-     }
-}
-
-static enum flow_type identify_flow_type_by_history(const struct session *sess, const struct tuple6 *key)
-{
-     if (tuple6_cmp(session_get_tuple6(sess), key) == 0)
-     {
-          return FLOW_TYPE_C2S;
-     }
-     else
-     {
-          return FLOW_TYPE_S2C;
-     }
-}
-
-/******************************************************************************
- * bypass packet -- table limit / session evicted / duplicated packet
- ******************************************************************************/
-
-static int session_manager_runtime_bypass_packet_on_tcp_table_limit(struct session_manager_runtime *sess_mgr_rt, const struct tuple6 *key)
-{
-     if (key->ip_proto == IPPROTO_TCP && sess_mgr_rt->stat.tcp_sess_used >= sess_mgr_rt->cfg.tcp_session_max)
-     {
-          sess_mgr_rt->stat.tcp_pkts_bypass_table_full++;
-          return 1;
-     }
-     return 0;
-}
-
-static int session_manager_runtime_bypass_packet_on_udp_table_limit(struct session_manager_runtime *sess_mgr_rt, const struct tuple6 *key)
-{
-     if (key->ip_proto == IPPROTO_UDP && sess_mgr_rt->stat.udp_sess_used >= sess_mgr_rt->cfg.udp_session_max)
-     {
-          sess_mgr_rt->stat.udp_pkts_bypass_table_full++;
-          return 1;
-     }
-     return 0;
-}
-
-static int session_manager_runtime_bypass_packet_on_session_evicted(struct session_manager_runtime *sess_mgr_rt, const struct tuple6 *key)
-{
-     if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable && session_filter_lookup(sess_mgr_rt->evicte_sess_filter, key, sess_mgr_rt->now_ms))
-     {
-          sess_mgr_rt->stat.udp_pkts_bypass_session_evicted++;
-          return 1;
-     }
-
-     return 0;
-}
-
-static int session_manager_runtime_bypass_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
-{
-     if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable == 0)
-     {
-          return 0;
-     }
-
-     enum flow_type type = identify_flow_type_by_history(sess, key);
-     if (session_get_stat(sess, type, STAT_RAW_PACKETS_RECEIVED) < 3 || session_has_duplicate_traffic(sess))
-     {
-          if (packet_filter_lookup(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms))
-          {
-               session_inc_stat(sess, type, STAT_DUPLICATE_PACKETS_BYPASS, 1);
-               session_inc_stat(sess, type, STAT_DUPLICATE_BYTES_BYPASS, packet_get_raw_len(pkt));
-               switch (session_get_type(sess))
-               {
-               case SESSION_TYPE_TCP:
-                    sess_mgr_rt->stat.tcp_pkts_bypass_duplicated++;
-                    break;
-               case SESSION_TYPE_UDP:
-                    sess_mgr_rt->stat.udp_pkts_bypass_duplicated++;
-                    break;
-               default:
-                    assert(0);
-                    break;
-               }
-               session_set_duplicate_traffic(sess);
-
-               session_set_current_packet(sess, pkt);
-               session_set_flow_type(sess, type);
-               return 1;
-          }
-          else
-          {
-               packet_filter_add(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms);
-               return 0;
-          }
-     }
-
-     return 0;
-}
-
-void session_manager_runtime_record_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt)
-{
-     if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable)
-     {
-          packet_filter_add(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms);
-     }
-}
-
-/******************************************************************************
- * config -- new / free / print
- ******************************************************************************/
-
-struct session_manager_config *session_manager_config_new(const char *toml_file)
-{
-     if (toml_file == NULL)
-     {
-          return NULL;
-     }
-
-     struct session_manager_config *sess_mgr_cfg = (struct session_manager_config *)calloc(1, sizeof(struct session_manager_config));
-     if (sess_mgr_cfg == NULL)
-     {
-          return NULL;
-     }
-
-     int ret = 0;
-     ret += load_toml_integer_config(toml_file, "instance.id", (uint64_t *)&sess_mgr_cfg->instance_id, 0, 4095);
-     ret += load_toml_integer_config(toml_file, "packet_io.thread_num", (uint64_t *)&sess_mgr_cfg->thread_num, 0, MAX_THREAD_NUM);
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_session_max", (uint64_t *)&sess_mgr_cfg->tcp_session_max, EVICTE_SESSION_BURST * 2, UINT64_MAX);
-     ret += load_toml_integer_config(toml_file, "session_manager.udp_session_max", (uint64_t *)&sess_mgr_cfg->udp_session_max, EVICTE_SESSION_BURST * 2, UINT64_MAX);
-
-     ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_tcp_table_limit", (uint64_t *)&sess_mgr_cfg->evict_old_on_tcp_table_limit, 0, 1);
-     ret += load_toml_integer_config(toml_file, "session_manager.evict_old_on_udp_table_limit", (uint64_t *)&sess_mgr_cfg->evict_old_on_udp_table_limit, 0, 1);
-
-     ret += load_toml_integer_config(toml_file, "session_manager.expire_period_ms", (uint64_t *)&sess_mgr_cfg->expire_period_ms, 0, 60000);
-     ret += load_toml_integer_config(toml_file, "session_manager.expire_batch_max", (uint64_t *)&sess_mgr_cfg->expire_batch_max, 1, 1024);
-
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.init", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.init, 1, 60000);
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.handshake", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.handshake, 1, 60000);
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.data", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.data, 1, 15999999000);
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.half_closed", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.half_closed, 1, 604800000);
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.time_wait", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.time_wait, 1, 60000);
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.discard_default", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.discard_default, 1, 15999999000);
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_timeout_ms.unverified_rst", (uint64_t *)&sess_mgr_cfg->tcp_timeout_ms.unverified_rst, 1, 60000);
-
-     ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.data", (uint64_t *)&sess_mgr_cfg->udp_timeout_ms.data, 1, 15999999000);
-     ret += load_toml_integer_config(toml_file, "session_manager.udp_timeout_ms.discard_default", (uint64_t *)&sess_mgr_cfg->udp_timeout_ms.discard_default, 1, 15999999000);
-
-     ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.enable", (uint64_t *)&sess_mgr_cfg->duplicated_packet_bloom_filter.enable, 0, 1);
-     ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.capacity", (uint64_t *)&sess_mgr_cfg->duplicated_packet_bloom_filter.capacity, 1, 4294967295);
-     ret += load_toml_integer_config(toml_file, "session_manager.duplicated_packet_bloom_filter.time_window_ms", (uint64_t *)&sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms, 1, 60000);
-     ret += load_toml_double_config(toml_file, "session_manager.duplicated_packet_bloom_filter.error_rate", (double *)&sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate, 0.0, 1.0);
-
-     ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.enable", (uint64_t *)&sess_mgr_cfg->evicted_session_bloom_filter.enable, 0, 1);
-     ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.capacity", (uint64_t *)&sess_mgr_cfg->evicted_session_bloom_filter.capacity, 1, 4294967295);
-     ret += load_toml_integer_config(toml_file, "session_manager.evicted_session_bloom_filter.time_window_ms", (uint64_t *)&sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms, 1, 60000);
-     ret += load_toml_double_config(toml_file, "session_manager.evicted_session_bloom_filter.error_rate", (double *)&sess_mgr_cfg->evicted_session_bloom_filter.error_rate, 0.0, 1.0);
-
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.enable", (uint64_t *)&sess_mgr_cfg->tcp_reassembly.enable, 0, 1);
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.timeout_ms", (uint64_t *)&sess_mgr_cfg->tcp_reassembly.timeout_ms, 1, 60000);
-     ret += load_toml_integer_config(toml_file, "session_manager.tcp_reassembly.buffered_segments_max", (uint64_t *)&sess_mgr_cfg->tcp_reassembly.buffered_segments_max, 2, 4096);
-
-     if (ret != 0)
-     {
-          session_manager_config_free(sess_mgr_cfg);
-          return NULL;
-     }
-
-     return sess_mgr_cfg;
-}
-
-void session_manager_config_free(struct session_manager_config *sess_mgr_cfg)
-{
-     if (sess_mgr_cfg)
-     {
-          free(sess_mgr_cfg);
-          sess_mgr_cfg = NULL;
-     }
-}
-
-void session_manager_config_print(struct session_manager_config *sess_mgr_cfg)
-{
-     if (sess_mgr_cfg)
-     {
-          // max session number
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_session_max                               : %lu", sess_mgr_cfg->tcp_session_max);
-          SESSION_MANAGER_LOG_INFO("session_manager.udp_session_max                               : %lu", sess_mgr_cfg->udp_session_max);
-
-          // session overload
-          SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_tcp_table_limit                  : %d", sess_mgr_cfg->evict_old_on_tcp_table_limit);
-          SESSION_MANAGER_LOG_INFO("session_manager.evict_old_on_udp_table_limit                  : %d", sess_mgr_cfg->evict_old_on_udp_table_limit);
-
-          // TCP timeout
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.init                           : %lu", sess_mgr_cfg->tcp_timeout_ms.init);
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.handshake                      : %lu", sess_mgr_cfg->tcp_timeout_ms.handshake);
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.data                           : %lu", sess_mgr_cfg->tcp_timeout_ms.data);
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.half_closed                    : %lu", sess_mgr_cfg->tcp_timeout_ms.half_closed);
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.time_wait                      : %lu", sess_mgr_cfg->tcp_timeout_ms.time_wait);
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.discard_default                : %lu", sess_mgr_cfg->tcp_timeout_ms.discard_default);
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_timeout_ms.unverified_rst                 : %lu", sess_mgr_cfg->tcp_timeout_ms.unverified_rst);
-
-          // UDP timeout
-          SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.data                           : %lu", sess_mgr_cfg->udp_timeout_ms.data);
-          SESSION_MANAGER_LOG_INFO("session_manager.udp_timeout_ms.discard_default                : %lu", sess_mgr_cfg->udp_timeout_ms.discard_default);
-
-          // limit
-          SESSION_MANAGER_LOG_INFO("session_manager.expire_period_ms                              : %lu", sess_mgr_cfg->expire_period_ms);
-          SESSION_MANAGER_LOG_INFO("session_manager.expire_batch_max                              : %lu", sess_mgr_cfg->expire_batch_max);
-
-          // duplicated packet filter
-          SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.enable         : %d", sess_mgr_cfg->duplicated_packet_bloom_filter.enable);
-          SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.capacity       : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.capacity);
-          SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.time_window_ms : %lu", sess_mgr_cfg->duplicated_packet_bloom_filter.time_window_ms);
-          SESSION_MANAGER_LOG_INFO("session_manager.duplicated_packet_bloom_filter.error_rate     : %f", sess_mgr_cfg->duplicated_packet_bloom_filter.error_rate);
-
-          // eviction session filter
-          SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.enable           : %d", sess_mgr_cfg->evicted_session_bloom_filter.enable);
-          SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.capacity         : %lu", sess_mgr_cfg->evicted_session_bloom_filter.capacity);
-          SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.time_window_ms   : %lu", sess_mgr_cfg->evicted_session_bloom_filter.time_window_ms);
-          SESSION_MANAGER_LOG_INFO("session_manager.evicted_session_bloom_filter.error_rate       : %f", sess_mgr_cfg->evicted_session_bloom_filter.error_rate);
-
-          // TCP reassembly
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.enable                         : %d", sess_mgr_cfg->tcp_reassembly.enable);
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.timeout_ms                     : %lu", sess_mgr_cfg->tcp_reassembly.timeout_ms);
-          SESSION_MANAGER_LOG_INFO("session_manager.tcp_reassembly.buffered_segments_max          : %lu", sess_mgr_cfg->tcp_reassembly.buffered_segments_max);
-     }
-}
-
-/******************************************************************************
- * runtime -- new / free
- ******************************************************************************/
-
-struct session_manager_runtime *session_manager_runtime_new(const struct session_manager_config *sess_mgr_cfg, uint64_t now_ms)
-{
-     struct session_manager_runtime *sess_mgr_rt = (struct session_manager_runtime *)calloc(1, sizeof(struct session_manager_runtime));
-     if (sess_mgr_rt == NULL)
-     {
-          return NULL;
-     }
-     memcpy(&sess_mgr_rt->cfg, sess_mgr_cfg, sizeof(struct session_manager_config));
-
-     sess_mgr_rt->sess_pool = session_pool_new(sess_mgr_rt->cfg.tcp_session_max + sess_mgr_rt->cfg.udp_session_max);
-     sess_mgr_rt->tcp_sess_table = session_table_new();
-     sess_mgr_rt->udp_sess_table = session_table_new();
-     sess_mgr_rt->sess_timer = session_timer_new(now_ms);
-     if (sess_mgr_rt->sess_pool == NULL || sess_mgr_rt->tcp_sess_table == NULL || sess_mgr_rt->udp_sess_table == NULL || sess_mgr_rt->sess_timer == NULL)
-     {
-          goto error;
-     }
-     if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable)
-     {
-          sess_mgr_rt->evicte_sess_filter = session_filter_new(sess_mgr_rt->cfg.evicted_session_bloom_filter.capacity,
-                                                               sess_mgr_rt->cfg.evicted_session_bloom_filter.time_window_ms,
-                                                               sess_mgr_rt->cfg.evicted_session_bloom_filter.error_rate, now_ms);
-          if (sess_mgr_rt->evicte_sess_filter == NULL)
-          {
-               goto error;
-          }
-     }
-     if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable)
-     {
-          sess_mgr_rt->dup_pkt_filter = packet_filter_new(sess_mgr_rt->cfg.duplicated_packet_bloom_filter.capacity,
-                                                          sess_mgr_rt->cfg.duplicated_packet_bloom_filter.time_window_ms,
-                                                          sess_mgr_rt->cfg.duplicated_packet_bloom_filter.error_rate, now_ms);
-          if (sess_mgr_rt->dup_pkt_filter == NULL)
-          {
-               goto error;
-          }
-     }
-     sess_mgr_rt->sf = snowflake_new(sess_mgr_rt->cfg.session_id_seed);
-     if (sess_mgr_rt->sf == NULL)
-     {
-          goto error;
-     }
-
-     TAILQ_INIT(&sess_mgr_rt->evicte_list);
-     session_transition_init();
-     sess_mgr_rt->now_ms = now_ms;
-     sess_mgr_rt->last_clean_expired_sess_ts = now_ms;
-
-     return sess_mgr_rt;
-
-error:
-     session_manager_runtime_free(sess_mgr_rt);
-     return NULL;
-}
-
-void session_manager_runtime_free(struct session_manager_runtime *sess_mgr_rt)
-{
-     struct session *sess;
-     if (sess_mgr_rt)
-     {
-          // free all evicted session
-          while ((sess = TAILQ_FIRST(&sess_mgr_rt->evicte_list)))
-          {
-               TAILQ_REMOVE(&sess_mgr_rt->evicte_list, sess, evicte_tqe);
-               session_manager_runtime_free_session(sess_mgr_rt, sess);
-          }
-          // free all udp session
-          while (sess_mgr_rt->udp_sess_table && (sess = session_table_find_lru(sess_mgr_rt->udp_sess_table)))
-          {
-               session_manager_runtime_free_session(sess_mgr_rt, sess);
-          }
-          // free all tcp session
-          while (sess_mgr_rt->tcp_sess_table && (sess = session_table_find_lru(sess_mgr_rt->tcp_sess_table)))
-          {
-               session_manager_runtime_free_session(sess_mgr_rt, sess);
-          }
-          if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable)
-          {
-               session_filter_free(sess_mgr_rt->evicte_sess_filter);
-          }
-          if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable)
-          {
-               packet_filter_free(sess_mgr_rt->dup_pkt_filter);
-          }
-          snowflake_free(sess_mgr_rt->sf);
-          session_timer_free(sess_mgr_rt->sess_timer);
-          session_table_free(sess_mgr_rt->udp_sess_table);
-          session_table_free(sess_mgr_rt->tcp_sess_table);
-          session_pool_free(sess_mgr_rt->sess_pool);
-          free(sess_mgr_rt);
-          sess_mgr_rt = NULL;
-     }
-}
-
-/******************************************************************************
- * session -- new / free / lookup / updata / expire / evicte / clean
- ******************************************************************************/
-
-static void session_update(struct session_manager_runtime *sess_mgr_rt, struct session *sess, enum session_state next_state, const struct packet *pkt, const struct tuple6 *key, enum flow_type type)
-{
-     if (session_get_current_state(sess) == SESSION_STATE_INIT)
-     {
-          uint64_t sess_id = snowflake_generate(sess_mgr_rt->sf, sess_mgr_rt->now_ms / 1000);
-          session_set_id(sess, sess_id);
-          enum packet_direction pkt_dir = packet_get_direction(pkt);
-          if (type == FLOW_TYPE_C2S)
-          {
-               session_set_tuple6(sess, key);
-               if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External
-               {
-                    session_set_direction(sess, SESSION_DIRECTION_OUTBOUND);
-               }
-               else
-               {
-                    session_set_direction(sess, SESSION_DIRECTION_INBOUND);
-               }
-               tuple6_to_str(key, sess->tuple_str, sizeof(sess->tuple_str));
-          }
-          else
-          {
-               struct tuple6 out;
-               tuple6_reverse(key, &out);
-               session_set_tuple6(sess, &out);
-               if (pkt_dir == PACKET_DIRECTION_OUTGOING) // Internal -> External
-               {
-                    session_set_direction(sess, SESSION_DIRECTION_INBOUND);
-               }
-               else
-               {
-                    session_set_direction(sess, SESSION_DIRECTION_OUTBOUND);
-               }
-               tuple6_to_str(&out, sess->tuple_str, sizeof(sess->tuple_str));
-          }
-
-          session_set_timestamp(sess, SESSION_TIMESTAMP_START, sess_mgr_rt->now_ms);
-          switch (key->ip_proto)
-          {
-          case IPPROTO_TCP:
-               session_set_type(sess, SESSION_TYPE_TCP);
-               break;
-          case IPPROTO_UDP:
-               session_set_type(sess, SESSION_TYPE_UDP);
-               break;
-          default:
-               assert(0);
-               break;
-          }
-     }
-
-     session_inc_stat(sess, type, STAT_RAW_PACKETS_RECEIVED, 1);
-     session_inc_stat(sess, type, STAT_RAW_BYTES_RECEIVED, packet_get_raw_len(pkt));
-
-     if (!session_get_first_packet(sess, type))
-     {
-          session_set_first_packet(sess, type, packet_dup(pkt));
-          session_set_route_ctx(sess, type, packet_get_route_ctx(pkt));
-          session_set_sids(sess, type, packet_get_sids(pkt));
-     }
-
-     session_set_current_packet(sess, pkt);
-     session_set_flow_type(sess, type);
-     session_set_timestamp(sess, SESSION_TIMESTAMP_LAST, sess_mgr_rt->now_ms);
-     session_set_current_state(sess, next_state);
-}
-
-static void session_manager_runtime_evicte_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, int reason)
-{
-     if (sess == NULL)
-     {
-          return;
-     }
-
-     // when session add to evicted queue, session lifetime is over
-     enum session_state curr_state = session_get_current_state(sess);
-     enum session_state next_state = session_transition_run(curr_state, reason);
-     session_transition_log(sess, curr_state, next_state, reason);
-     session_set_current_state(sess, next_state);
-     if (!session_get_closing_reason(sess))
-     {
-          if (reason == PORT_REUSE_EVICT)
-          {
-               session_set_closing_reason(sess, CLOSING_BY_PORT_REUSE_EVICTED);
-          }
-          if (reason == LRU_EVICT)
-          {
-               session_set_closing_reason(sess, CLOSING_BY_LRU_EVICTED);
-          }
-     }
-     session_timer_del(sess_mgr_rt->sess_timer, sess);
-     TAILQ_INSERT_TAIL(&sess_mgr_rt->evicte_list, sess, evicte_tqe);
-
-     switch (session_get_type(sess))
-     {
-     case SESSION_TYPE_TCP:
-          SESSION_MANAGER_LOG_DEBUG("evicte tcp old session: %lu", session_get_id(sess));
-          session_table_del(sess_mgr_rt->tcp_sess_table, sess);
-          SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp);
-          sess_mgr_rt->stat.tcp_sess_evicted++;
-          break;
-     case SESSION_TYPE_UDP:
-          SESSION_MANAGER_LOG_DEBUG("evicte udp old session: %lu", session_get_id(sess));
-          session_table_del(sess_mgr_rt->udp_sess_table, sess);
-          if (sess_mgr_rt->cfg.evicted_session_bloom_filter.enable)
-          {
-               session_filter_add(sess_mgr_rt->evicte_sess_filter, session_get_tuple6(sess), sess_mgr_rt->now_ms);
-          }
-          SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp);
-          sess_mgr_rt->stat.udp_sess_evicted++;
-          break;
-     default:
-          assert(0);
-          break;
-     }
-}
-
-static struct session *session_manager_runtime_lookup_tcp_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, const struct tuple6 *key)
-{
-     struct session *sess = session_table_find_tuple6(sess_mgr_rt->tcp_sess_table, key, 0);
-     if (sess == NULL)
-     {
-          return NULL;
-     }
-
-     const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP);
-     const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
-     uint8_t flags = tcp_hdr_get_flags(hdr);
-     if ((flags & TH_SYN) == 0)
-     {
-          return sess;
-     }
-
-     enum flow_type type = identify_flow_type_by_history(sess, key);
-     struct tcp_half *half = &sess->tcp_halfs[type];
-     if ((half->isn && half->isn != tcp_hdr_get_seq(hdr)) ||     // recv SYN with different ISN
-         ((half->history & TH_FIN) || (half->history & TH_RST))) // recv SYN after FIN or RST
-     {
-          // TCP port reuse, evict old session
-          session_manager_runtime_evicte_session(sess_mgr_rt, sess, PORT_REUSE_EVICT);
-          return NULL;
-     }
-     else
-     {
-          // TCP SYN retransmission
-          return sess;
-     }
-}
-
-static struct session *session_manager_runtime_new_tcp_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, const struct tuple6 *key)
-{
-     const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP);
-     const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
-     uint8_t flags = tcp_hdr_get_flags(hdr);
-     if (!(flags & TH_SYN))
-     {
-          sess_mgr_rt->stat.tcp_pkts_bypass_session_not_found++;
-          return NULL;
-     }
-
-     // tcp table full evict old session
-     if (sess_mgr_rt->cfg.evict_old_on_tcp_table_limit && sess_mgr_rt->stat.tcp_sess_used >= sess_mgr_rt->cfg.tcp_session_max - EVICTE_SESSION_BURST)
-     {
-          struct session *evic_sess = session_table_find_lru(sess_mgr_rt->tcp_sess_table);
-          session_manager_runtime_evicte_session(sess_mgr_rt, evic_sess, LRU_EVICT);
-     }
-
-     enum flow_type type = (flags & TH_ACK) ? FLOW_TYPE_S2C : FLOW_TYPE_C2S;
-     struct session *sess = session_pool_pop(sess_mgr_rt->sess_pool);
-     if (sess == NULL)
-     {
-          assert(0);
-          return NULL;
-     }
-     session_init(sess);
-     sess->sess_mgr_rt = sess_mgr_rt;
-     sess->sess_mgr_stat = &sess_mgr_rt->stat;
-
-     enum session_state next_state = session_transition_run(SESSION_STATE_INIT, TCP_SYN);
-     session_update(sess_mgr_rt, sess, next_state, pkt, key, type);
-     session_transition_log(sess, SESSION_STATE_INIT, next_state, TCP_SYN);
-
-     if (tcp_init(sess_mgr_rt, sess) == -1)
-     {
-          assert(0);
-          session_pool_push(sess_mgr_rt->sess_pool, sess);
-          return NULL;
-     }
-     tcp_update(sess_mgr_rt, sess, type, tcp_layer);
-
-     uint64_t timeout = (flags & TH_ACK) ? sess_mgr_rt->cfg.tcp_timeout_ms.handshake : sess_mgr_rt->cfg.tcp_timeout_ms.init;
-     session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + timeout);
-     session_table_add(sess_mgr_rt->tcp_sess_table, sess);
-
-     if (sess_mgr_rt->cfg.duplicated_packet_bloom_filter.enable)
-     {
-          packet_filter_add(sess_mgr_rt->dup_pkt_filter, pkt, sess_mgr_rt->now_ms);
-     }
-
-     SESS_MGR_STAT_INC(&sess_mgr_rt->stat, next_state, tcp);
-     sess_mgr_rt->stat.tcp_sess_used++;
-     sess_mgr_rt->stat.history_tcp_sessions++;
-
-     return sess;
-}
-
-static struct session *session_manager_runtime_new_udp_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, const struct tuple6 *key)
-{
-     // udp table full evict old session
-     if (sess_mgr_rt->cfg.evict_old_on_udp_table_limit && sess_mgr_rt->stat.udp_sess_used >= sess_mgr_rt->cfg.udp_session_max - EVICTE_SESSION_BURST)
-     {
-          struct session *evic_sess = session_table_find_lru(sess_mgr_rt->udp_sess_table);
-          session_manager_runtime_evicte_session(sess_mgr_rt, evic_sess, LRU_EVICT);
-     }
-
-     struct session *sess = session_pool_pop(sess_mgr_rt->sess_pool);
-     if (sess == NULL)
-     {
-          assert(sess);
-          return NULL;
-     }
-     session_init(sess);
-     sess->sess_mgr_rt = sess_mgr_rt;
-     sess->sess_mgr_stat = &sess_mgr_rt->stat;
-
-     enum flow_type type = identify_flow_type_by_port(ntohs(key->src_port), ntohs(key->dst_port));
-     enum session_state next_state = session_transition_run(SESSION_STATE_INIT, UDP_DATA);
-     session_update(sess_mgr_rt, sess, next_state, pkt, key, type);
-     session_transition_log(sess, SESSION_STATE_INIT, next_state, UDP_DATA);
-
-     session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.data);
-     session_table_add(sess_mgr_rt->udp_sess_table, sess);
-
-     SESS_MGR_STAT_INC(&sess_mgr_rt->stat, next_state, udp);
-     sess_mgr_rt->stat.udp_sess_used++;
-     sess_mgr_rt->stat.history_udp_sessions++;
-
-     return sess;
-}
-
-static int session_manager_runtime_update_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
-{
-     const struct layer_private *tcp_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_TCP);
-     const struct tcphdr *hdr = (const struct tcphdr *)tcp_layer->hdr_ptr;
-     enum flow_type type = identify_flow_type_by_history(sess, key);
-     uint8_t flags = tcp_hdr_get_flags(hdr);
-     int inputs = 0;
-     inputs |= (flags & TH_SYN) ? TCP_SYN : NONE;
-     inputs |= (flags & TH_FIN) ? TCP_FIN : NONE;
-     inputs |= (flags & TH_RST) ? TCP_RST : NONE;
-     inputs |= tcp_layer->pld_len ? TCP_DATA : NONE;
-
-     // update state
-     enum session_state curr_state = session_get_current_state(sess);
-     enum session_state next_state = session_transition_run(curr_state, inputs);
-
-     // update session
-     session_update(sess_mgr_rt, sess, next_state, pkt, key, type);
-     session_transition_log(sess, curr_state, next_state, inputs);
-
-     // update tcp
-     tcp_update(sess_mgr_rt, sess, type, tcp_layer);
-
-     // set closing reason
-     if (next_state == SESSION_STATE_CLOSING && !session_get_closing_reason(sess))
-     {
-          if (flags & TH_FIN)
-          {
-               session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_FIN : CLOSING_BY_SERVER_FIN));
-          }
-          if (flags & TH_RST)
-          {
-               session_set_closing_reason(sess, (type == FLOW_TYPE_C2S ? CLOSING_BY_CLIENT_RST : CLOSING_BY_SERVER_RST));
-          }
-     }
-
-     // update timeout
-     struct tcp_half *curr = &sess->tcp_halfs[type];
-     struct tcp_half *peer = &sess->tcp_halfs[(type == FLOW_TYPE_C2S ? FLOW_TYPE_S2C : FLOW_TYPE_C2S)];
-     uint64_t timeout = 0;
-     switch (next_state)
-     {
-     case SESSION_STATE_OPENING:
-          if (flags & TH_SYN)
-          {
-               timeout = (flags & TH_ACK) ? sess_mgr_rt->cfg.tcp_timeout_ms.handshake : sess_mgr_rt->cfg.tcp_timeout_ms.init;
-          }
-          else
-          {
-               timeout = sess_mgr_rt->cfg.tcp_timeout_ms.data;
-          }
-          break;
-     case SESSION_STATE_ACTIVE:
-          timeout = sess_mgr_rt->cfg.tcp_timeout_ms.data;
-          break;
-     case SESSION_STATE_CLOSING:
-          if (flags & TH_FIN)
-          {
-               timeout = (peer->history & TH_FIN) ? sess_mgr_rt->cfg.tcp_timeout_ms.time_wait : sess_mgr_rt->cfg.tcp_timeout_ms.half_closed;
-          }
-          else if (flags & TH_RST)
-          {
-               // if fin is received, the expected sequence number should be increased by 1
-               uint32_t expected = (peer->history & TH_FIN) ? peer->ack + 1 : peer->ack;
-               timeout = (expected == curr->seq) ? sess_mgr_rt->cfg.tcp_timeout_ms.time_wait : sess_mgr_rt->cfg.tcp_timeout_ms.unverified_rst;
-          }
-          else
-          {
-               timeout = sess_mgr_rt->cfg.tcp_timeout_ms.data;
-          }
-          break;
-     case SESSION_STATE_DISCARD:
-          timeout = sess_mgr_rt->cfg.tcp_timeout_ms.discard_default;
-          break;
-     default:
-          assert(0);
-          break;
-     }
-     session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + timeout);
-
-     SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp);
-
-     return 0;
-}
-
-static int session_manager_runtime_update_udp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, const struct tuple6 *key)
-{
-     enum flow_type type = identify_flow_type_by_history(sess, key);
-     enum session_state curr_state = session_get_current_state(sess);
-     enum session_state next_state = session_transition_run(curr_state, UDP_DATA);
-     session_update(sess_mgr_rt, sess, next_state, pkt, key, type);
-     session_transition_log(sess, curr_state, next_state, UDP_DATA);
-
-     if (session_get_current_state(sess) == SESSION_STATE_DISCARD)
-     {
-          session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.discard_default);
-     }
-     else
-     {
-          session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.data);
-     }
-
-     SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp);
-
-     return 0;
-}
-
-struct session *session_manager_runtime_new_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, uint64_t now_ms)
-{
-     sess_mgr_rt->now_ms = now_ms;
-
-     struct tuple6 key;
-     if (packet_get_innermost_tuple6(pkt, &key))
-     {
-          return NULL;
-     }
-     switch (key.ip_proto)
-     {
-     case IPPROTO_TCP:
-          if (session_manager_runtime_bypass_packet_on_tcp_table_limit(sess_mgr_rt, &key))
-          {
-               return NULL;
-          }
-          return session_manager_runtime_new_tcp_session(sess_mgr_rt, pkt, &key);
-     case IPPROTO_UDP:
-          if (session_manager_runtime_bypass_packet_on_session_evicted(sess_mgr_rt, &key))
-          {
-               return NULL;
-          }
-          if (session_manager_runtime_bypass_packet_on_udp_table_limit(sess_mgr_rt, &key))
-          {
-               return NULL;
-          }
-          return session_manager_runtime_new_udp_session(sess_mgr_rt, pkt, &key);
-     default:
-          return NULL;
-     }
-}
-
-void session_manager_runtime_free_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess)
-{
-     if (sess)
-     {
-          SESSION_MANAGER_LOG_DEBUG("session %lu closed (%s)", session_get_id(sess), closing_reason_to_str(session_get_closing_reason(sess)));
-
-          session_timer_del(sess_mgr_rt->sess_timer, sess);
-          switch (session_get_type(sess))
-          {
-          case SESSION_TYPE_TCP:
-               tcp_clean(sess_mgr_rt, sess);
-               if (session_table_find_sessid(sess_mgr_rt->tcp_sess_table, session_get_id(sess), 0) == sess)
-               {
-                    session_table_del(sess_mgr_rt->tcp_sess_table, sess);
-               }
-               SESS_MGR_STAT_DEC(&sess_mgr_rt->stat, session_get_current_state(sess), tcp);
-               sess_mgr_rt->stat.tcp_sess_used--;
-               break;
-          case SESSION_TYPE_UDP:
-               if (session_table_find_sessid(sess_mgr_rt->udp_sess_table, session_get_id(sess), 0) == sess)
-               {
-                    session_table_del(sess_mgr_rt->udp_sess_table, sess);
-               }
-               SESS_MGR_STAT_DEC(&sess_mgr_rt->stat, session_get_current_state(sess), udp);
-               sess_mgr_rt->stat.udp_sess_used--;
-               break;
-          default:
-               assert(0);
-               break;
-          }
-
-          packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_C2S));
-          packet_free((struct packet *)session_get_first_packet(sess, FLOW_TYPE_S2C));
-          session_set_first_packet(sess, FLOW_TYPE_C2S, NULL);
-          session_set_first_packet(sess, FLOW_TYPE_S2C, NULL);
-          session_clear_route_ctx(sess, FLOW_TYPE_C2S);
-          session_clear_route_ctx(sess, FLOW_TYPE_S2C);
-          session_clear_sids(sess, FLOW_TYPE_C2S);
-          session_clear_sids(sess, FLOW_TYPE_S2C);
-          session_set_current_state(sess, SESSION_STATE_INIT);
-          session_set_current_packet(sess, NULL);
-          session_set_flow_type(sess, FLOW_TYPE_NONE);
-          session_init(sess);
-          session_pool_push(sess_mgr_rt->sess_pool, sess);
-          sess = NULL;
-     }
-}
-
-struct session *session_manager_runtime_lookup_session_by_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt)
-{
-     struct tuple6 key;
-     if (packet_get_innermost_tuple6(pkt, &key))
-     {
-          return NULL;
-     }
-     switch (key.ip_proto)
-     {
-     case IPPROTO_UDP:
-          return session_table_find_tuple6(sess_mgr_rt->udp_sess_table, &key, 0);
-     case IPPROTO_TCP:
-          return session_manager_runtime_lookup_tcp_session(sess_mgr_rt, pkt, &key);
-     default:
-          return NULL;
-     }
-}
-
-struct session *session_manager_runtime_lookup_session_by_id(struct session_manager_runtime *sess_mgr_rt, uint64_t sess_id)
-{
-     struct session *sess = NULL;
-     sess = session_table_find_sessid(sess_mgr_rt->tcp_sess_table, sess_id, 1);
-     if (sess)
-     {
-          return sess;
-     }
-
-     sess = session_table_find_sessid(sess_mgr_rt->udp_sess_table, sess_id, 1);
-     if (sess)
-     {
-          return sess;
-     }
-
-     return NULL;
-}
-
-int session_manager_runtime_update_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, uint64_t now_ms)
-{
-     sess_mgr_rt->now_ms = now_ms;
-
-     struct tuple6 key;
-     if (packet_get_innermost_tuple6(pkt, &key))
-     {
-          return -1;
-     }
-     if (session_manager_runtime_bypass_duplicated_packet(sess_mgr_rt, sess, pkt, &key))
-     {
-          return -1;
-     }
-     switch (session_get_type(sess))
-     {
-     case SESSION_TYPE_TCP:
-          return session_manager_runtime_update_tcp_session(sess_mgr_rt, sess, pkt, &key);
-     case SESSION_TYPE_UDP:
-          return session_manager_runtime_update_udp_session(sess_mgr_rt, sess, pkt, &key);
-     default:
-          return -1;
-     }
-}
-
-struct session *session_manager_runtime_get_expired_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms)
-{
-     sess_mgr_rt->now_ms = now_ms;
-
-     struct session *sess = session_timer_expire(sess_mgr_rt->sess_timer, now_ms);
-     if (sess)
-     {
-          enum session_state curr_state = session_get_current_state(sess);
-          enum session_state next_state = session_transition_run(curr_state, TIMEOUT);
-          session_transition_log(sess, curr_state, next_state, TIMEOUT);
-          session_set_current_state(sess, next_state);
-
-          switch (session_get_type(sess))
-          {
-          case SESSION_TYPE_TCP:
-               SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp);
-               break;
-          case SESSION_TYPE_UDP:
-               SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp);
-               break;
-          default:
-               assert(0);
-               break;
-          }
-
-          // next state is closed, need to free session
-          if (next_state == SESSION_STATE_CLOSED)
-          {
-               if (!session_get_closing_reason(sess))
-               {
-                    session_set_closing_reason(sess, CLOSING_BY_TIMEOUT);
-               }
-               return sess;
-          }
-          // next state is closing, only update timeout
-          else
-          {
-               switch (session_get_type(sess))
-               {
-               case SESSION_TYPE_TCP:
-                    session_timer_update(sess_mgr_rt->sess_timer, sess, now_ms + sess_mgr_rt->cfg.tcp_timeout_ms.data);
-                    break;
-               case SESSION_TYPE_UDP:
-                    session_timer_update(sess_mgr_rt->sess_timer, sess, now_ms + sess_mgr_rt->cfg.udp_timeout_ms.data);
-                    break;
-               default:
-                    assert(0);
-                    break;
-               }
-               return NULL;
-          }
-     }
-
-     return NULL;
-}
-
-struct session *session_manager_runtime_get_evicted_session(struct session_manager_runtime *sess_mgr_rt)
-{
-     struct session *sess = TAILQ_FIRST(&sess_mgr_rt->evicte_list);
-     if (sess)
-     {
-          TAILQ_REMOVE(&sess_mgr_rt->evicte_list, sess, evicte_tqe);
-     }
-     return sess;
-}
-
-uint64_t session_manager_runtime_clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size)
-{
-     sess_mgr_rt->now_ms = now_ms;
-     struct session *sess = NULL;
-     uint64_t cleaned_sess_num = 0;
-     uint64_t expired_sess_num = 0;
-
-     uint8_t expired_sess_canbe_clean = 0;
-     if (now_ms - sess_mgr_rt->last_clean_expired_sess_ts >= sess_mgr_rt->cfg.expire_period_ms ||
-         now_ms == UINT64_MAX)
-     {
-          expired_sess_canbe_clean = 1;
-     }
-
-     for (uint64_t i = 0; i < array_size; i++)
-     {
-          // frist clean evicted session
-          sess = session_manager_runtime_get_evicted_session(sess_mgr_rt);
-          if (sess)
-          {
-               cleaned_sess[cleaned_sess_num++] = sess;
-          }
-          // then clean expired session
-          else
-          {
-               if (expired_sess_canbe_clean && expired_sess_num < sess_mgr_rt->cfg.expire_batch_max)
-               {
-                    sess_mgr_rt->last_clean_expired_sess_ts = now_ms;
-                    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, now_ms);
-                    if (sess)
-                    {
-                         cleaned_sess[cleaned_sess_num++] = sess;
-                         expired_sess_num++;
-                    }
-                    else
-                    {
-                         break;
-                    }
-               }
-               else
-               {
-                    break;
-               }
-          }
-     }
-
-     return cleaned_sess_num;
-}
-
-/******************************************************************************
- * stat -- get / print
- ******************************************************************************/
-
-struct session_manager_stat *session_manager_runtime_get_stat(struct session_manager_runtime *sess_mgr_rt)
-{
-     return &sess_mgr_rt->stat;
-}
-
-void session_manager_runtime_print_stat(struct session_manager_runtime *sess_mgr_rt)
-{
-     struct session_manager_stat *stat = &sess_mgr_rt->stat;
-
-     // TCP session
-     SESSION_MANAGER_LOG_INFO("runtime: %p, TCP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu",
-                              sess_mgr_rt, stat->history_tcp_sessions, stat->tcp_sess_used, stat->tcp_sess_opening, stat->tcp_sess_active,
-                              stat->tcp_sess_closing, stat->tcp_sess_discard, stat->tcp_sess_closed);
-     // UDP session
-     SESSION_MANAGER_LOG_INFO("runtime: %p, UDP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu",
-                              sess_mgr_rt, stat->history_udp_sessions, stat->udp_sess_used, stat->udp_sess_opening, stat->udp_sess_active,
-                              stat->udp_sess_closing, stat->udp_sess_discard, stat->udp_sess_closed);
-     // evicted session
-     SESSION_MANAGER_LOG_INFO("runtime: %p, evicted session stat => TCP: %lu, UDP: %lu", sess_mgr_rt, stat->tcp_sess_evicted, stat->udp_sess_evicted);
-     // Bypassed packet
-     SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed TCP packet stat => table_full: %lu, session_not_found: %lu, duplicated: %lu",
-                              sess_mgr_rt, stat->tcp_pkts_bypass_table_full, stat->tcp_pkts_bypass_session_not_found, stat->tcp_pkts_bypass_duplicated);
-     SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed UDP packet stat => table_full: %lu, session_evicted: %lu, duplicated: %lu",
-                              sess_mgr_rt, stat->udp_pkts_bypass_table_full, stat->udp_pkts_bypass_session_evicted, stat->udp_pkts_bypass_duplicated);
-     // TCP segment
-     SESSION_MANAGER_LOG_INFO("runtime: %p, TCP segment stat => input: %lu, consumed: %lu, timeout: %lu, retransmited: %lu, overlapped: %lu, omitted_too_many: %lu, inorder: %lu, reordered: %lu, buffered: %lu, freed: %lu",
-                              sess_mgr_rt, stat->tcp_segs_input, stat->tcp_segs_consumed, stat->tcp_segs_timeout, stat->tcp_segs_retransmited,
-                              stat->tcp_segs_overlapped, stat->tcp_segs_omitted_too_many, stat->tcp_segs_inorder, stat->tcp_segs_reordered,
-                              stat->tcp_segs_buffered, stat->tcp_segs_freed);
-}
-
-/******************************************************************************
- * scan
- ******************************************************************************/
-
-static inline uint8_t ipv4_in_range(const struct in_addr *addr, const struct in_addr *start, const struct in_addr *end)
-{
-     return (memcmp(addr, start, sizeof(struct in_addr)) >= 0 && memcmp(addr, end, sizeof(struct in_addr)) <= 0);
-}
-
-static inline uint8_t ipv6_in_range(const struct in6_addr *addr, const struct in6_addr *start, const struct in6_addr *end)
-{
-     return (memcmp(addr, start, sizeof(struct in6_addr)) >= 0 && memcmp(addr, end, sizeof(struct in6_addr)) <= 0);
-}
-
-uint64_t session_manager_runtime_scan(const struct session_manager_runtime *sess_mgr_rt, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size)
-{
-     uint64_t capacity = 0;
-     uint64_t max_loop = 0;
-     uint64_t mached_sess_num = 0;
-     const struct session *sess = NULL;
-     const struct tuple6 *tuple = NULL;
-
-     if (sess_mgr_rt == NULL || opts == NULL || mached_sess_ids == NULL || array_size == 0)
-     {
-          return mached_sess_num;
-     }
-     if (opts->count == 0)
-     {
-          return mached_sess_num;
-     }
-     capacity = sess_mgr_rt->cfg.tcp_session_max + sess_mgr_rt->cfg.udp_session_max;
-     if (opts->cursor >= capacity)
-     {
-          return mached_sess_num;
-     }
-
-     max_loop = MIN(capacity, opts->cursor + opts->count);
-     for (uint64_t i = opts->cursor; i < max_loop; i++)
-     {
-          sess = session_pool_get0(sess_mgr_rt->sess_pool, i);
-          tuple = session_get_tuple6(sess);
-          if (session_get_current_state(sess) == SESSION_STATE_INIT)
-          {
-               continue;
-          }
-
-          if ((opts->flags & SESSION_SCAN_TYPE) && opts->type != session_get_type(sess))
-          {
-               continue;
-          }
-          if ((opts->flags & SESSION_SCAN_STATE) && opts->state != session_get_current_state(sess))
-          {
-               continue;
-          }
-          if ((opts->flags & SESSION_SCAN_CREATE_TIME) &&
-              (session_get_timestamp(sess, SESSION_TIMESTAMP_START) < opts->create_time_ms[0] ||
-               session_get_timestamp(sess, SESSION_TIMESTAMP_START) > opts->create_time_ms[1]))
-          {
-               continue;
-          }
-          if ((opts->flags & SESSION_SCAN_LAST_PKT_TIME) &&
-              (session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) < opts->last_pkt_time_ms[0] ||
-               session_get_timestamp(sess, SESSION_TIMESTAMP_LAST) > opts->last_pkt_time_ms[1]))
-          {
-               continue;
-          }
-          if ((opts->flags & SESSION_SCAN_SPORT) && opts->src_port != tuple->src_port)
-          {
-               continue;
-          }
-          if ((opts->flags & SESSION_SCAN_DPORT) && opts->dst_port != tuple->dst_port)
-          {
-               continue;
-          }
-          if (opts->flags & SESSION_SCAN_SIP)
-          {
-               if (opts->addr_family != tuple->addr_family)
-               {
-                    continue;
-               }
-               if ((opts->addr_family == AF_INET) && !ipv4_in_range(&tuple->src_addr.v4, &opts->src_addr[0].v4, &opts->src_addr[1].v4))
-               {
-                    continue;
-               }
-               if ((opts->addr_family == AF_INET6) && !ipv6_in_range(&tuple->src_addr.v6, &opts->src_addr[0].v6, &opts->src_addr[1].v6))
-               {
-                    continue;
-               }
-          }
-          if (opts->flags & SESSION_SCAN_DIP)
-          {
-               if (opts->addr_family != tuple->addr_family)
-               {
-                    continue;
-               }
-               if ((opts->addr_family == AF_INET) && !ipv4_in_range(&tuple->dst_addr.v4, &opts->dst_addr[0].v4, &opts->dst_addr[1].v4))
-               {
-                    continue;
-               }
-               if ((opts->addr_family == AF_INET6) && !ipv6_in_range(&tuple->dst_addr.v6, &opts->dst_addr[0].v6, &opts->dst_addr[1].v6))
-               {
-                    continue;
-               }
-          }
-
-          mached_sess_ids[mached_sess_num++] = session_get_id(sess);
-          if (mached_sess_num >= array_size)
-          {
-               break;
-          }
-     }
-
-     SESSION_MANAGER_LOG_DEBUG("session scan => cursor: %lu, count: %lu, mached_sess_num: %lu", opts->cursor, opts->count, mached_sess_num);
-     return mached_sess_num;
-}
-
-/******************************************************************************
- * other
- ******************************************************************************/
-
-void session_set_discard(struct session *sess)
-{
-     struct session_manager_runtime *sess_mgr_rt = sess->sess_mgr_rt;
-     enum session_type type = session_get_type(sess);
-     enum session_state curr_state = session_get_current_state(sess);
-     enum session_state next_state = session_transition_run(curr_state, USER_CLOSE);
-     session_transition_log(sess, curr_state, next_state, USER_CLOSE);
-     session_set_current_state(sess, next_state);
-
-     switch (type)
-     {
-     case SESSION_TYPE_TCP:
-          session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.tcp_timeout_ms.discard_default);
-          SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, tcp);
-          break;
-     case SESSION_TYPE_UDP:
-          session_timer_update(sess_mgr_rt->sess_timer, sess, sess_mgr_rt->now_ms + sess_mgr_rt->cfg.udp_timeout_ms.discard_default);
-          SESS_MGR_STAT_UPDATE(&sess_mgr_rt->stat, curr_state, next_state, udp);
-          break;
-     default:
-          assert(0);
-          break;
-     }
-}
\ No newline at end of file
diff --git a/infra/session_manager/session_manager_runtime.h b/infra/session_manager/session_manager_runtime.h
deleted file mode 100644
index 0b5a961..0000000
--- a/infra/session_manager/session_manager_runtime.h
+++ /dev/null
@@ -1,184 +0,0 @@
-#pragma once
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include "tuple.h"
-#include "stellar/session.h"
-
-#define SESSION_MANAGER_LOG_FATAL(format, ...) STELLAR_LOG_FATAL(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
-#define SESSION_MANAGER_LOG_ERROR(format, ...) STELLAR_LOG_ERROR(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
-#define SESSION_MANAGER_LOG_DEBUG(format, ...) STELLAR_LOG_DEBUG(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
-#define SESSION_MANAGER_LOG_INFO(format, ...) STELLAR_LOG_INFO(__thread_local_logger, "session manager", format, ##__VA_ARGS__)
-
-struct session_manager_config
-{
-    uint64_t instance_id;
-    uint16_t thread_num;
-    uint64_t session_id_seed;
-    uint64_t tcp_session_max;
-    uint64_t udp_session_max;
-
-    uint8_t evict_old_on_tcp_table_limit; // range: [0, 1]
-    uint8_t evict_old_on_udp_table_limit; // range: [0, 1]
-
-    uint64_t expire_period_ms; // range: [0, 60000] (ms)
-    uint64_t expire_batch_max; // range: [1, 1024]
-
-    struct
-    {
-        uint64_t init;            // range: [1, 60000] (ms)
-        uint64_t handshake;       // range: [1, 60000] (ms)
-        uint64_t data;            // range: [1, 15999999000] (ms)
-        uint64_t half_closed;     // range: [1, 604800000] (ms)
-        uint64_t time_wait;       // range: [1, 600000] (ms)
-        uint64_t discard_default; // range: [1, 15999999000] (ms)
-        uint64_t unverified_rst;  // range: [1, 600000] (ms)
-    } tcp_timeout_ms;
-
-    struct
-    {
-        uint64_t data;            // range: [1, 15999999000] (ms)
-        uint64_t discard_default; // range: [1, 15999999000] (ms)
-    } udp_timeout_ms;
-
-    struct
-    {
-        uint8_t enable;          // range: [0, 1]
-        uint32_t capacity;       // range: [1, 4294967295]
-        uint32_t time_window_ms; // range: [1, 60000] (ms)
-        double error_rate;       // range: [0.0, 1.0]
-    } duplicated_packet_bloom_filter;
-
-    struct
-    {
-        uint8_t enable;          // range: [0, 1]
-        uint32_t capacity;       // range: [1, 4294967295]
-        uint32_t time_window_ms; // range: [1, 60000] (ms)
-        double error_rate;       // range: [0.0, 1.0]
-    } evicted_session_bloom_filter;
-
-    struct
-    {
-        uint8_t enable;                 // range: [0, 1]
-        uint32_t timeout_ms;            // range: [1, 60000] (ms)
-        uint32_t buffered_segments_max; // range: [2, 4096]
-    } tcp_reassembly;
-};
-
-struct session_manager_stat
-{
-    // TCP session
-    uint64_t history_tcp_sessions;
-    uint64_t tcp_sess_used;
-    uint64_t tcp_sess_opening;
-    uint64_t tcp_sess_active;
-    uint64_t tcp_sess_closing;
-    uint64_t tcp_sess_discard;
-    uint64_t tcp_sess_closed;
-
-    // UDP session
-    uint64_t history_udp_sessions;
-    uint64_t udp_sess_used;
-    uint64_t udp_sess_opening;
-    uint64_t udp_sess_active;
-    uint64_t udp_sess_closing;
-    uint64_t udp_sess_discard;
-    uint64_t udp_sess_closed;
-
-    // Evicted session
-    uint64_t tcp_sess_evicted; // sum
-    uint64_t udp_sess_evicted; // sum
-
-    // Packet
-    uint64_t udp_pkts_bypass_table_full;        // sum
-    uint64_t tcp_pkts_bypass_table_full;        // sum
-    uint64_t tcp_pkts_bypass_session_not_found; // sum
-    uint64_t tcp_pkts_bypass_duplicated;        // sum
-    uint64_t udp_pkts_bypass_duplicated;        // sum
-    uint64_t udp_pkts_bypass_session_evicted;   // sum
-
-    // TCP segments
-    uint64_t tcp_segs_input;            // sum
-    uint64_t tcp_segs_consumed;         // sum
-    uint64_t tcp_segs_timeout;          // sum
-    uint64_t tcp_segs_retransmited;     // sum
-    uint64_t tcp_segs_overlapped;       // sum
-    uint64_t tcp_segs_omitted_too_many; // sum
-    uint64_t tcp_segs_inorder;          // sum
-    uint64_t tcp_segs_reordered;        // sum
-    uint64_t tcp_segs_buffered;         // sum
-    uint64_t tcp_segs_freed;            // sum
-} __attribute__((aligned(64)));
-
-enum session_scan_flags
-{
-    SESSION_SCAN_TYPE = 1 << 0,
-    SESSION_SCAN_STATE = 1 << 1,
-
-    SESSION_SCAN_SIP = 1 << 2,
-    SESSION_SCAN_DIP = 1 << 3,
-
-    SESSION_SCAN_SPORT = 1 << 4,
-    SESSION_SCAN_DPORT = 1 << 5,
-
-    SESSION_SCAN_CREATE_TIME = 1 << 6,
-    SESSION_SCAN_LAST_PKT_TIME = 1 << 7,
-};
-
-struct session_scan_opts
-{
-    // required
-    uint32_t flags;
-    uint32_t cursor;
-    uint32_t count;
-
-    // optional
-    enum session_type type;
-    enum session_state state;
-
-    uint32_t addr_family;         // AF_INET or AF_INET6
-    union ip_address src_addr[2]; // network byte order
-    union ip_address dst_addr[2]; // network byte order
-    uint16_t src_port;            // network byte order
-    uint16_t dst_port;            // network byte order
-
-    uint64_t create_time_ms[2];
-    uint64_t last_pkt_time_ms[2];
-};
-
-// new/free/print config
-struct session_manager_config *session_manager_config_new(const char *toml_file);
-void session_manager_config_free(struct session_manager_config *sess_mgr_cfg);
-void session_manager_config_print(struct session_manager_config *sess_mgr_cfg);
-
-// new/free runtime
-struct session_manager_runtime;
-struct session_manager_runtime *session_manager_runtime_new(const struct session_manager_config *sess_mgr_cfg, uint64_t now_ms);
-void session_manager_runtime_free(struct session_manager_runtime *sess_mgr_rt);
-
-// new/free/lookup/update/clean session
-struct session *session_manager_runtime_new_session(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt, uint64_t now_ms);
-void session_manager_runtime_free_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess);
-struct session *session_manager_runtime_lookup_session_by_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt);
-struct session *session_manager_runtime_lookup_session_by_id(struct session_manager_runtime *sess_mgr_rt, uint64_t sess_id);
-int session_manager_runtime_update_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess, const struct packet *pkt, uint64_t now_ms);
-struct session *session_manager_runtime_get_expired_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms);
-struct session *session_manager_runtime_get_evicted_session(struct session_manager_runtime *sess_mgr_rt);
-uint64_t session_manager_runtime_clean_session(struct session_manager_runtime *sess_mgr_rt, uint64_t now_ms, struct session *cleaned_sess[], uint64_t array_size);
-
-// stat
-struct session_manager_stat *session_manager_runtime_get_stat(struct session_manager_runtime *sess_mgr_rt);
-void session_manager_runtime_print_stat(struct session_manager_runtime *sess_mgr_rt);
-
-// scan
-uint64_t session_manager_runtime_scan(const struct session_manager_runtime *sess_mgr_rt, const struct session_scan_opts *opts, uint64_t mached_sess_ids[], uint64_t array_size);
-
-// duplicated packet
-void session_manager_runtime_record_duplicated_packet(struct session_manager_runtime *sess_mgr_rt, const struct packet *pkt);
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/infra/session_manager/session_manager_stat.c b/infra/session_manager/session_manager_stat.c
new file mode 100644
index 0000000..8591f6b
--- /dev/null
+++ b/infra/session_manager/session_manager_stat.c
@@ -0,0 +1,39 @@
+#include "session_manager_log.h"
+#include "session_manager_stat.h"
+
+uint64_t session_manager_stat_get(struct session_manager_stat *stat, enum sess_mgr_stat_type type)
+{
+    switch (type)
+    {
+#define XX(_type, _name) case _type: return stat->_name;
+    SESS_MGR_STAT_MAP(XX)
+#undef XX
+    default:
+        return 0;
+    }
+}
+
+void session_manager_stat_print(struct session_manager_stat *stat)
+{
+    // TCP session
+    SESSION_MANAGER_LOG_INFO("runtime: %p, TCP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu",
+                             stat, stat->history_tcp_sessions, stat->tcp_sess_used, stat->tcp_sess_opening, stat->tcp_sess_active,
+                             stat->tcp_sess_closing, stat->tcp_sess_discard, stat->tcp_sess_closed);
+    // UDP session
+    SESSION_MANAGER_LOG_INFO("runtime: %p, UDP session stat => history: %lu, used: %lu, opening: %lu, active: %lu, closing: %lu, discard: %lu, closed: %lu",
+                             stat, stat->history_udp_sessions, stat->udp_sess_used, stat->udp_sess_opening, stat->udp_sess_active,
+                             stat->udp_sess_closing, stat->udp_sess_discard, stat->udp_sess_closed);
+    // Evicted session
+    SESSION_MANAGER_LOG_INFO("runtime: %p, evicted session stat => TCP: %lu, UDP: %lu",
+                             stat, stat->tcp_sess_evicted, stat->udp_sess_evicted);
+    // Bypassed packet
+    SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed TCP packet stat => table_full: %lu, session_not_found: %lu, duplicated: %lu",
+                             stat, stat->tcp_pkts_bypass_table_full, stat->tcp_pkts_bypass_session_not_found, stat->tcp_pkts_bypass_duplicated);
+    SESSION_MANAGER_LOG_INFO("runtime: %p, bypassed UDP packet stat => table_full: %lu, session_evicted: %lu, duplicated: %lu",
+                             stat, stat->udp_pkts_bypass_table_full, stat->udp_pkts_bypass_session_evicted, stat->udp_pkts_bypass_duplicated);
+    // TCP segment
+    SESSION_MANAGER_LOG_INFO("runtime: %p, TCP segment stat => input: %lu, consumed: %lu, timeout: %lu, retransmited: %lu, overlapped: %lu, omitted_too_many: %lu, inorder: %lu, reordered: %lu, buffered: %lu, freed: %lu",
+                             stat, stat->tcp_segs_input, stat->tcp_segs_consumed, stat->tcp_segs_timeout, stat->tcp_segs_retransmited,
+                             stat->tcp_segs_overlapped, stat->tcp_segs_omitted_too_many, stat->tcp_segs_inorder, stat->tcp_segs_reordered,
+                             stat->tcp_segs_buffered, stat->tcp_segs_freed);
+}
diff --git a/infra/session_manager/session_manager_stat.h b/infra/session_manager/session_manager_stat.h
new file mode 100644
index 0000000..b279764
--- /dev/null
+++ b/infra/session_manager/session_manager_stat.h
@@ -0,0 +1,166 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+
+#define SESS_MGR_STAT_INC(stat, state, proto) \
+    {                                         \
+        switch ((state))                      \
+        {                                     \
+        case SESSION_STATE_OPENING:           \
+            (stat)->proto##_sess_opening++;   \
+            break;                            \
+        case SESSION_STATE_ACTIVE:            \
+            (stat)->proto##_sess_active++;    \
+            break;                            \
+        case SESSION_STATE_CLOSING:           \
+            (stat)->proto##_sess_closing++;   \
+            break;                            \
+        case SESSION_STATE_DISCARD:           \
+            (stat)->proto##_sess_discard++;   \
+            break;                            \
+        case SESSION_STATE_CLOSED:            \
+            (stat)->proto##_sess_closed++;    \
+            break;                            \
+        default:                              \
+            break;                            \
+        }                                     \
+    }
+
+#define SESS_MGR_STAT_DEC(stat, state, proto) \
+    {                                         \
+        switch ((state))                      \
+        {                                     \
+        case SESSION_STATE_OPENING:           \
+            (stat)->proto##_sess_opening--;   \
+            break;                            \
+        case SESSION_STATE_ACTIVE:            \
+            (stat)->proto##_sess_active--;    \
+            break;                            \
+        case SESSION_STATE_CLOSING:           \
+            (stat)->proto##_sess_closing--;   \
+            break;                            \
+        case SESSION_STATE_DISCARD:           \
+            (stat)->proto##_sess_discard--;   \
+            break;                            \
+        case SESSION_STATE_CLOSED:            \
+            (stat)->proto##_sess_closed--;    \
+            break;                            \
+        default:                              \
+            break;                            \
+        }                                     \
+    }
+
+#define SESS_MGR_STAT_UPDATE(stat, curr, next, proto) \
+    {                                                 \
+        if (curr != next)                             \
+        {                                             \
+            SESS_MGR_STAT_DEC(stat, curr, proto);     \
+            SESS_MGR_STAT_INC(stat, next, proto);     \
+        }                                             \
+    }
+
+struct session_manager_stat
+{
+    // TCP session
+    uint64_t history_tcp_sessions;
+    uint64_t tcp_sess_used;
+    uint64_t tcp_sess_opening;
+    uint64_t tcp_sess_active;
+    uint64_t tcp_sess_closing;
+    uint64_t tcp_sess_discard;
+    uint64_t tcp_sess_closed;
+
+    // UDP session
+    uint64_t history_udp_sessions;
+    uint64_t udp_sess_used;
+    uint64_t udp_sess_opening;
+    uint64_t udp_sess_active;
+    uint64_t udp_sess_closing;
+    uint64_t udp_sess_discard;
+    uint64_t udp_sess_closed;
+
+    // Evicted session
+    uint64_t tcp_sess_evicted; // sum
+    uint64_t udp_sess_evicted; // sum
+
+    // Packet
+    uint64_t udp_pkts_bypass_table_full;        // sum
+    uint64_t tcp_pkts_bypass_table_full;        // sum
+    uint64_t tcp_pkts_bypass_session_not_found; // sum
+    uint64_t tcp_pkts_bypass_duplicated;        // sum
+    uint64_t udp_pkts_bypass_duplicated;        // sum
+    uint64_t udp_pkts_bypass_session_evicted;   // sum
+
+    // TCP segments
+    uint64_t tcp_segs_input;            // sum
+    uint64_t tcp_segs_consumed;         // sum
+    uint64_t tcp_segs_timeout;          // sum
+    uint64_t tcp_segs_retransmited;     // sum
+    uint64_t tcp_segs_overlapped;       // sum
+    uint64_t tcp_segs_omitted_too_many; // sum
+    uint64_t tcp_segs_inorder;          // sum
+    uint64_t tcp_segs_reordered;        // sum
+    uint64_t tcp_segs_buffered;         // sum
+    uint64_t tcp_segs_freed;            // sum
+} __attribute__((aligned(64)));
+
+#define SESS_MGR_STAT_MAP(XX)                                                              \
+    XX(SESS_MGR_STAT_HISTORY_TCP_SESSIONS, history_tcp_sessions)                           \
+    XX(SESS_MGR_STAT_TCP_SESS_USED, tcp_sess_used)                                         \
+    XX(SESS_MGR_STAT_TCP_SESS_OPENING, tcp_sess_opening)                                   \
+    XX(SESS_MGR_STAT_TCP_SESS_ACTIVE, tcp_sess_active)                                     \
+    XX(SESS_MGR_STAT_TCP_SESS_CLOSING, tcp_sess_closing)                                   \
+    XX(SESS_MGR_STAT_TCP_SESS_DISCARD, tcp_sess_discard)                                   \
+    XX(SESS_MGR_STAT_TCP_SESS_CLOSED, tcp_sess_closed)                                     \
+    XX(SESS_MGR_STAT_HISTORY_UDP_SESSIONS, history_udp_sessions)                           \
+    XX(SESS_MGR_STAT_UDP_SESS_USED, udp_sess_used)                                         \
+    XX(SESS_MGR_STAT_UDP_SESS_OPENING, udp_sess_opening)                                   \
+    XX(SESS_MGR_STAT_UDP_SESS_ACTIVE, udp_sess_active)                                     \
+    XX(SESS_MGR_STAT_UDP_SESS_CLOSING, udp_sess_closing)                                   \
+    XX(SESS_MGR_STAT_UDP_SESS_DISCARD, udp_sess_discard)                                   \
+    XX(SESS_MGR_STAT_UDP_SESS_CLOSED, udp_sess_closed)                                     \
+    XX(SESS_MGR_STAT_TCP_SESS_EVICTED, tcp_sess_evicted)                                   \
+    XX(SESS_MGR_STAT_UDP_SESS_EVICTED, udp_sess_evicted)                                   \
+    XX(SESS_MGR_STAT_UDP_PKTS_BYPASS_TABLE_FULL, udp_pkts_bypass_table_full)               \
+    XX(SESS_MGR_STAT_TCP_PKTS_BYPASS_TABLE_FULL, tcp_pkts_bypass_table_full)               \
+    XX(SESS_MGR_STAT_TCP_PKTS_BYPASS_SESSION_NOT_FOUND, tcp_pkts_bypass_session_not_found) \
+    XX(SESS_MGR_STAT_TCP_PKTS_BYPASS_DUPLICATED, tcp_pkts_bypass_duplicated)               \
+    XX(SESS_MGR_STAT_UDP_PKTS_BYPASS_DUPLICATED, udp_pkts_bypass_duplicated)               \
+    XX(SESS_MGR_STAT_UDP_PKTS_BYPASS_SESSION_EVICTED, udp_pkts_bypass_session_evicted)     \
+    XX(SESS_MGR_STAT_TCP_SEGS_INPUT, tcp_segs_input)                                       \
+    XX(SESS_MGR_STAT_TCP_SEGS_CONSUMED, tcp_segs_consumed)                                 \
+    XX(SESS_MGR_STAT_TCP_SEGS_TIMEOUT, tcp_segs_timeout)                                   \
+    XX(SESS_MGR_STAT_TCP_SEGS_RETRANSMITED, tcp_segs_retransmited)                         \
+    XX(SESS_MGR_STAT_TCP_SEGS_OVERLAPPED, tcp_segs_overlapped)                             \
+    XX(SESS_MGR_STAT_TCP_SEGS_OMITTED_TOO_MANY, tcp_segs_omitted_too_many)                 \
+    XX(SESS_MGR_STAT_TCP_SEGS_INORDER, tcp_segs_inorder)                                   \
+    XX(SESS_MGR_STAT_TCP_SEGS_REORDERED, tcp_segs_reordered)                               \
+    XX(SESS_MGR_STAT_TCP_SEGS_BUFFERED, tcp_segs_buffered)                                 \
+    XX(SESS_MGR_STAT_TCP_SEGS_FREED, tcp_segs_freed)
+
+enum sess_mgr_stat_type
+{
+#define XX(type, name) type,
+    SESS_MGR_STAT_MAP(XX)
+#undef XX
+    SESS_MGR_STAT_MAX
+};
+
+__attribute__((unused)) static const char sess_mgr_stat_str[SESS_MGR_STAT_MAX][64] =
+{
+#define XX(type, name) #name,
+    SESS_MGR_STAT_MAP(XX)
+#undef XX
+};
+
+uint64_t session_manager_stat_get(struct session_manager_stat *stat, enum sess_mgr_stat_type type);
+void session_manager_stat_print(struct session_manager_stat *stat);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/infra/session_manager/session_table.h b/infra/session_manager/session_table.h
index 5dc73fb..2452361 100644
--- a/infra/session_manager/session_table.h
+++ b/infra/session_manager/session_table.h
@@ -5,6 +5,8 @@ extern "C"
 {
 #endif
 
+#include "tuple.h"
+
 struct session_table;
 struct session_table *session_table_new();
 void session_table_free(struct session_table *table);
diff --git a/infra/session_manager/session_utils.c b/infra/session_manager/session_utils.c
index 801ddd4..6bf2386 100644
--- a/infra/session_manager/session_utils.c
+++ b/infra/session_manager/session_utils.c
@@ -1,6 +1,6 @@
 #include "stellar/exdata.h"
 #include "session_internal.h"
-#include "session_manager_runtime.h"
+#include "session_manager_stat.h"
 
 void session_init(struct session *sess)
 {
diff --git a/infra/session_manager/test/default_config.h b/infra/session_manager/test/default_config.h
deleted file mode 100644
index f6d8af6..0000000
--- a/infra/session_manager/test/default_config.h
+++ /dev/null
@@ -1,68 +0,0 @@
-
-
-#pragma once
-
-#ifdef __cplusplus
-extern "C"
-{
-#endif
-
-#include "session_manager_runtime.h"
-
-static struct session_manager_config sess_mgr_cfg = {
-    .instance_id = 1,
-    .thread_num = 1,
-    .session_id_seed = 0xFFFFF,
-    .tcp_session_max = 256,
-    .udp_session_max = 256,
-
-    .evict_old_on_tcp_table_limit = 1,
-    .evict_old_on_udp_table_limit = 1,
-
-    .expire_period_ms = 0,
-    .expire_batch_max = 1024,
-
-    .tcp_timeout_ms =
-        {
-            .init = 1,
-            .handshake = 2,
-            .data = 3,
-            .half_closed = 4,
-            .time_wait = 5,
-            .discard_default = 6,
-            .unverified_rst = 7,
-        },
-
-    .udp_timeout_ms =
-        {
-            .data = 8,
-            .discard_default = 0,
-        },
-
-    .duplicated_packet_bloom_filter =
-        {
-            .enable = 1,
-            .capacity = 1000,
-            .time_window_ms = 10,
-            .error_rate = 0.0001,
-        },
-
-    .evicted_session_bloom_filter =
-        {
-            .enable = 1,
-            .capacity = 1000,
-            .time_window_ms = 10,
-            .error_rate = 0.0001,
-        },
-
-    .tcp_reassembly =
-        {
-            .enable = 1,
-            .timeout_ms = 1000,
-            .buffered_segments_max = 16,
-        },
-};
-
-#ifdef __cplusplus
-}
-#endif
diff --git a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
index 0f7e80c..ee382a2 100644
--- a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
+++ b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
@@ -1,10 +1,4 @@
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
+#include "test_utils.h"
 
 /******************************************************************************
  * case: TCP init -> opening (by TCP Fast Open)
@@ -263,11 +257,11 @@ TEST(CASE, TCP_FAST_OPEN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S fast open packet\n");
@@ -276,9 +270,10 @@ TEST(CASE, TCP_FAST_OPEN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -347,7 +342,7 @@ TEST(CASE, TCP_FAST_OPEN)
     session_free_tcp_segment(sess, seg);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -355,24 +350,25 @@ TEST(CASE, TCP_FAST_OPEN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
index 8ae1a9b..b8d0334 100644
--- a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
+++ b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
@@ -1,29 +1,15 @@
-#include <gtest/gtest.h>
-
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void packet_set_ip_id(struct packet *pkt, uint16_t ip_id)
-{
-    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
-    EXPECT_TRUE(ipv4_layer);
-    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
-    hdr->ip_id = htons(ip_id);
-}
+#include "test_utils.h"
 
 #if 1
 TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -32,12 +18,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -48,12 +37,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == -1);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
@@ -63,20 +55,23 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
-    packet_set_ip_id(&pkt, 0x1234);
+    packet_overwrite_ipid(&pkt, 0x1234);
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -85,11 +80,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -98,12 +93,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -114,12 +112,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == -1);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
@@ -129,20 +130,23 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     memcpy(synack_retransmission, tcp_pkt2_s2c_syn_ack, sizeof(tcp_pkt2_s2c_syn_ack));
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)synack_retransmission, sizeof(tcp_pkt2_s2c_syn_ack));
-    packet_set_ip_id(&pkt, 0x1234);
+    packet_overwrite_ipid(&pkt, 0x1234);
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -151,12 +155,12 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
     char syn_retransmission[1500] = {0};
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -165,12 +169,15 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -179,16 +186,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
-    packet_set_ip_id(&pkt, 0x1234);
+    packet_overwrite_ipid(&pkt, 0x1234);
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -197,16 +207,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     memcpy(syn_retransmission, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)syn_retransmission, sizeof(tcp_pkt1_c2s_syn));
-    packet_set_ip_id(&pkt, 0x1235);
+    packet_overwrite_ipid(&pkt, 0x1235);
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -217,16 +230,19 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -235,14 +251,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
-    _cfg.duplicated_packet_bloom_filter.enable = 0;
+    struct session_manager_cfg _sess_mgr_cfg;
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
+    _sess_mgr_cfg.duplicated_packet_bloom_filter.enable = 0;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -251,12 +267,15 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -267,16 +286,19 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -285,14 +307,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
-    _cfg.duplicated_packet_bloom_filter.enable = 0;
+    struct session_manager_cfg _sess_mgr_cfg;
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
+    _sess_mgr_cfg.duplicated_packet_bloom_filter.enable = 0;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -301,12 +323,15 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
@@ -317,16 +342,19 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+
+    // check stat
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
index d7ec896..50e024d 100644
--- a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
+++ b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
@@ -1,33 +1,18 @@
-#include <gtest/gtest.h>
-
-#include "utils_internal.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
-{
-    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
-    EXPECT_TRUE(ipv4_layer);
-    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
-    hdr->ip_src.s_addr = htonl(addr);
-}
+#include "test_utils.h"
 
 #if 1
 TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
 {
     struct packet pkt;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
-    _cfg.tcp_session_max = RX_BURST_MAX * 2;
-    _cfg.udp_session_max = RX_BURST_MAX * 2;
+    struct session_manager_cfg _sess_mgr_cfg;
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
+    _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -36,15 +21,15 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
+    for (uint32_t i = 0; i < _sess_mgr_cfg.tcp_session_max; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.tcp_session_max);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
@@ -53,7 +38,7 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -61,16 +46,16 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
 TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
 {
     struct packet pkt;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
-    _cfg.tcp_session_max = RX_BURST_MAX * 2;
-    _cfg.udp_session_max = RX_BURST_MAX * 2;
-    _cfg.evict_old_on_tcp_table_limit = 0;
+    struct session_manager_cfg _sess_mgr_cfg;
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
+    _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.evict_old_on_tcp_table_limit = 0;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -79,16 +64,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
+    for (uint32_t i = 0; i < _sess_mgr_cfg.tcp_session_max; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.tcp_session_max);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _sess_mgr_cfg.tcp_session_max);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
@@ -99,15 +84,16 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     // table full, evict new session
     for (uint32_t i = 0; i < RX_BURST_MAX; i++)
     {
-        packet_set_ip_src_addr(&pkt, _cfg.tcp_session_max + i);
-        EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL);
+        uint32_t idx = _sess_mgr_cfg.tcp_session_max + i;
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx);
+        EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL);
     }
     printf("=> Session Manager: after evicte new session\n");
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _cfg.tcp_session_max);
-    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == _sess_mgr_cfg.tcp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == _sess_mgr_cfg.tcp_session_max);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
@@ -115,7 +101,7 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
index cb7b8b6..fbc8adb 100644
--- a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
+++ b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
@@ -1,34 +1,19 @@
-#include <gtest/gtest.h>
-
-#include "utils_internal.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
-{
-    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
-    EXPECT_TRUE(ipv4_layer);
-    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
-    hdr->ip_src.s_addr = htonl(addr);
-}
+#include "test_utils.h"
 
 #if 1
 TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
-    _cfg.tcp_session_max = RX_BURST_MAX * 2;
-    _cfg.udp_session_max = RX_BURST_MAX * 2;
+    struct session_manager_cfg _sess_mgr_cfg;
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
+    _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -37,15 +22,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
+    for (uint32_t i = 0; i < _sess_mgr_cfg.udp_session_max; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.udp_session_max);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
@@ -57,10 +42,10 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     // evicted session
     while (1)
     {
-        sess = session_manager_runtime_get_evicted_session(sess_mgr_rt);
+        sess = session_manager_rte_get_evicted_session(sess_mgr_rte);
         if (sess)
         {
-            session_manager_runtime_free_session(sess_mgr_rt, sess);
+            session_manager_rte_free_session(sess_mgr_rte, sess);
         }
         else
         {
@@ -70,12 +55,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 
     for (uint32_t i = 0; i < RX_BURST_MAX; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
-        EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL); // hit evicted session, can't renew session
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
+        EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL); // hit evicted session, can't renew session
     }
     printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
@@ -87,11 +72,12 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
 
     // evicted session timeout
-    packet_set_ip_src_addr(&pkt, 0);
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
-    EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms));
+    uint32_t idx = 0;
+    packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1 + _sess_mgr_cfg.evicted_session_bloom_filter.time_window_ms));
     printf("=> Session Manager: after evicted session timeout\n");
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == RX_BURST_MAX + 1);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == RX_BURST_MAX);
@@ -102,7 +88,7 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -110,16 +96,16 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
 {
     struct packet pkt;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
-    struct session_manager_config _cfg;
-    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
-    _cfg.tcp_session_max = RX_BURST_MAX * 2;
-    _cfg.udp_session_max = RX_BURST_MAX * 2;
-    _cfg.evict_old_on_udp_table_limit = 0;
+    struct session_manager_cfg _sess_mgr_cfg;
+    memcpy(&_sess_mgr_cfg, &sess_mgr_cfg, sizeof(struct session_manager_cfg));
+    _sess_mgr_cfg.tcp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.udp_session_max = RX_BURST_MAX * 2;
+    _sess_mgr_cfg.evict_old_on_udp_table_limit = 0;
 
-    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&_sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -128,16 +114,16 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     printf("<= Packet Parse: done\n\n");
 
     // new session
-    for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
+    for (uint32_t i = 0; i < _sess_mgr_cfg.udp_session_max; i++)
     {
-        packet_set_ip_src_addr(&pkt, i);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&i);
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1));
     }
-    printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    printf("=> Session Manager: after add %lu new sessions\n", _sess_mgr_cfg.udp_session_max);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _sess_mgr_cfg.udp_session_max);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
@@ -146,20 +132,21 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
 
     // evicted session
-    EXPECT_TRUE(session_manager_runtime_get_evicted_session(sess_mgr_rt) == NULL);
+    EXPECT_TRUE(session_manager_rte_get_evicted_session(sess_mgr_rte) == NULL);
 
     // table full, evict new session
     for (uint32_t i = 0; i < RX_BURST_MAX; i++)
     {
-        packet_set_ip_src_addr(&pkt, _cfg.udp_session_max + i);
-        EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
-        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1) == NULL);
+        uint32_t idx = _sess_mgr_cfg.udp_session_max + i;
+        packet_overwrite_v4_saddr(&pkt, (struct in_addr *)&idx);
+        EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+        EXPECT_TRUE(session_manager_rte_new_session(sess_mgr_rte, &pkt, 1) == NULL);
     }
     printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _cfg.udp_session_max);
-    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == _sess_mgr_cfg.udp_session_max);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == _sess_mgr_cfg.udp_session_max);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
@@ -167,7 +154,7 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == RX_BURST_MAX);
     EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_sess_mgr_scan.cpp b/infra/session_manager/test/gtest_sess_mgr_scan.cpp
index 6b9530b..0369fcc 100644
--- a/infra/session_manager/test/gtest_sess_mgr_scan.cpp
+++ b/infra/session_manager/test/gtest_sess_mgr_scan.cpp
@@ -1,27 +1,13 @@
-#include <gtest/gtest.h>
+#include "test_utils.h"
 
-#include "session_internal.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static inline void packet_overwrite_src_addr(struct packet *pkt, struct in_addr addr)
+static inline void mached_session_print(const char *title, struct session_manager_rte *sess_mgr_rte, uint64_t mached_sess_id[], uint64_t mached_sess_num)
 {
-    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
-    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
-    hdr->ip_src = addr;
-}
-
-static inline void mached_session_print(const char *title, struct session_manager_runtime *sess_mgr_rt, uint64_t mached_sess_ids[], uint64_t mached_sess_num)
-{
-    struct session *sess = NULL;
     printf("%-*s mached_sess_num: %lu\n", 40, title, mached_sess_num);
     for (uint64_t i = 0; i < mached_sess_num; i++)
     {
-        sess = session_manager_runtime_lookup_session_by_id(sess_mgr_rt, mached_sess_ids[i]);
+        struct session *sess = session_manager_rte_lookup_session_by_id(sess_mgr_rte, mached_sess_id[i]);
         printf("session id: %lu, addr: %s, type: %s, state: %s, start: %lu, last: %lu\n",
-               mached_sess_ids[i], session_get0_readable_addr(sess),
+               mached_sess_id[i], session_get0_readable_addr(sess),
                session_type_to_str(session_get_type(sess)),
                session_state_to_str(session_get_current_state(sess)),
                session_get_timestamp(sess, SESSION_TIMESTAMP_START),
@@ -34,10 +20,10 @@ TEST(SESS_MGR_SCAN, OPTS)
 {
     char buff[1500] = {0};
     uint64_t mached_sess_num = 0;
-    uint64_t mached_sess_ids[1460];
+    uint64_t mached_sess_id[1460];
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
     struct in_addr v4_src_addr1 = {};
     struct in_addr v4_src_addr2 = {};
@@ -85,91 +71,91 @@ TEST(SESS_MGR_SCAN, OPTS)
     inet_pton(AF_INET6, "cafe::0000", &v6_dst_subnet_beg);
     inet_pton(AF_INET6, "cafe::ffff", &v6_dst_subnet_end);
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // new session
     memset(&pkt, 0, sizeof(pkt));
     memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
-    packet_overwrite_src_addr(&pkt, v4_src_addr1);
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    packet_overwrite_v4_saddr(&pkt, &v4_src_addr1);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // new session
     memset(&pkt, 0, sizeof(pkt));
     memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
-    packet_overwrite_src_addr(&pkt, v4_src_addr2);
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 2);
+    packet_overwrite_v4_saddr(&pkt, &v4_src_addr2);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 2);
     EXPECT_TRUE(sess);
 
     // new session
     memset(&pkt, 0, sizeof(pkt));
     memcpy(buff, tcp_pkt1_c2s_syn, sizeof(tcp_pkt1_c2s_syn));
     packet_parse(&pkt, (const char *)buff, sizeof(tcp_pkt1_c2s_syn));
-    packet_overwrite_src_addr(&pkt, v4_src_addr3);
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 3);
+    packet_overwrite_v4_saddr(&pkt, &v4_src_addr3);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 3);
     EXPECT_TRUE(sess);
 
     // new session
     memset(&pkt, 0, sizeof(pkt));
     packet_parse(&pkt, (const char *)ipv6_in_ipv6_udp, sizeof(ipv6_in_ipv6_udp));
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 4);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 4);
     EXPECT_TRUE(sess);
 
     struct session_scan_opts scan = {};
-    // scan.flags = SESSION_SCAN_TYPE | SESSION_SCAN_STATE | SESSION_SCAN_SIP | SESSION_SCAN_DIP | SESSION_SCAN_SPORT | SESSION_SCAN_DPORT | SESSION_SCAN_CREATE_TIME | SESSION_SCAN_LAST_PKT_TIME;
+    // scan.flags = SESSION_SCAN_TYPE | SESSION_SCAN_STATE | SESSION_SCAN_SIP | SESSION_SCAN_DIP | SESSION_SCAN_SPORT | SESSION_SCAN_DPORT | SESSION_SCAN_CREATE_TIME | SESSION_SCAN_LASPKT_TIME;
     scan.cursor = 0;
     scan.count = 1460;
 
-    scan.last_pkt_time_ms[0] = 0;
-    scan.last_pkt_time_ms[1] = UINT64_MAX;
+    scan.laspkt_time_ms[0] = 0;
+    scan.laspkt_time_ms[1] = UINT64_MAX;
 
     // SESSION_SCAN_TYPE
     scan.flags = SESSION_SCAN_TYPE;
 
     scan.type = SESSION_TYPE_TCP;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.type = SESSION_TYPE_UDP;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_STATE
     scan.flags = SESSION_SCAN_STATE;
 
     scan.state = SESSION_STATE_OPENING;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 4);
-    mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.state = SESSION_STATE_ACTIVE;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.state = SESSION_STATE_CLOSING;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.state = SESSION_STATE_DISCARD;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.state = SESSION_STATE_CLOSED;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_SIP
     scan.flags = SESSION_SCAN_SIP;
@@ -177,44 +163,44 @@ TEST(SESS_MGR_SCAN, OPTS)
     scan.addr_family = AF_INET;
     scan.src_addr[0].v4 = v4_src_addr1;
     scan.src_addr[1].v4 = v4_src_addr1;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET;
     scan.src_addr[0].v4 = v4_src_subnet_beg;
     scan.src_addr[1].v4 = v4_src_subnet_end;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET;
     scan.src_addr[0].v4 = v4_min_addr;
     scan.src_addr[1].v4 = v4_max_addr;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.src_addr[0].v6, &v6_src_addr, sizeof(v6_src_addr));
     memcpy(&scan.src_addr[1].v6, &v6_src_addr, sizeof(v6_src_addr));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.src_addr[0].v6, &v6_src_subnet_beg, sizeof(v6_src_subnet_beg));
     memcpy(&scan.src_addr[1].v6, &v6_src_subnet_end, sizeof(v6_src_subnet_end));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.src_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr));
     memcpy(&scan.src_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_DIP
     scan.flags = SESSION_SCAN_DIP;
@@ -222,126 +208,126 @@ TEST(SESS_MGR_SCAN, OPTS)
     scan.addr_family = AF_INET;
     scan.dst_addr[0].v4 = v4_dst_addr;
     scan.dst_addr[1].v4 = v4_dst_addr;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET;
     scan.dst_addr[0].v4 = v4_dst_subnet_beg;
     scan.dst_addr[1].v4 = v4_dst_subnet_end;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET;
     scan.dst_addr[0].v4 = v4_min_addr;
     scan.dst_addr[1].v4 = v4_max_addr;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.dst_addr[0].v6, &v6_dst_addr, sizeof(v6_dst_addr));
     memcpy(&scan.dst_addr[1].v6, &v6_dst_addr, sizeof(v6_dst_addr));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.dst_addr[0].v6, &v6_dst_subnet_beg, sizeof(v6_dst_subnet_beg));
     memcpy(&scan.dst_addr[1].v6, &v6_dst_subnet_end, sizeof(v6_dst_subnet_end));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.addr_family = AF_INET6;
     memcpy(&scan.dst_addr[0].v6, &v6_min_addr, sizeof(v6_min_addr));
     memcpy(&scan.dst_addr[1].v6, &v6_max_addr, sizeof(v6_max_addr));
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_SPORT
     scan.flags = SESSION_SCAN_SPORT;
 
     scan.src_port = htons(60111);
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.src_port = htons(60110);
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_DPORT
     scan.flags = SESSION_SCAN_DPORT;
 
     scan.dst_port = htons(80);
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.dst_port = htons(81);
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     // SESSION_SCAN_CREATE_TIME
     scan.flags = SESSION_SCAN_CREATE_TIME;
 
     scan.create_time_ms[0] = 0;
     scan.create_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 4);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.create_time_ms[0] = 1;
     scan.create_time_ms[1] = 2;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 2);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.create_time_ms[0] = 0;
     scan.create_time_ms[1] = 0;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
     scan.create_time_ms[0] = UINT64_MAX;
     scan.create_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    // SESSION_SCAN_LAST_PKT_TIME
-    scan.flags = SESSION_SCAN_LAST_PKT_TIME;
+    // SESSION_SCAN_LASPKT_TIME
+    scan.flags = SESSION_SCAN_LASPKT_TIME;
 
-    scan.last_pkt_time_ms[0] = 0;
-    scan.last_pkt_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    scan.laspkt_time_ms[0] = 0;
+    scan.laspkt_time_ms[1] = UINT64_MAX;
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 4);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LASPKT_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    scan.last_pkt_time_ms[0] = 1;
-    scan.last_pkt_time_ms[1] = 2;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    scan.laspkt_time_ms[0] = 1;
+    scan.laspkt_time_ms[1] = 2;
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 2);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LASPKT_TIME: (HIT)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    scan.last_pkt_time_ms[0] = 0;
-    scan.last_pkt_time_ms[1] = 0;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    scan.laspkt_time_ms[0] = 0;
+    scan.laspkt_time_ms[1] = 0;
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LASPKT_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    scan.last_pkt_time_ms[0] = UINT64_MAX;
-    scan.last_pkt_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    scan.laspkt_time_ms[0] = UINT64_MAX;
+    scan.laspkt_time_ms[1] = UINT64_MAX;
+    mached_sess_num = session_manager_rte_scan_session(sess_mgr_rte, &scan, mached_sess_id, sizeof(mached_sess_id) / sizeof(mached_sess_id[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LASPKT_TIME: (MISS)", sess_mgr_rte, mached_sess_id, mached_sess_num);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
index 88eb20f..7ee70e4 100644
--- a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
+++ b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
@@ -1,24 +1,4 @@
-#include <gtest/gtest.h>
-
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void hex_dump(const char *payload, uint32_t len)
-{
-    printf("Payload Length: %u\n", len);
-    for (uint32_t i = 0; i < len; i++)
-    {
-        if (i > 0 && i % 16 == 0)
-        {
-            printf("\n");
-        }
-        printf("%02x ", (uint8_t)payload[i]);
-    }
-    printf("\n");
-}
+#include "test_utils.h"
 
 #if 1
 TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
@@ -26,10 +6,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     struct tcp_segment *seg;
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -38,9 +18,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     seg = session_get_tcp_segment(sess);
@@ -53,10 +34,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -68,10 +50,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -83,10 +66,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -98,10 +82,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 5) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -113,10 +98,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 6) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -128,10 +114,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 7) == 0);
 
     /*
      * 11111111111111111111111111111111111111111111111111111111111111
@@ -166,48 +153,49 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload1));
     EXPECT_TRUE(memcmp((void *)seg->data, payload1, sizeof(payload1)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload2));
     EXPECT_TRUE(memcmp((void *)seg->data, payload2, sizeof(payload2)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload3));
     EXPECT_TRUE(memcmp((void *)seg->data, payload3, sizeof(payload3)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload4));
     EXPECT_TRUE(memcmp((void *)seg->data, payload4, sizeof(payload4)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(payload5));
     EXPECT_TRUE(memcmp((void *)seg->data, payload5, sizeof(payload5)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);                      // active -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 7 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);                      // active -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 7 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -217,10 +205,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     struct tcp_segment *seg;
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -229,9 +217,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     seg = session_get_tcp_segment(sess);
@@ -244,10 +233,11 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -259,16 +249,17 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt3_payload));
     EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt3_payload, sizeof(tcp_seq_wraparound_pkt3_payload)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     // C2S Data Packet
@@ -278,29 +269,31 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
     EXPECT_TRUE(seg->len == sizeof(tcp_seq_wraparound_pkt4_payload));
     EXPECT_TRUE(memcmp((void *)seg->data, tcp_seq_wraparound_pkt4_payload, sizeof(tcp_seq_wraparound_pkt4_payload)) == 0);
-    hex_dump((const char *)seg->data, seg->len);
+    hexdump_to_fd(STDOUT_FILENO, 0, (const char *)seg->data, seg->len);
     session_free_tcp_segment(sess, seg);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);                      // active -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 4 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);                      // active -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 4 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_session_filter.cpp b/infra/session_manager/test/gtest_session_filter.cpp
index c3a0911..c9c6d05 100644
--- a/infra/session_manager/test/gtest_session_filter.cpp
+++ b/infra/session_manager/test/gtest_session_filter.cpp
@@ -1,7 +1,4 @@
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "session_filter.h"
+#include "test_utils.h"
 
 TEST(SESSION_FILTER, TEST)
 {
diff --git a/infra/session_manager/test/gtest_session_pool.cpp b/infra/session_manager/test/gtest_session_pool.cpp
index db6df28..8c868ee 100644
--- a/infra/session_manager/test/gtest_session_pool.cpp
+++ b/infra/session_manager/test/gtest_session_pool.cpp
@@ -1,6 +1,4 @@
-#include <gtest/gtest.h>
-
-#include "session_pool.h"
+#include "test_utils.h"
 
 TEST(SESSION_POOL, POP_PUSH)
 {
diff --git a/infra/session_manager/test/gtest_session_table.cpp b/infra/session_manager/test/gtest_session_table.cpp
index 72906eb..4a45f38 100644
--- a/infra/session_manager/test/gtest_session_table.cpp
+++ b/infra/session_manager/test/gtest_session_table.cpp
@@ -1,9 +1,4 @@
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "session_internal.h"
-#include "session_pool.h"
-#include "session_table.h"
+#include "test_utils.h"
 
 #define TUPLE6_SET_V4_TCP(t6)                               \
     {                                                       \
diff --git a/infra/session_manager/test/gtest_session_timer.cpp b/infra/session_manager/test/gtest_session_timer.cpp
index ef5a720..a118629 100644
--- a/infra/session_manager/test/gtest_session_timer.cpp
+++ b/infra/session_manager/test/gtest_session_timer.cpp
@@ -1,7 +1,4 @@
-#include <gtest/gtest.h>
-
-#include "session_internal.h"
-#include "session_timer.h"
+#include "test_utils.h"
 
 TEST(SESSION_TIMER, EXPIRE)
 {
diff --git a/infra/session_manager/test/gtest_session_transition.cpp b/infra/session_manager/test/gtest_session_transition.cpp
index a41309e..f9c9ed2 100644
--- a/infra/session_manager/test/gtest_session_transition.cpp
+++ b/infra/session_manager/test/gtest_session_transition.cpp
@@ -1,6 +1,4 @@
-#include <gtest/gtest.h>
-
-#include "session_transition.h"
+#include "test_utils.h"
 
 TEST(SESSION_TRANSITION, RUN)
 {
diff --git a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
index d45eb2b..f84a59f 100644
--- a/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_active_to_closing.cpp
@@ -1,14 +1,7 @@
 // TCP state machine test: active -> closing
-#include <gtest/gtest.h>
+#include "test_utils.h"
 
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
-static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess)
+static void build_active_tcp_session(struct session_manager_rte *sess_mgr_rte, struct session *sess)
 {
     struct packet pkt;
 
@@ -19,9 +12,10 @@ static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S DATA Packet
@@ -31,10 +25,11 @@ static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 }
 
 /******************************************************************************
@@ -47,14 +42,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -63,10 +58,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -75,10 +71,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -100,7 +97,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -108,23 +105,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -138,14 +136,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // C2S RST Packet
     printf("\n=> Packet Parse: TCP C2S RST packet\n");
@@ -160,10 +158,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -185,7 +184,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -193,23 +192,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -223,14 +223,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // S2C RST Packet
     printf("\n=> Packet Parse: TCP S2C RST packet\n");
@@ -245,10 +245,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -270,7 +271,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -278,23 +279,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -306,17 +308,17 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
 TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
 {
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -324,24 +326,25 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -355,14 +358,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -371,10 +374,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -396,7 +400,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -404,23 +408,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -434,14 +439,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(sess_mgr_rt, sess);
+    build_active_tcp_session(sess_mgr_rte, sess);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -450,10 +455,11 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -475,7 +481,7 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -483,23 +489,24 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
index 92002b5..3ae89ff 100644
--- a/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening.cpp
@@ -1,12 +1,5 @@
 // TCP state machine test: init -> opening
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
+#include "test_utils.h"
 
 /******************************************************************************
  * case: TCP init -> opening (by SYN)
@@ -18,11 +11,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +24,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -56,7 +50,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -64,24 +58,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -95,11 +90,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -108,9 +103,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -133,7 +129,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -141,24 +137,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -172,11 +169,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -185,9 +182,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -197,10 +195,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -222,7 +221,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -230,24 +229,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -261,11 +261,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -274,9 +274,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -286,10 +287,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -298,10 +300,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -323,7 +326,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -331,24 +334,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -364,11 +368,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -377,9 +381,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S SYN Packet retransmission
@@ -394,10 +399,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -419,7 +425,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -427,24 +433,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -460,11 +467,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -473,9 +480,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // SYNACK Packet retransmission
@@ -491,10 +499,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -516,7 +525,7 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -524,24 +533,25 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -555,11 +565,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -568,9 +578,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S ACK Packet
@@ -580,10 +591,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -605,7 +617,7 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -613,24 +625,25 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -644,11 +657,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -657,9 +670,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C ACK Packet
@@ -669,10 +683,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -694,7 +709,7 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -702,24 +717,25 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
index 4678fd8..508ebd9 100644
--- a/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_init_to_opening_to_active_to_closing_to_closed.cpp
@@ -1,12 +1,5 @@
 // TCP state machine test: init -> opening -> active -> closing -> closed
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
+#include "test_utils.h"
 
 #if 1
 TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
@@ -14,11 +7,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     char buffer[1024];
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -27,9 +20,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -58,10 +52,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -89,10 +84,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -120,10 +116,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 4) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -151,10 +148,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 5) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -182,10 +180,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 6) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -213,10 +212,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 7) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -244,10 +244,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 8) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 8) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -275,10 +276,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 9) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 9) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -306,10 +308,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 10) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 10) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -337,10 +340,11 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 11) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 11) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -362,7 +366,7 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(session_get_first_packet(sess, FLOW_TYPE_S2C) != NULL);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -370,23 +374,24 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 11 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 11 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
index a1e5fba..5ecded6 100644
--- a/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_opening_to_active.cpp
@@ -1,12 +1,5 @@
 // TCP state machine test: opening -> active
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
+#include "test_utils.h"
 
 /******************************************************************************
  * case: TCP opening -> active (by C2S DATA)
@@ -18,11 +11,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +24,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S DATA Packet
@@ -43,10 +37,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -68,7 +63,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -76,24 +71,25 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -107,11 +103,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -120,9 +116,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C DATA Packet
@@ -132,10 +129,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -157,7 +155,7 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -165,24 +163,25 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
index 06f4f16..7a28bfd 100644
--- a/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_tcp_opening_to_closing.cpp
@@ -1,12 +1,5 @@
 // TCP state machine test: opening -> closing
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
+#include "test_utils.h"
 
 /******************************************************************************
  * case: TCP opening -> closing (by FIN-FIN)
@@ -18,11 +11,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +24,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S FIN Packet
@@ -43,10 +37,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -55,10 +50,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -80,7 +76,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -88,23 +84,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.time_wait);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -118,11 +115,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -131,9 +128,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S RST Packet
@@ -149,10 +147,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -174,7 +173,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -182,23 +181,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_RST);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -212,11 +212,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -225,9 +225,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C RST Packet
@@ -243,10 +244,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -268,7 +270,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -276,23 +278,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.unverified_rst);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_RST);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -305,11 +308,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -318,13 +321,14 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -332,24 +336,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -363,11 +368,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -376,9 +381,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -388,10 +394,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -413,7 +420,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -421,24 +428,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -452,11 +460,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -465,9 +473,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -477,10 +486,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -489,10 +499,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -514,7 +525,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
@@ -522,24 +533,25 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 3 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -553,11 +565,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -566,9 +578,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S FIN Packet
@@ -578,10 +591,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -603,7 +617,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -611,23 +625,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_CLIENT_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -641,11 +656,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -654,9 +669,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C FIN Packet
@@ -666,10 +682,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -691,7 +708,7 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
@@ -699,23 +716,24 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 1);
 
     // expire session
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.half_closed);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_SERVER_FIN);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
index 739f04d..c66708c 100644
--- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_active_to_closing.cpp
@@ -1,24 +1,16 @@
 // UDP state machine test: init -> opening -> active -> closing
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
-
+#include "test_utils.h"
 #if 1
 TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
 {
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -27,9 +19,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,10 +50,11 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -82,7 +76,7 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
@@ -90,24 +84,25 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // active -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // active -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
index 48f6f6a..3c66a18 100644
--- a/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
+++ b/infra/session_manager/test/gtest_state_udp_init_to_opening_to_closing.cpp
@@ -1,12 +1,5 @@
 // UDP state machine test: init -> opening -> closing
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
+#include "test_utils.h"
 
 /******************************************************************************
  * case: UDP init -> opening (by C2S Packet)
@@ -19,11 +12,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -32,9 +25,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,7 +51,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
@@ -65,24 +59,25 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -97,11 +92,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
     struct session_manager_stat *sess_mgr_stat = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C RESP Packet
     printf("\n=> Packet Parse: UDP S2C RESP packet\n");
@@ -110,9 +105,10 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -135,7 +131,7 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     session_print(sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
@@ -143,8 +139,8 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
@@ -152,17 +148,17 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     session_print(sess);
 
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
     // check stat
-    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    sess_mgr_stat = session_manager_rte_get_stat(sess_mgr_rte);
     EXPECT_TRUE(sess_mgr_stat);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
     EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_timeout_tcp_data.cpp b/infra/session_manager/test/gtest_timeout_tcp_data.cpp
index 0cfcc57..768494e 100644
--- a/infra/session_manager/test/gtest_timeout_tcp_data.cpp
+++ b/infra/session_manager/test/gtest_timeout_tcp_data.cpp
@@ -1,21 +1,14 @@
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
+#include "test_utils.h"
 
 #if 1
 TEST(TIMEOUT, TCP_TIMEOUT_DATA)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,9 +17,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S DATA Packet
@@ -36,22 +30,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.tcp_timeout_ms.data + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
index d837a8a..0cb79f6 100644
--- a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
+++ b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
@@ -1,21 +1,14 @@
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
+#include "test_utils.h"
 
 #if 1
 TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -24,22 +17,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake) == NULL);
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.handshake + sess_mgr_cfg.tcp_timeout_ms.data);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_timeout_tcp_init.cpp b/infra/session_manager/test/gtest_timeout_tcp_init.cpp
index b3ca04a..cfc6292 100644
--- a/infra/session_manager/test/gtest_timeout_tcp_init.cpp
+++ b/infra/session_manager/test/gtest_timeout_tcp_init.cpp
@@ -1,21 +1,14 @@
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
+#include "test_utils.h"
 
 #if 1
 TEST(TIMEOUT, TCP_TIMEOUT_INIT)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,22 +17,24 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init) == NULL);                      // opening -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.tcp_timeout_ms.init + sess_mgr_cfg.tcp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_timeout_udp_data.cpp b/infra/session_manager/test/gtest_timeout_udp_data.cpp
index d5663fe..9da1f15 100644
--- a/infra/session_manager/test/gtest_timeout_udp_data.cpp
+++ b/infra/session_manager/test/gtest_timeout_udp_data.cpp
@@ -1,21 +1,14 @@
-#include <gtest/gtest.h>
-
-#include "tuple.h"
-#include "packet_internal.h"
-#include "packet_parser.h"
-#include "session_internal.h"
-#include "default_config.h"
-#include "test_packets.h"
+#include "test_utils.h"
 
 #if 1
 TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -24,22 +17,24 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // opening -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 1 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
@@ -48,10 +43,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_rte *sess_mgr_rte = NULL;
 
-    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
-    EXPECT_TRUE(sess_mgr_rt != NULL);
+    sess_mgr_rte = session_manager_rte_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rte != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -60,9 +55,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt) == NULL);
+
     // new session
-    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
+    sess = session_manager_rte_new_session(sess_mgr_rte, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C RESP Packet
@@ -72,22 +68,24 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
+    sess = session_manager_rte_lookup_session_by_packet(sess_mgr_rte, &pkt);
     EXPECT_TRUE(sess);
+
     // update session
-    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_rte_update_session(sess_mgr_rte, sess, &pkt, 2) == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // active -> closing
-    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
+    EXPECT_TRUE(session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data) == NULL);                      // active -> closing
+    sess = session_manager_rte_get_expired_session(sess_mgr_rte, 2 + sess_mgr_cfg.udp_timeout_ms.data + sess_mgr_cfg.udp_timeout_ms.data); // closing -> closed
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
     EXPECT_TRUE(session_get_closing_reason(sess) == CLOSING_BY_TIMEOUT);
     session_print(sess);
+
     // free session
-    session_manager_runtime_free_session(sess_mgr_rt, sess);
+    session_manager_rte_free_session(sess_mgr_rte, sess);
 
-    session_manager_runtime_free(sess_mgr_rt);
+    session_manager_rte_free(sess_mgr_rte);
 }
 #endif
 
diff --git a/infra/session_manager/test/test_packets.h b/infra/session_manager/test/test_utils.h
index 231ef88..64df5dd 100644
--- a/infra/session_manager/test/test_packets.h
+++ b/infra/session_manager/test/test_utils.h
@@ -1,10 +1,97 @@
 #pragma once
 
+#include <gtest/gtest.h>
+
 #ifdef __cplusplus
 extern "C"
 {
 #endif
 
+#include "tuple.h"
+#include "packet_parser.h"
+#include "packet_internal.h"
+#include "utils_internal.h"
+
+#include "session_pool.h"
+#include "session_timer.h"
+#include "session_table.h"
+#include "session_filter.h"
+#include "session_internal.h"
+#include "session_transition.h"
+#include "session_manager_cfg.h"
+#include "session_manager_rte.h"
+
+__attribute__((unused)) static struct session_manager_cfg sess_mgr_cfg = {
+    .instance_id = 1,
+    .thread_num = 1,
+    .session_id_seed = 0xFFFFF,
+
+    .tcp_session_max = 256,
+    .udp_session_max = 256,
+
+    .evict_old_on_tcp_table_limit = 1,
+    .evict_old_on_udp_table_limit = 1,
+
+    .expire_period_ms = 0,
+    .expire_batch_max = 1024,
+
+    .tcp_timeout_ms =
+        {
+            .init = 1,
+            .handshake = 2,
+            .data = 3,
+            .half_closed = 4,
+            .time_wait = 5,
+            .discard_default = 6,
+            .unverified_rst = 7,
+        },
+
+    .udp_timeout_ms =
+        {
+            .data = 8,
+            .discard_default = 0,
+        },
+
+    .duplicated_packet_bloom_filter =
+        {
+            .enable = 1,
+            .capacity = 1000,
+            .time_window_ms = 10,
+            .error_rate = 0.0001,
+        },
+
+    .evicted_session_bloom_filter =
+        {
+            .enable = 1,
+            .capacity = 1000,
+            .time_window_ms = 10,
+            .error_rate = 0.0001,
+        },
+
+    .tcp_reassembly =
+        {
+            .enable = 1,
+            .timeout_ms = 1000,
+            .buffered_segments_max = 16,
+        },
+};
+
+static inline void packet_overwrite_ipid(struct packet *pkt, uint16_t ip_id)
+{
+    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
+    EXPECT_TRUE(ipv4_layer);
+    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
+    hdr->ip_id = htons(ip_id);
+}
+
+static inline void packet_overwrite_v4_saddr(struct packet *pkt, struct in_addr *addr)
+{
+    const struct layer_private *ipv4_layer = packet_get_innermost_layer(pkt, LAYER_PROTO_IPV4);
+    EXPECT_TRUE(ipv4_layer);
+    struct ip *hdr = (struct ip *)ipv4_layer->hdr_ptr;
+    hdr->ip_src = *addr;
+}
+
 /******************************************************************************
  * test packet: HTTP www.example.com
  ******************************************************************************/
diff --git a/scripts/CMakeLists.txt b/scripts/CMakeLists.txt
index 7243c1d..af17de6 100644
--- a/scripts/CMakeLists.txt
+++ b/scripts/CMakeLists.txt
@@ -1,2 +1 @@
-install(FILES python_stat.sh DESTINATION ./ COMPONENT PROGRAM)
-install(FILES shell_stat.sh DESTINATION ./ COMPONENT PROGRAM)
\ No newline at end of file
+install(FILES stat_format.sh DESTINATION ./ COMPONENT PROGRAM)
\ No newline at end of file
diff --git a/scripts/python_stat.sh b/scripts/python_stat.sh
deleted file mode 100644
index 2cfb69b..0000000
--- a/scripts/python_stat.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash
-
-/opt/MESA/bin/fieldstat_exporter.py local -j /opt/tsg/stellar/log/stellar_fs4.json -l --clear-screen -e
diff --git a/scripts/shell_stat.sh b/scripts/shell_stat.sh
deleted file mode 100644
index 056f882..0000000
--- a/scripts/shell_stat.sh
+++ /dev/null
@@ -1,59 +0,0 @@
-#!/bin/bash +x
-
-#cat stellar_fs4.json |jq
-#[
-#  {
-#    "name": "stellar",
-#    "tags": {},
-#    "fields": {
-#      "aaaa": 1111111,
-#      "bbbb": 2222222,
-#    },
-#    "timestamp_ms": 1713053113549
-#  }
-#]
-
-calculate() {
-    local curr_data=$1
-    local prev_data=$2
-
-    local fields=($(echo "$curr_data" | jq -r '.[].fields | to_entries | .[] | .key' | grep -v timestamp_ms))
-    local curr_ts=$(echo "$curr_data" | jq -r '.[].timestamp_ms')
-    local prev_ts=$(echo "$prev_data" | jq -r '.[].timestamp_ms')
-    local diff_ts=$(($curr_ts - $prev_ts))
-    local seconds=$((curr_ts / 1000))
-    local buffer=()
-
-    local curr_fileds=$(echo "$curr_data" | jq -r '.[].fields' | grep -v timestamp_ms)
-    local prev_fileds=$(echo "$prev_data" | jq -r '.[].fields' | grep -v timestamp_ms)
-
-    buffer+=("====================================$(date -d "@$seconds" +"%Y-%m-%d %H:%M:%S")====================================\n")
-    buffer+=("$(printf "%-30s" Field)$(printf "%-20s" Sum)$(printf "%-20s" Speed)\n")
-    local result=()
-    for field in "${fields[@]}"; do
-        local curr_val=$(echo "$curr_fileds" | grep $field | awk '{print $2}' | sed 's/,//g')
-        local prev_val=$(echo "$prev_fileds" | grep $field | awk '{print $2}' | sed 's/,//g')
-        local diff_val=$((curr_val - prev_val))
-        local speed=0
-        if [ $diff_ts -eq 0 ]; then
-            speed=0
-        else
-            speed=$((diff_val * 1000 / diff_ts))
-        fi
-        buffer+=("$(printf "%-30s" $field)$(printf "%-20s" $curr_val)$(printf "%-20s" $speed)\n")
-    done
-    buffer+=("===========================================================================================\n")
-    clear
-    echo -e "${buffer[@]}"
-}
-
-prev_data=""
-
-while true; do
-    curr_data=$(cat /opt/tsg/stellar/log/stellar_fs4.json)
-    if [ ! -z "$prev_data" ]; then
-        calculate "$curr_data" "$prev_data"
-    fi
-    prev_data="$curr_data"
-    sleep 1
-done
diff --git a/scripts/stat_format.sh b/scripts/stat_format.sh
new file mode 100644
index 0000000..999e839
--- /dev/null
+++ b/scripts/stat_format.sh
@@ -0,0 +1,9 @@
+#!/bin/bash
+
+if [ $# -ne 1 ]; then
+    echo "Usage: $0 <f4_json_file>"
+    exit 1
+fi
+
+f4_json_file=$1
+/opt/MESA/bin/fieldstat_exporter.py local -j $f4_json_file -l --clear-screen