refactor(session manager): rename original session_manager to session_manager_runtime

18 files changed, 1103 insertions, 1103 deletions

diff --git a/infra/session_manager/test/default_config.h b/infra/session_manager/test/default_config.h
index 607c7b7..729caed 100644
--- a/infra/session_manager/test/default_config.h
+++ b/infra/session_manager/test/default_config.h
@@ -9,7 +9,7 @@ extern "C"
 
 #include "session_manager.h"
 
-static struct session_manager_config cfg = {
+static struct session_manager_config sess_mgr_cfg = {
     .session_id_seed = 0xFFFFF,
     .tcp_session_max = 256,
     .udp_session_max = 256,
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 50011ba..0f7e80c 100644
--- a/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
+++ b/infra/session_manager/test/gtest_case_tcp_fast_open.cpp
@@ -263,11 +263,11 @@ TEST(CASE, TCP_FAST_OPEN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S fast open packet\n");
@@ -276,9 +276,9 @@ TEST(CASE, TCP_FAST_OPEN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -347,32 +347,32 @@ TEST(CASE, TCP_FAST_OPEN)
     session_free_tcp_segment(sess, seg);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // closing -> closed
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
index 6869565..8ae1a9b 100644
--- a/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
+++ b/infra/session_manager/test/gtest_filter_tcp_dupkt.cpp
@@ -19,11 +19,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -32,14 +32,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
     // C2S SYN dup Packet
     printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -48,14 +48,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == -1);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
     // C2S SYN retransmission Packet
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -67,16 +67,16 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
@@ -85,11 +85,11 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -98,14 +98,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
     // S2C SYNACK dup Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -114,14 +114,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == -1);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == -1);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
     // S2C SYNACK retransmission Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK retransmission packet\n");
@@ -133,16 +133,16 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 1);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 1);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
@@ -151,12 +151,12 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
     char syn_retransmission[1500] = {0};
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -165,14 +165,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
     // C2S SYN retransmission Packet
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -183,14 +183,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
     // C2S SYN retransmission Packet
     printf("\n=> Packet Parse: TCP C2S SYN retransmission packet\n");
@@ -201,14 +201,14 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
     // C2S SYN dup Packet
     printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -217,16 +217,16 @@ TEST(TCP_DUPKT_FILTER_ENABLE, SKIP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
@@ -235,14 +235,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
     struct session_manager_config _cfg;
-    memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
+    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
     _cfg.duplicated_packet_bloom_filter.enable = 0;
 
-    mgr = session_manager_new(&_cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -251,14 +251,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
     // C2S SYN dup Packet
     printf("\n=> Packet Parse: TCP C2S SYN dup packet\n");
@@ -267,16 +267,16 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYN_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
@@ -285,14 +285,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
     struct session_manager_config _cfg;
-    memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
+    memcpy(&_cfg, &sess_mgr_cfg, sizeof(struct session_manager_config));
     _cfg.duplicated_packet_bloom_filter.enable = 0;
 
-    mgr = session_manager_new(&_cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -301,14 +301,14 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
     // S2C SYNACK dup Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK dup packet\n");
@@ -317,16 +317,16 @@ TEST(TCP_DUPKT_FILTER_DISABLE, SYNACK_DUP)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
     EXPECT_TRUE(session_has_duplicate_traffic(sess) == 0);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_duplicated == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_duplicated == 0);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #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 36e815a..6518104 100644
--- a/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
+++ b/infra/session_manager/test/gtest_overload_evict_tcp_sess.cpp
@@ -19,15 +19,15 @@ static void packet_set_ip_src_addr(struct packet *pkt, uint32_t addr)
 TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
 {
     struct packet pkt;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
     struct session_manager_config _cfg;
-    memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
+    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;
 
-    mgr = session_manager_new(&_cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -39,21 +39,21 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
     for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
     {
         packet_set_ip_src_addr(&pkt, i);
-        EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
+        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
     }
     printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max);
-    EXPECT_TRUE(stat->tcp_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-    EXPECT_TRUE(stat->tcp_sess_closed == RX_BURST_MAX); // have evicted, have't free
-    EXPECT_TRUE(stat->tcp_sess_evicted == RX_BURST_MAX);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == 0);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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 == RX_BURST_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 == RX_BURST_MAX); // have evicted, have't free
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_evicted == RX_BURST_MAX);
+    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_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
@@ -61,16 +61,16 @@ TEST(TCP_OVERLOAD, EVICT_OLD_SESS)
 TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
 {
     struct packet pkt;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
     struct session_manager_config _cfg;
-    memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
+    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;
 
-    mgr = session_manager_new(&_cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -82,40 +82,40 @@ TEST(TCP_OVERLOAD, EVICT_NEW_SESS)
     for (uint32_t i = 0; i < _cfg.tcp_session_max; i++)
     {
         packet_set_ip_src_addr(&pkt, i);
-        EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
+        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
     }
     printf("=> Session Manager: after add %lu new sessions\n", _cfg.tcp_session_max);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max);
-    EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-    EXPECT_TRUE(stat->tcp_sess_closed == 0);
-    EXPECT_TRUE(stat->tcp_sess_evicted == 0);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == 0);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_evicted == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_table_full == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_pkts_bypass_session_not_found == 0);
 
     // 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_lookup_session_by_packet(mgr, &pkt) == NULL);
-        EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
+        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);
     }
     printf("=> Session Manager: after evicte new session\n");
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == _cfg.tcp_session_max);
-    EXPECT_TRUE(stat->tcp_sess_opening == _cfg.tcp_session_max);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-    EXPECT_TRUE(stat->tcp_sess_closed == 0);
-    EXPECT_TRUE(stat->tcp_sess_evicted == 0);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_table_full == RX_BURST_MAX);
-    EXPECT_TRUE(stat->tcp_pkts_bypass_session_not_found == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closed == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_evicted == 0);
+    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_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #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 1595e8e..aefe600 100644
--- a/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
+++ b/infra/session_manager/test/gtest_overload_evict_udp_sess.cpp
@@ -20,15 +20,15 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
     struct session_manager_config _cfg;
-    memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
+    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;
 
-    mgr = session_manager_new(&_cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -40,27 +40,27 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
     for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
     {
         packet_set_ip_src_addr(&pkt, i);
-        EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
+        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
     }
     printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max);
-    EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess_closed == RX_BURST_MAX); // have evicted, have't free
-    EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0);
-    EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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 == RX_BURST_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 == RX_BURST_MAX); // have evicted, have't free
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == RX_BURST_MAX);
+    EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
 
     // evicted session
     while (1)
     {
-        sess = session_manager_get_evicted_session(mgr);
+        sess = session_manager_runtime_get_evicted_session(sess_mgr_rt);
         if (sess)
         {
-            session_manager_free_session(mgr, sess);
+            session_manager_runtime_free_session(sess_mgr_rt, sess);
         }
         else
         {
@@ -71,38 +71,38 @@ 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_lookup_session_by_packet(mgr, &pkt) == NULL);
-        EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL); // hit evicted session, can't renew session
+        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
     }
     printf("=> Session Manager: after readd %d evicted sessions\n", RX_BURST_MAX);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess_closed == 0);
-    EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0);
-    EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
+    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);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == RX_BURST_MAX);
+    EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
+    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_lookup_session_by_packet(mgr, &pkt) == NULL);
-    EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1 + _cfg.evicted_session_bloom_filter.time_window_ms));
+    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));
     printf("=> Session Manager: after evicted session timeout\n");
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == RX_BURST_MAX + 1);
-    EXPECT_TRUE(stat->udp_sess_opening == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess_closed == 1); // have evicted, have't free
-    EXPECT_TRUE(stat->udp_sess_evicted == RX_BURST_MAX + 1);
-    EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0);
-    EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == RX_BURST_MAX);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
+    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 == 1); // have evicted, have't free
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == RX_BURST_MAX + 1);
+    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);
 }
 #endif
 
@@ -110,16 +110,16 @@ TEST(UDP_OVERLOAD, EVICT_OLD_SESS)
 TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
 {
     struct packet pkt;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
     struct session_manager_config _cfg;
-    memcpy(&_cfg, &cfg, sizeof(struct session_manager_config));
+    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;
 
-    mgr = session_manager_new(&_cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -131,43 +131,43 @@ TEST(UDP_OVERLOAD, EVICT_NEW_SESS)
     for (uint32_t i = 0; i < _cfg.udp_session_max; i++)
     {
         packet_set_ip_src_addr(&pkt, i);
-        EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1));
+        EXPECT_TRUE(session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1));
     }
     printf("=> Session Manager: after add %lu new sessions\n", _cfg.udp_session_max);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max);
-    EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess_closed == 0);
-    EXPECT_TRUE(stat->udp_sess_evicted == 0);
-    EXPECT_TRUE(stat->udp_pkts_bypass_table_full == 0);
-    EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_table_full == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_pkts_bypass_session_evicted == 0);
 
     // evicted session
-    EXPECT_TRUE(session_manager_get_evicted_session(mgr) == NULL);
+    EXPECT_TRUE(session_manager_runtime_get_evicted_session(sess_mgr_rt) == 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_lookup_session_by_packet(mgr, &pkt) == NULL);
-        EXPECT_TRUE(session_manager_new_session(mgr, &pkt, 1) == NULL);
+        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);
     }
     printf("=> Session Manager: after readd %d evicted session\n", RX_BURST_MAX);
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == _cfg.udp_session_max);
-    EXPECT_TRUE(stat->udp_sess_opening == _cfg.udp_session_max);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
-    EXPECT_TRUE(stat->udp_sess_closed == 0);
-    EXPECT_TRUE(stat->udp_sess_evicted == 0);
-    EXPECT_TRUE(stat->udp_pkts_bypass_table_full == RX_BURST_MAX);
-    EXPECT_TRUE(stat->udp_pkts_bypass_session_evicted == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_closed == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_evicted == 0);
+    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);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_sess_mgr_scan.cpp b/infra/session_manager/test/gtest_sess_mgr_scan.cpp
index f784349..6b9530b 100644
--- a/infra/session_manager/test/gtest_sess_mgr_scan.cpp
+++ b/infra/session_manager/test/gtest_sess_mgr_scan.cpp
@@ -13,13 +13,13 @@ static inline void packet_overwrite_src_addr(struct packet *pkt, struct in_addr
     hdr->ip_src = addr;
 }
 
-static inline void mached_session_print(const char *title, struct session_manager *mgr, uint64_t mached_sess_ids[], uint64_t mached_sess_num)
+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_lookup_session_by_id(mgr, mached_sess_ids[i]);
+        sess = session_manager_runtime_lookup_session_by_id(sess_mgr_rt, mached_sess_ids[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),
                session_type_to_str(session_get_type(sess)),
@@ -37,7 +37,7 @@ TEST(SESS_MGR_SCAN, OPTS)
     uint64_t mached_sess_ids[1460];
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
 
     struct in_addr v4_src_addr1 = {};
     struct in_addr v4_src_addr2 = {};
@@ -85,16 +85,16 @@ 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);
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != 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_lookup_session_by_packet(mgr, &pkt) == NULL);
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    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);
     EXPECT_TRUE(sess);
 
     // new session
@@ -102,8 +102,8 @@ TEST(SESS_MGR_SCAN, OPTS)
     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_lookup_session_by_packet(mgr, &pkt) == NULL);
-    sess = session_manager_new_session(mgr, &pkt, 2);
+    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);
     EXPECT_TRUE(sess);
 
     // new session
@@ -111,15 +111,15 @@ TEST(SESS_MGR_SCAN, OPTS)
     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_lookup_session_by_packet(mgr, &pkt) == NULL);
-    sess = session_manager_new_session(mgr, &pkt, 3);
+    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);
     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_lookup_session_by_packet(mgr, &pkt) == NULL);
-    sess = session_manager_new_session(mgr, &pkt, 4);
+    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(sess);
 
     struct session_scan_opts scan = {};
@@ -134,42 +134,42 @@ TEST(SESS_MGR_SCAN, OPTS)
     scan.flags = SESSION_SCAN_TYPE;
 
     scan.type = SESSION_TYPE_TCP;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_TYPE: (TCP)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_TYPE: (TCP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.type = SESSION_TYPE_UDP;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_TYPE: (UDP)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_TYPE: (UDP)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     // SESSION_SCAN_STATE
     scan.flags = SESSION_SCAN_STATE;
 
     scan.state = SESSION_STATE_OPENING;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 4);
-    mached_session_print("SESSION_SCAN_STATE: (OPENING)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (OPENING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.state = SESSION_STATE_ACTIVE;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (ACTIVE)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.state = SESSION_STATE_CLOSING;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (CLOSING)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (CLOSING)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.state = SESSION_STATE_DISCARD;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (DISCARD)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (DISCARD)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.state = SESSION_STATE_CLOSED;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_STATE: (CLOSED)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_STATE: (CLOSED)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     // SESSION_SCAN_SIP
     scan.flags = SESSION_SCAN_SIP;
@@ -177,44 +177,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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv4)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv4)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv6)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv6)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     // SESSION_SCAN_DIP
     scan.flags = SESSION_SCAN_DIP;
@@ -222,126 +222,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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DIP: (IPv4)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv4)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv4 SUBNET)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv4 MIN MAX)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_DIP: (IPv6)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv6)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv6 SUBNET)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 1);
-    mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DIP: (IPv6 MIN MAX)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     // SESSION_SCAN_SPORT
     scan.flags = SESSION_SCAN_SPORT;
 
     scan.src_port = htons(60111);
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_SPORT: (HIT)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.src_port = htons(60110);
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_SPORT: (MISS)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_SPORT: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     // SESSION_SCAN_DPORT
     scan.flags = SESSION_SCAN_DPORT;
 
     scan.dst_port = htons(80);
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 3);
-    mached_session_print("SESSION_SCAN_DPORT: (HIT)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DPORT: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.dst_port = htons(81);
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_DPORT: (MISS)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_DPORT: (MISS)", sess_mgr_rt, mached_sess_ids, 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_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 4);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.create_time_ms[0] = 1;
     scan.create_time_ms[1] = 2;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 2);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.create_time_ms[0] = 0;
     scan.create_time_ms[1] = 0;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.create_time_ms[0] = UINT64_MAX;
     scan.create_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_CREATE_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     // SESSION_SCAN_LAST_PKT_TIME
     scan.flags = SESSION_SCAN_LAST_PKT_TIME;
 
     scan.last_pkt_time_ms[0] = 0;
     scan.last_pkt_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 4);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.last_pkt_time_ms[0] = 1;
     scan.last_pkt_time_ms[1] = 2;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 2);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (HIT)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.last_pkt_time_ms[0] = 0;
     scan.last_pkt_time_ms[1] = 0;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
     scan.last_pkt_time_ms[0] = UINT64_MAX;
     scan.last_pkt_time_ms[1] = UINT64_MAX;
-    mached_sess_num = session_manager_scan(mgr, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
+    mached_sess_num = session_manager_runtime_scan(sess_mgr_rt, &scan, mached_sess_ids, sizeof(mached_sess_ids) / sizeof(mached_sess_ids[0]));
     EXPECT_TRUE(mached_sess_num == 0);
-    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", mgr, mached_sess_ids, mached_sess_num);
+    mached_session_print("SESSION_SCAN_LAST_PKT_TIME: (MISS)", sess_mgr_rt, mached_sess_ids, mached_sess_num);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #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 abbe321..88eb20f 100644
--- a/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
+++ b/infra/session_manager/test/gtest_sess_mgr_tcp_reassembly.cpp
@@ -26,10 +26,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     struct tcp_segment *seg;
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -38,9 +38,9 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     seg = session_get_tcp_segment(sess);
@@ -53,10 +53,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -68,10 +68,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -83,10 +83,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -98,10 +98,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 5) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -113,10 +113,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 6) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -128,10 +128,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 7) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
 
     /*
      * 11111111111111111111111111111111111111111111111111111111111111
@@ -198,16 +198,16 @@ TEST(SESS_MGR_TCP_REASSEMBLY, OUT_OF_ORDER)
     session_free_tcp_segment(sess, seg);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data) == NULL);             // active -> closing
-    sess = session_manager_get_expired_session(mgr, 7 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); // closing -> closed
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
@@ -217,10 +217,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     struct tcp_segment *seg;
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -229,9 +229,9 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     seg = session_get_tcp_segment(sess);
@@ -244,10 +244,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg == NULL);
@@ -259,10 +259,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
@@ -278,10 +278,10 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
 
     seg = session_get_tcp_segment(sess);
     EXPECT_TRUE(seg != NULL);
@@ -291,16 +291,16 @@ TEST(SESS_MGR_TCP_REASSEMBLY, SEQ_WRAPAROUND)
     session_free_tcp_segment(sess, seg);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data) == NULL);             // active -> closing
-    sess = session_manager_get_expired_session(mgr, 4 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data); // closing -> closed
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
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 0c4b7aa..d45eb2b 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
@@ -8,7 +8,7 @@
 #include "default_config.h"
 #include "test_packets.h"
 
-static void build_active_tcp_session(struct session_manager *mgr, struct session *sess)
+static void build_active_tcp_session(struct session_manager_runtime *sess_mgr_rt, struct session *sess)
 {
     struct packet pkt;
 
@@ -19,9 +19,9 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S DATA Packet
@@ -31,10 +31,10 @@ static void build_active_tcp_session(struct session_manager *mgr, struct session
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 }
 
 /******************************************************************************
@@ -47,14 +47,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(mgr, sess);
+    build_active_tcp_session(sess_mgr_rt, sess);
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -63,10 +63,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -75,10 +75,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -100,31 +100,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_FIN_FIN)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -138,14 +138,14 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(mgr, sess);
+    build_active_tcp_session(sess_mgr_rt, sess);
 
     // C2S RST Packet
     printf("\n=> Packet Parse: TCP C2S RST packet\n");
@@ -160,10 +160,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -185,31 +185,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_RST)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #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 *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(mgr, sess);
+    build_active_tcp_session(sess_mgr_rt, sess);
 
     // S2C RST Packet
     printf("\n=> Packet Parse: TCP S2C RST packet\n");
@@ -245,10 +245,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -270,31 +270,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -306,42 +306,42 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_RST)
 TEST(TCP_ACTIVE_TO_CLOSING, BY_DATA_TIMEOUT)
 {
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(mgr, sess);
+    build_active_tcp_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 1);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -355,14 +355,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 *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(mgr, sess);
+    build_active_tcp_session(sess_mgr_rt, sess);
 
     // C2S FIN Packet
     printf("\n=> Packet Parse: TCP C2S FIN packet\n");
@@ -371,10 +371,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -396,31 +396,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_C2S_HALF_CLOSED_TIMEOUT)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -434,14 +434,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 *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet & C2S DATA Packet
-    build_active_tcp_session(mgr, sess);
+    build_active_tcp_session(sess_mgr_rt, sess);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -450,10 +450,10 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -475,31 +475,31 @@ TEST(TCP_ACTIVE_TO_CLOSING, BY_S2C_HALF_CLOSED_TIMEOUT)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #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 a466a34..92002b5 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
@@ -18,11 +18,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +31,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -56,32 +56,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // closing -> closed
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -95,11 +95,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -108,9 +108,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -133,32 +133,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -172,11 +172,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -185,9 +185,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -197,10 +197,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -222,32 +222,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #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 *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -274,9 +274,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -286,10 +286,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -298,10 +298,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -323,32 +323,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_SYNACK_ACK)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -364,11 +364,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -377,9 +377,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S SYN Packet retransmission
@@ -394,10 +394,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -419,32 +419,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYN_RETRANSMISSION)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -460,11 +460,11 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -473,9 +473,9 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // SYNACK Packet retransmission
@@ -491,10 +491,10 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -516,32 +516,32 @@ TEST(TCP_INIT_TO_OPENING, BY_SYNACK_RETRANSMISSION)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -555,11 +555,11 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -568,9 +568,9 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S ACK Packet
@@ -580,10 +580,10 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -605,32 +605,32 @@ TEST(TCP_INIT_TO_OPENING, BY_C2S_ASMMETRIC)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -644,11 +644,11 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -657,9 +657,9 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C ACK Packet
@@ -669,10 +669,10 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -694,32 +694,32 @@ TEST(TCP_INIT_TO_OPENING, BY_S2C_ASMMETRIC)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #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 b5cbd9a..4678fd8 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
@@ -14,11 +14,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 *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -27,9 +27,9 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -58,10 +58,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -89,10 +89,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -120,10 +120,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 4) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 4) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -151,10 +151,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 5) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 5) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -182,10 +182,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 6) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 6) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -213,10 +213,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 7) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 7) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -244,10 +244,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 8) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 8) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -275,10 +275,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 9) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 9) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -306,10 +306,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 10) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 10) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -337,10 +337,10 @@ TEST(TCP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING_TO_CLOSED, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 11) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 11) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     memset(buffer, 0, sizeof(buffer));
@@ -362,31 +362,31 @@ 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
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 11 + cfg.tcp_timeout_ms.time_wait);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #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 6554ff4..a1e5fba 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
@@ -18,11 +18,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +31,9 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S DATA Packet
@@ -43,10 +43,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -68,32 +68,32 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYN_C2S_DATA)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 1);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -107,11 +107,11 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -120,9 +120,9 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C DATA Packet
@@ -132,10 +132,10 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -157,32 +157,32 @@ TEST(TCP_OPENING_TO_ACTIVE, BY_SYNACK_S2C_DATA)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 1);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #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 41c228a..06f4f16 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
@@ -18,11 +18,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -31,9 +31,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S FIN Packet
@@ -43,10 +43,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     // S2C FIN Packet
     printf("\n=> Packet Parse: TCP S2C FIN packet\n");
@@ -55,10 +55,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -80,31 +80,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_FIN_FIN)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.time_wait);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -118,11 +118,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -131,9 +131,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S RST Packet
@@ -149,10 +149,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -174,31 +174,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_RST)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #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 *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -225,9 +225,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C RST Packet
@@ -243,10 +243,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -268,31 +268,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_RST)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.unverified_rst);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -305,11 +305,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -318,38 +318,38 @@ TEST(TCP_OPENING_TO_CLOSING, BY_INIT_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL);
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -363,11 +363,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -376,9 +376,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -388,10 +388,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -413,32 +413,32 @@ TEST(TCP_OPENING_TO_CLOSING, BY_HANDSHAKE_TIMEOUT)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -452,11 +452,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -465,9 +465,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C SYNACK Packet
@@ -477,10 +477,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     // C2S ACK Packet
     printf("\n=> Packet Parse: TCP C2S ACK packet\n");
@@ -489,10 +489,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 3) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 3) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -514,32 +514,32 @@ TEST(TCP_OPENING_TO_CLOSING, BY_DATA_TIMEOUT)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 1);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_get_expired_session(mgr, 3 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -553,11 +553,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -566,9 +566,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S FIN Packet
@@ -578,10 +578,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -603,31 +603,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_C2S_HALF_FIN)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -641,11 +641,11 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -654,9 +654,9 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C FIN Packet
@@ -666,10 +666,10 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -691,31 +691,31 @@ TEST(TCP_OPENING_TO_CLOSING, BY_S2C_HALF_FIN)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 1);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 1);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->tcp_sess_used == 1);
+    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 == 1);
 
     // expire session
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.half_closed);
+    sess = session_manager_runtime_get_expired_session(sess_mgr_rt, 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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->tcp_sess_used == 0);
-    EXPECT_TRUE(stat->tcp_sess_opening == 0);
-    EXPECT_TRUE(stat->tcp_sess_active == 0);
-    EXPECT_TRUE(stat->tcp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #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 6078818..739f04d 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
@@ -14,11 +14,11 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -27,9 +27,9 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,10 +57,10 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
     tuple6_to_str(session_get_tuple6(sess), buffer, sizeof(buffer));
@@ -82,32 +82,32 @@ TEST(UDP_INIT_TO_OPENING_TO_ACTIVE_TO_CLOSING, TEST)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == 1);
-    EXPECT_TRUE(stat->udp_sess_opening == 0);
-    EXPECT_TRUE(stat->udp_sess_active == 1);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 1);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL);             // active -> closing
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == 0);
-    EXPECT_TRUE(stat->udp_sess_opening == 0);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #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 bd26842..48f6f6a 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
@@ -19,11 +19,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -32,9 +32,9 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -57,32 +57,32 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_C2S)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == 1);
-    EXPECT_TRUE(stat->udp_sess_opening == 1);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == 0);
-    EXPECT_TRUE(stat->udp_sess_opening == 0);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
@@ -97,11 +97,11 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     char buffer[1024] = {0};
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
-    struct session_manager_stat *stat = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
+    struct session_manager_stat *sess_mgr_stat = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // S2C RESP Packet
     printf("\n=> Packet Parse: UDP S2C RESP packet\n");
@@ -110,9 +110,9 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     EXPECT_TRUE(session_get_id(sess) != 0);
@@ -135,16 +135,16 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     session_print(sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == 1);
-    EXPECT_TRUE(stat->udp_sess_opening == 1);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    EXPECT_TRUE(sess_mgr_stat);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_used == 1);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_opening == 1);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_active == 0);
+    EXPECT_TRUE(sess_mgr_stat->udp_sess_closing == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
+    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(sess);
 
     EXPECT_TRUE(session_get_current_state(sess) == SESSION_STATE_CLOSED);
@@ -152,17 +152,17 @@ TEST(UDP_INIT_TO_OPENING_TO_CLOSING, BY_S2C)
     session_print(sess);
 
     // free session
-    session_manager_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
     // check stat
-    stat = session_manager_stat(mgr);
-    EXPECT_TRUE(stat);
-    EXPECT_TRUE(stat->udp_sess_used == 0);
-    EXPECT_TRUE(stat->udp_sess_opening == 0);
-    EXPECT_TRUE(stat->udp_sess_active == 0);
-    EXPECT_TRUE(stat->udp_sess_closing == 0);
-
-    session_manager_free(mgr);
+    sess_mgr_stat = session_manager_runtime_get_stat(sess_mgr_rt);
+    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);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_timeout_tcp_data.cpp b/infra/session_manager/test/gtest_timeout_tcp_data.cpp
index 0a47768..0cfcc57 100644
--- a/infra/session_manager/test/gtest_timeout_tcp_data.cpp
+++ b/infra/session_manager/test/gtest_timeout_tcp_data.cpp
@@ -12,10 +12,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,9 +24,9 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // C2S DATA Packet
@@ -36,22 +36,22 @@ TEST(TIMEOUT, TCP_TIMEOUT_DATA)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data) == NULL);
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.tcp_timeout_ms.data + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
index ae2a810..d837a8a 100644
--- a/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
+++ b/infra/session_manager/test/gtest_timeout_tcp_handshake.cpp
@@ -12,10 +12,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // S2C SYNACK Packet
     printf("\n=> Packet Parse: TCP S2C SYNACK packet\n");
@@ -24,22 +24,22 @@ TEST(TIMEOUT, TCP_TIMEOUT_HANDSHAKE)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake) == NULL);
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.handshake + cfg.tcp_timeout_ms.data);
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_timeout_tcp_init.cpp b/infra/session_manager/test/gtest_timeout_tcp_init.cpp
index 20bb5fa..b3ca04a 100644
--- a/infra/session_manager/test/gtest_timeout_tcp_init.cpp
+++ b/infra/session_manager/test/gtest_timeout_tcp_init.cpp
@@ -12,10 +12,10 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S SYN Packet
     printf("\n=> Packet Parse: TCP C2S SYN packet\n");
@@ -24,22 +24,22 @@ TEST(TIMEOUT, TCP_TIMEOUT_INIT)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.tcp_timeout_ms.init + cfg.tcp_timeout_ms.data); // closing -> closed
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
diff --git a/infra/session_manager/test/gtest_timeout_udp_data.cpp b/infra/session_manager/test/gtest_timeout_udp_data.cpp
index 6d9d69e..d5663fe 100644
--- a/infra/session_manager/test/gtest_timeout_udp_data.cpp
+++ b/infra/session_manager/test/gtest_timeout_udp_data.cpp
@@ -12,10 +12,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -24,22 +24,22 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA1)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data) == NULL);             // opening -> closing
-    sess = session_manager_get_expired_session(mgr, 1 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif
 
@@ -48,10 +48,10 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
 {
     struct packet pkt;
     struct session *sess = NULL;
-    struct session_manager *mgr = NULL;
+    struct session_manager_runtime *sess_mgr_rt = NULL;
 
-    mgr = session_manager_new(&cfg, 1);
-    EXPECT_TRUE(mgr != NULL);
+    sess_mgr_rt = session_manager_runtime_new(&sess_mgr_cfg, 1);
+    EXPECT_TRUE(sess_mgr_rt != NULL);
 
     // C2S REQ Packet
     printf("\n=> Packet Parse: UDP C2S REQ packet\n");
@@ -60,9 +60,9 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    EXPECT_TRUE(session_manager_lookup_session_by_packet(mgr, &pkt) == NULL);
+    EXPECT_TRUE(session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt) == NULL);
     // new session
-    sess = session_manager_new_session(mgr, &pkt, 1);
+    sess = session_manager_runtime_new_session(sess_mgr_rt, &pkt, 1);
     EXPECT_TRUE(sess);
 
     // S2C RESP Packet
@@ -72,22 +72,22 @@ TEST(TIMEOUT, UDP_TIMEOUT_DATA2)
     printf("<= Packet Parse: done\n\n");
 
     // lookup session
-    sess = session_manager_lookup_session_by_packet(mgr, &pkt);
+    sess = session_manager_runtime_lookup_session_by_packet(sess_mgr_rt, &pkt);
     EXPECT_TRUE(sess);
     // update session
-    EXPECT_TRUE(session_manager_update_session(mgr, sess, &pkt, 2) == 0);
+    EXPECT_TRUE(session_manager_runtime_update_session(sess_mgr_rt, sess, &pkt, 2) == 0);
 
     // expire session
-    EXPECT_TRUE(session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data) == NULL);             // active -> closing
-    sess = session_manager_get_expired_session(mgr, 2 + cfg.udp_timeout_ms.data + cfg.udp_timeout_ms.data); // closing -> closed
+    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(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_free_session(mgr, sess);
+    session_manager_runtime_free_session(sess_mgr_rt, sess);
 
-    session_manager_free(mgr);
+    session_manager_runtime_free(sess_mgr_rt);
 }
 #endif