perf: 优化session_ctx减少内存占用; 优化global metrics的结构

12 files changed, 333 insertions, 441 deletions

diff --git a/common/include/utils.h b/common/include/utils.h
index b0dfbf4..c606766 100644
--- a/common/include/utils.h
+++ b/common/include/utils.h
@@ -53,49 +53,6 @@ int mutable_array_exist_elem(struct mutable_array *array, uint64_t elem);
 int mutable_array_index_elem(struct mutable_array *array, int index);
 
 /******************************************************************************
- * sids
- ******************************************************************************/
-
-typedef uint16_t sid_t;
-#define MR_SID_LIST_MAXLEN 8
-
-struct sids
-{
-    int num;
-    sid_t elems[MR_SID_LIST_MAXLEN];
-};
-
-void sids_copy(struct sids *dst, struct sids *src);
-
-/******************************************************************************
- * route_ctx
- ******************************************************************************/
-
-struct route_ctx
-{
-    char data[64];
-    int len;
-};
-
-void route_ctx_copy(struct route_ctx *dst, struct route_ctx *src);
-
-/******************************************************************************
- * throughput_metrics
- ******************************************************************************/
-
-struct throughput_metrics
-{
-    uint64_t n_pkts;
-    uint64_t n_bytes;
-};
-
-static inline void throughput_metrics_inc(struct throughput_metrics *iterm, uint64_t n_pkts, uint64_t n_bytes)
-{
-    iterm->n_bytes += n_bytes;
-    iterm->n_pkts += n_pkts;
-}
-
-/******************************************************************************
  * device
  ******************************************************************************/
 
diff --git a/common/src/utils.cpp b/common/src/utils.cpp
index 94d644f..773b1f2 100644
--- a/common/src/utils.cpp
+++ b/common/src/utils.cpp
@@ -99,29 +99,6 @@ int mutable_array_index_elem(struct mutable_array *array, int index)
 }
 
 /******************************************************************************
- * sids
- ******************************************************************************/
-
-void sids_copy(struct sids *dst, struct sids *src)
-{
-    if (dst && src)
-    {
-        dst->num = src->num;
-        memcpy(dst->elems, src->elems, sizeof(dst->elems[0]) * dst->num);
-    }
-}
-
-/******************************************************************************
- * route_ctx
- ******************************************************************************/
-
-void route_ctx_copy(struct route_ctx *dst, struct route_ctx *src)
-{
-    memcpy(dst->data, src->data, src->len);
-    dst->len = src->len;
-}
-
-/******************************************************************************
  * device
  ******************************************************************************/
 
diff --git a/common/test/gtest_utils.cpp b/common/test/gtest_utils.cpp
index 5b85acd..9b50c62 100644
--- a/common/test/gtest_utils.cpp
+++ b/common/test/gtest_utils.cpp
@@ -36,34 +36,6 @@ TEST(UTILS, FIXED_NUM_ARRAY)
 	EXPECT_TRUE(mutable_array_count_elem(&array) == 0);
 }
 
-TEST(UTILS, SIDS)
-{
-	struct sids src;
-	struct sids dst;
-
-	for (int i = 0; i < MR_SID_LIST_MAXLEN; i++)
-	{
-		src.elems[i] = i;
-	}
-	src.num = MR_SID_LIST_MAXLEN;
-
-	sids_copy(&dst, &src);
-
-	EXPECT_TRUE(dst.num == src.num);
-	for (int i = 0; i < MR_SID_LIST_MAXLEN; i++)
-	{
-		EXPECT_TRUE(dst.elems[i] == i);
-	}
-}
-
-TEST(UTILS, THROUGHPUT_METRICS)
-{
-	struct throughput_metrics iterm = {.n_pkts = 0, .n_bytes = 0};
-	throughput_metrics_inc(&iterm, 1, 2);
-	EXPECT_TRUE(iterm.n_pkts == 1);
-	EXPECT_TRUE(iterm.n_bytes == 2);
-}
-
 TEST(UTILS, DEVICE)
 {
 	const char *dev_name = "lo";
diff --git a/platform/include/global_metrics.h b/platform/include/global_metrics.h
index 8b34261..8389473 100644
--- a/platform/include/global_metrics.h
+++ b/platform/include/global_metrics.h
@@ -9,20 +9,29 @@ extern "C"
 #include "utils.h"
 #include <MESA/field_stat2.h>
 
-struct metrics_config
+struct throughput_metrics
 {
-    char output_file[256];
-    char statsd_server[32];
-    int statsd_port;
-    int statsd_format;
-    int statsd_cycle;
-
-    int prometheus_listen_port;
-    char prometheus_listen_url[256];
+    uint64_t n_pkts;
+    uint64_t n_bytes;
 };
 
-struct device_metrics
+#define THROUGHPUT_METRICS_INC(iterm, _n_pkts, _n_bytes) \
+    do                                                   \
+    {                                                    \
+        (iterm)->n_pkts += (_n_pkts);                    \
+        (iterm)->n_bytes += (_n_bytes);                  \
+    } while (0)
+
+struct thread_metrics
 {
+    // keepalived packet metrics
+    struct throughput_metrics downlink_rx; // 累计值
+    struct throughput_metrics downlink_tx; // 累计值
+
+    struct throughput_metrics uplink_rx;      // 累计值
+    struct throughput_metrics uplink_tx_drop; // 累计值
+
+    // device packet metrics
     struct throughput_metrics nf_rx; // 累计值
     struct throughput_metrics nf_tx; // 累计值
 
@@ -33,11 +42,8 @@ struct device_metrics
     struct throughput_metrics endpoint_vlan_rx;   // 累计值
     struct throughput_metrics endpoint_vlan_tx;   // 累计值
     struct throughput_metrics endpoint_vlan_drop; // 累计值
-};
 
-// data_pkt_metrics 不包含 vxlan frame 所占的字节
-struct data_pkt_metrics
-{
+    // data packet metrics 不包含 vxlan frame / vlan header 所占的字节
     struct throughput_metrics mirr_bypass;  // 累计值
     struct throughput_metrics mirr_block;   // 累计值
     struct throughput_metrics mirr_rx_drop; // 累计值
@@ -51,61 +57,41 @@ struct data_pkt_metrics
     struct throughput_metrics miss_sess;    // 累计值
     struct throughput_metrics error_bypass; // 累计值
     struct throughput_metrics error_block;  // 累计值
-};
-
-struct ctrl_pkt_metrics
-{
-    struct throughput_metrics rx; // 累计值
-    struct throughput_metrics tx; // 累计值
-
-    uint64_t opening;  // 累计值
-    uint64_t active;   // 累计值
-    uint64_t closing;  // 累计值
-    uint64_t resetall; // 累计值
-    uint64_t error;    // 累计值
-};
 
-struct keepalived_pkt_metrics
-{
-    struct throughput_metrics downlink_rx; // 累计值
-    struct throughput_metrics downlink_tx; // 累计值
+    // control packet metrics
+    struct throughput_metrics ctrl_rx; // 累计值
+    struct throughput_metrics ctrl_tx; // 累计值
 
-    struct throughput_metrics uplink_rx;      // 累计值
-    struct throughput_metrics uplink_tx_drop; // 累计值
-};
+    uint64_t ctrl_opening;  // 累计值
+    uint64_t ctrl_active;   // 累计值
+    uint64_t ctrl_closing;  // 累计值
+    uint64_t ctrl_resetall; // 累计值
+    uint64_t ctrl_error;    // 累计值
 
-struct sf_status_metrics
-{
-    uint64_t active;   // 累计值
-    uint64_t inactive; // 累计值
-};
+    // sf status metrics
+    uint64_t sf_active;   // 累计值
+    uint64_t sf_inactive; // 累计值
 
-struct sf_session_metrics
-{
-    uint64_t num; // 当前值
-    uint64_t log; // 累计值
+    // sf session metrics
+    uint64_t session_num; // 当前值
+    uint64_t session_log; // 累计值
 };
 
-struct thread_metrics
+struct metrics_config
 {
-    struct device_metrics device;
-    struct data_pkt_metrics data_pkt;
-    struct ctrl_pkt_metrics ctrl_pkt;
-    struct keepalived_pkt_metrics kee_pkt;
+    char output_file[256];
+    char statsd_server[32];
+    int statsd_port;
+    int statsd_format;
+    int statsd_cycle;
 
-    struct sf_status_metrics sf_status;
-    struct sf_session_metrics sf_session;
+    int prometheus_listen_port;
+    char prometheus_listen_url[256];
 };
 
 struct global_metrics
 {
-    struct device_metrics device;
-    struct data_pkt_metrics data_pkt;
-    struct ctrl_pkt_metrics ctrl_pkt;
-    struct keepalived_pkt_metrics kee_pkt;
-
-    struct sf_status_metrics sf_status;
-    struct sf_session_metrics sf_session;
+    struct thread_metrics sum;
 
     struct metrics_config config;
     screen_stat_handle_t fs_handle;
diff --git a/platform/include/packet_io.h b/platform/include/packet_io.h
index 779f120..ad45bb2 100644
--- a/platform/include/packet_io.h
+++ b/platform/include/packet_io.h
@@ -12,6 +12,35 @@ extern "C"
  * Packet IO API for gtest
  ******************************************************************************/
 
+struct sids
+{
+    sid_t elems[MR_SID_LIST_MAXLEN];
+    int num;
+};
+
+struct route_ctx
+{
+    char data[64];
+    int len;
+};
+
+struct metadata
+{
+    uint64_t session_id;
+    uint32_t rehash_index;
+
+    char *raw_data; // refer to current packet data
+    int raw_len;
+    uint16_t l7offset;
+
+    int direction; // 1: E2I; 0: I2E
+    int is_ctrl_pkt;
+    int is_decrypted;
+
+    struct sids sids;
+    struct route_ctx route_ctx;
+};
+
 int mbuff_get_metadata(marsio_buff_t *rx_buff, struct metadata *meta);
 int mbuff_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta);
 void vlan_encapsulate(marsio_buff_t *mbuff, int vlan_id, int replace_orig_vlan_header);
diff --git a/platform/include/policy.h b/platform/include/policy.h
index 3907ab0..21a85c1 100644
--- a/platform/include/policy.h
+++ b/platform/include/policy.h
@@ -8,6 +8,7 @@ extern "C"
 
 #include "utils.h"
 #include "packet.h"
+#include "global_metrics.h"
 #include <linux/if_ether.h>
 
 enum traffic_type
diff --git a/platform/include/sce.h b/platform/include/sce.h
index 7d5bf9b..3d2bc8d 100644
--- a/platform/include/sce.h
+++ b/platform/include/sce.h
@@ -39,31 +39,6 @@ struct thread_ctx
     uint64_t tx_packets_ipid;
 };
 
-/******************************************************************************
- * Struct Metadata
- ******************************************************************************/
-
-struct metadata
-{
-    int write_ref;
-    uint64_t session_id;
-    uint32_t rehash_index;
-
-    char *raw_data; // refer to current packet data
-    int raw_len;
-    uint16_t l7offset;
-
-    int direction; // 1: E2I; 0: I2E
-    int is_ctrl_pkt;
-    int is_decrypted;
-
-    struct sids sids;
-    struct route_ctx route_ctx;
-};
-
-int metadata_isempty(struct metadata *meta);
-void metadata_copy(struct metadata *dst, struct metadata *src);
-
 char *memdup(const char *src, int len);
 
 /******************************************************************************
@@ -74,22 +49,32 @@ struct session_ctx
 {
     uint64_t session_id;
     char *session_addr;
+    uint32_t rehash_index;
 
     // dup from received control packet, for sending control packet
-    char *ctrl_packet_header_data;
-    uint16_t ctrl_packet_header_len;
+    char *ctrl_pkt_hdr_ptr;
+    uint16_t ctrl_pkt_hdr_len;
 
     uint16_t vxlan_src_port;
 
     struct four_tuple inner_tuple4;
     struct mutable_array rule_ids;
 
-    struct metadata decrypted_meta_i2e;
-    struct metadata decrypted_meta_e2i;
-    struct metadata raw_meta_i2e;
-    struct metadata raw_meta_e2i;
-    struct metadata ctrl_meta;
-
+    // route ctx
+    struct route_ctx decrypted_e2i_route_ctx;
+    struct route_ctx decrypted_i2e_route_ctx;
+    struct route_ctx raw_e2i_route_ctx;
+    struct route_ctx raw_i2e_route_ctx;
+    struct route_ctx ctrl_route_ctx;
+
+    // sids
+    struct sids decrypted_e2i_sids;
+    struct sids decrypted_i2e_sids;
+    struct sids raw_e2i_sids;
+    struct sids raw_i2e_sids;
+    struct sids ctrl_sids;
+
+    // chaining
     struct selected_chaining *chaining_raw;
     struct selected_chaining *chaining_decrypted;
 
diff --git a/platform/src/global_metrics.cpp b/platform/src/global_metrics.cpp
index dd9d481..d238213 100644
--- a/platform/src/global_metrics.cpp
+++ b/platform/src/global_metrics.cpp
@@ -319,172 +319,173 @@ void global_metrics_update(struct global_metrics *global_metrics, struct thread_
 
 void global_metrics_dump(struct global_metrics *global_metrics)
 {
+    struct thread_metrics *sum = &global_metrics->sum;
     for (int i = 0; i < global_metrics->thread_num; i++)
     {
         if (ATOMIC_READ(&(global_metrics->thread_metrics_flag[i])) == THREAD_METRICS_CACHE_IS_BUSY)
         {
-            struct thread_metrics *thread_metrics = &global_metrics->thread_metrics_cache[i];
-
-            global_metrics->device.nf_rx.n_pkts += thread_metrics->device.nf_rx.n_pkts;
-            global_metrics->device.nf_rx.n_bytes += thread_metrics->device.nf_rx.n_bytes;
-            global_metrics->device.nf_tx.n_pkts += thread_metrics->device.nf_tx.n_pkts;
-            global_metrics->device.nf_tx.n_bytes += thread_metrics->device.nf_tx.n_bytes;
-
-            global_metrics->device.endpoint_vxlan_rx.n_pkts += thread_metrics->device.endpoint_vxlan_rx.n_pkts;
-            global_metrics->device.endpoint_vxlan_rx.n_bytes += thread_metrics->device.endpoint_vxlan_rx.n_bytes;
-            global_metrics->device.endpoint_vxlan_tx.n_pkts += thread_metrics->device.endpoint_vxlan_tx.n_pkts;
-            global_metrics->device.endpoint_vxlan_tx.n_bytes += thread_metrics->device.endpoint_vxlan_tx.n_bytes;
-            global_metrics->device.endpoint_vxlan_drop.n_pkts += thread_metrics->device.endpoint_vxlan_drop.n_pkts;
-            global_metrics->device.endpoint_vxlan_drop.n_bytes += thread_metrics->device.endpoint_vxlan_drop.n_bytes;
-
-            global_metrics->device.endpoint_vlan_rx.n_pkts += thread_metrics->device.endpoint_vlan_rx.n_pkts;
-            global_metrics->device.endpoint_vlan_rx.n_bytes += thread_metrics->device.endpoint_vlan_rx.n_bytes;
-            global_metrics->device.endpoint_vlan_tx.n_pkts += thread_metrics->device.endpoint_vlan_tx.n_pkts;
-            global_metrics->device.endpoint_vlan_tx.n_bytes += thread_metrics->device.endpoint_vlan_tx.n_bytes;
-            global_metrics->device.endpoint_vlan_drop.n_pkts += thread_metrics->device.endpoint_vlan_drop.n_pkts;
-            global_metrics->device.endpoint_vlan_drop.n_bytes += thread_metrics->device.endpoint_vlan_drop.n_bytes;
-
-            global_metrics->data_pkt.mirr_bypass.n_pkts += thread_metrics->data_pkt.mirr_bypass.n_pkts;
-            global_metrics->data_pkt.mirr_bypass.n_bytes += thread_metrics->data_pkt.mirr_bypass.n_bytes;
-            global_metrics->data_pkt.mirr_block.n_pkts += thread_metrics->data_pkt.mirr_block.n_pkts;
-            global_metrics->data_pkt.mirr_block.n_bytes += thread_metrics->data_pkt.mirr_block.n_bytes;
-            global_metrics->data_pkt.mirr_rx_drop.n_pkts += thread_metrics->data_pkt.mirr_rx_drop.n_pkts;
-            global_metrics->data_pkt.mirr_rx_drop.n_bytes += thread_metrics->data_pkt.mirr_rx_drop.n_bytes;
-            global_metrics->data_pkt.mirr_tx.n_pkts += thread_metrics->data_pkt.mirr_tx.n_pkts;
-            global_metrics->data_pkt.mirr_tx.n_bytes += thread_metrics->data_pkt.mirr_tx.n_bytes;
-            global_metrics->data_pkt.stee_bypass.n_pkts += thread_metrics->data_pkt.stee_bypass.n_pkts;
-            global_metrics->data_pkt.stee_bypass.n_bytes += thread_metrics->data_pkt.stee_bypass.n_bytes;
-            global_metrics->data_pkt.stee_block.n_pkts += thread_metrics->data_pkt.stee_block.n_pkts;
-            global_metrics->data_pkt.stee_block.n_bytes += thread_metrics->data_pkt.stee_block.n_bytes;
-            global_metrics->data_pkt.stee_rx.n_pkts += thread_metrics->data_pkt.stee_rx.n_pkts;
-            global_metrics->data_pkt.stee_rx.n_bytes += thread_metrics->data_pkt.stee_rx.n_bytes;
-            global_metrics->data_pkt.stee_tx.n_pkts += thread_metrics->data_pkt.stee_tx.n_pkts;
-            global_metrics->data_pkt.stee_tx.n_bytes += thread_metrics->data_pkt.stee_tx.n_bytes;
-            global_metrics->data_pkt.miss_sess.n_pkts += thread_metrics->data_pkt.miss_sess.n_pkts;
-            global_metrics->data_pkt.miss_sess.n_bytes += thread_metrics->data_pkt.miss_sess.n_bytes;
-            global_metrics->data_pkt.error_bypass.n_pkts += thread_metrics->data_pkt.error_bypass.n_pkts;
-            global_metrics->data_pkt.error_bypass.n_bytes += thread_metrics->data_pkt.error_bypass.n_bytes;
-            global_metrics->data_pkt.error_block.n_pkts += thread_metrics->data_pkt.error_block.n_pkts;
-            global_metrics->data_pkt.error_block.n_bytes += thread_metrics->data_pkt.error_block.n_bytes;
-            global_metrics->ctrl_pkt.rx.n_pkts += thread_metrics->ctrl_pkt.rx.n_pkts;
-            global_metrics->ctrl_pkt.rx.n_bytes += thread_metrics->ctrl_pkt.rx.n_bytes;
-            global_metrics->ctrl_pkt.tx.n_pkts += thread_metrics->ctrl_pkt.tx.n_pkts;
-            global_metrics->ctrl_pkt.tx.n_bytes += thread_metrics->ctrl_pkt.tx.n_bytes;
-            global_metrics->ctrl_pkt.opening += thread_metrics->ctrl_pkt.opening;
-            global_metrics->ctrl_pkt.active += thread_metrics->ctrl_pkt.active;
-            global_metrics->ctrl_pkt.closing += thread_metrics->ctrl_pkt.closing;
-            global_metrics->ctrl_pkt.resetall += thread_metrics->ctrl_pkt.resetall;
-            global_metrics->ctrl_pkt.error += thread_metrics->ctrl_pkt.error;
-            global_metrics->kee_pkt.downlink_rx.n_pkts += thread_metrics->kee_pkt.downlink_rx.n_pkts;
-            global_metrics->kee_pkt.downlink_rx.n_bytes += thread_metrics->kee_pkt.downlink_rx.n_bytes;
-            global_metrics->kee_pkt.downlink_tx.n_pkts += thread_metrics->kee_pkt.downlink_tx.n_pkts;
-            global_metrics->kee_pkt.downlink_tx.n_bytes += thread_metrics->kee_pkt.downlink_tx.n_bytes;
-            global_metrics->kee_pkt.uplink_rx.n_pkts += thread_metrics->kee_pkt.uplink_rx.n_pkts;
-            global_metrics->kee_pkt.uplink_rx.n_bytes += thread_metrics->kee_pkt.uplink_rx.n_bytes;
-            global_metrics->kee_pkt.uplink_tx_drop.n_pkts += thread_metrics->kee_pkt.uplink_tx_drop.n_pkts;
-            global_metrics->kee_pkt.uplink_tx_drop.n_bytes += thread_metrics->kee_pkt.uplink_tx_drop.n_bytes;
-            global_metrics->sf_status.active += thread_metrics->sf_status.active;
-            global_metrics->sf_status.inactive += thread_metrics->sf_status.inactive;
-            global_metrics->sf_session.num += thread_metrics->sf_session.num;
-            global_metrics->sf_session.log += thread_metrics->sf_session.log;
-
-            memset(thread_metrics, 0, sizeof(struct thread_metrics));
+            struct thread_metrics *thread = &global_metrics->thread_metrics_cache[i];
+
+            sum->nf_rx.n_pkts += thread->nf_rx.n_pkts;
+            sum->nf_rx.n_bytes += thread->nf_rx.n_bytes;
+            sum->nf_tx.n_pkts += thread->nf_tx.n_pkts;
+            sum->nf_tx.n_bytes += thread->nf_tx.n_bytes;
+
+            sum->endpoint_vxlan_rx.n_pkts += thread->endpoint_vxlan_rx.n_pkts;
+            sum->endpoint_vxlan_rx.n_bytes += thread->endpoint_vxlan_rx.n_bytes;
+            sum->endpoint_vxlan_tx.n_pkts += thread->endpoint_vxlan_tx.n_pkts;
+            sum->endpoint_vxlan_tx.n_bytes += thread->endpoint_vxlan_tx.n_bytes;
+            sum->endpoint_vxlan_drop.n_pkts += thread->endpoint_vxlan_drop.n_pkts;
+            sum->endpoint_vxlan_drop.n_bytes += thread->endpoint_vxlan_drop.n_bytes;
+
+            sum->endpoint_vlan_rx.n_pkts += thread->endpoint_vlan_rx.n_pkts;
+            sum->endpoint_vlan_rx.n_bytes += thread->endpoint_vlan_rx.n_bytes;
+            sum->endpoint_vlan_tx.n_pkts += thread->endpoint_vlan_tx.n_pkts;
+            sum->endpoint_vlan_tx.n_bytes += thread->endpoint_vlan_tx.n_bytes;
+            sum->endpoint_vlan_drop.n_pkts += thread->endpoint_vlan_drop.n_pkts;
+            sum->endpoint_vlan_drop.n_bytes += thread->endpoint_vlan_drop.n_bytes;
+
+            sum->mirr_bypass.n_pkts += thread->mirr_bypass.n_pkts;
+            sum->mirr_bypass.n_bytes += thread->mirr_bypass.n_bytes;
+            sum->mirr_block.n_pkts += thread->mirr_block.n_pkts;
+            sum->mirr_block.n_bytes += thread->mirr_block.n_bytes;
+            sum->mirr_rx_drop.n_pkts += thread->mirr_rx_drop.n_pkts;
+            sum->mirr_rx_drop.n_bytes += thread->mirr_rx_drop.n_bytes;
+            sum->mirr_tx.n_pkts += thread->mirr_tx.n_pkts;
+            sum->mirr_tx.n_bytes += thread->mirr_tx.n_bytes;
+            sum->stee_bypass.n_pkts += thread->stee_bypass.n_pkts;
+            sum->stee_bypass.n_bytes += thread->stee_bypass.n_bytes;
+            sum->stee_block.n_pkts += thread->stee_block.n_pkts;
+            sum->stee_block.n_bytes += thread->stee_block.n_bytes;
+            sum->stee_rx.n_pkts += thread->stee_rx.n_pkts;
+            sum->stee_rx.n_bytes += thread->stee_rx.n_bytes;
+            sum->stee_tx.n_pkts += thread->stee_tx.n_pkts;
+            sum->stee_tx.n_bytes += thread->stee_tx.n_bytes;
+            sum->miss_sess.n_pkts += thread->miss_sess.n_pkts;
+            sum->miss_sess.n_bytes += thread->miss_sess.n_bytes;
+            sum->error_bypass.n_pkts += thread->error_bypass.n_pkts;
+            sum->error_bypass.n_bytes += thread->error_bypass.n_bytes;
+            sum->error_block.n_pkts += thread->error_block.n_pkts;
+            sum->error_block.n_bytes += thread->error_block.n_bytes;
+            sum->ctrl_rx.n_pkts += thread->ctrl_rx.n_pkts;
+            sum->ctrl_rx.n_bytes += thread->ctrl_rx.n_bytes;
+            sum->ctrl_tx.n_pkts += thread->ctrl_tx.n_pkts;
+            sum->ctrl_tx.n_bytes += thread->ctrl_tx.n_bytes;
+            sum->ctrl_opening += thread->ctrl_opening;
+            sum->ctrl_active += thread->ctrl_active;
+            sum->ctrl_closing += thread->ctrl_closing;
+            sum->ctrl_resetall += thread->ctrl_resetall;
+            sum->ctrl_error += thread->ctrl_error;
+            sum->downlink_rx.n_pkts += thread->downlink_rx.n_pkts;
+            sum->downlink_rx.n_bytes += thread->downlink_rx.n_bytes;
+            sum->downlink_tx.n_pkts += thread->downlink_tx.n_pkts;
+            sum->downlink_tx.n_bytes += thread->downlink_tx.n_bytes;
+            sum->uplink_rx.n_pkts += thread->uplink_rx.n_pkts;
+            sum->uplink_rx.n_bytes += thread->uplink_rx.n_bytes;
+            sum->uplink_tx_drop.n_pkts += thread->uplink_tx_drop.n_pkts;
+            sum->uplink_tx_drop.n_bytes += thread->uplink_tx_drop.n_bytes;
+            sum->sf_active += thread->sf_active;
+            sum->sf_inactive += thread->sf_inactive;
+            sum->session_num += thread->session_num;
+            sum->session_log += thread->session_log;
+
+            memset(thread, 0, sizeof(struct thread_metrics));
             ATOMIC_SET(&(global_metrics->thread_metrics_flag[i]), THREAD_METRICS_CACHE_IS_FREE);
         }
     }
 
     // device_metrics
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_RX_PKT], 0, FS_OP_SET, global_metrics->device.nf_rx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_RX_B], 0, FS_OP_SET, global_metrics->device.nf_rx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_RX_PKT], 0, FS_OP_SET, sum->nf_rx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_RX_B], 0, FS_OP_SET, sum->nf_rx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_PKT], 0, FS_OP_SET, global_metrics->device.nf_tx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_B], 0, FS_OP_SET, global_metrics->device.nf_tx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_PKT], 0, FS_OP_SET, sum->nf_tx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_NF_TX_B], 0, FS_OP_SET, sum->nf_tx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_rx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_rx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_PKT], 0, FS_OP_SET, sum->endpoint_vxlan_rx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_RX_B], 0, FS_OP_SET, sum->endpoint_vxlan_rx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_tx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_tx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_PKT], 0, FS_OP_SET, sum->endpoint_vxlan_tx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_TX_B], 0, FS_OP_SET, sum->endpoint_vxlan_tx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_drop.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_B], 0, FS_OP_SET, global_metrics->device.endpoint_vxlan_drop.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_PKT], 0, FS_OP_SET, sum->endpoint_vxlan_drop.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VXLAN_DROP_B], 0, FS_OP_SET, sum->endpoint_vxlan_drop.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_rx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_rx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_PKT], 0, FS_OP_SET, sum->endpoint_vlan_rx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_RX_B], 0, FS_OP_SET, sum->endpoint_vlan_rx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_tx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_B], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_tx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_PKT], 0, FS_OP_SET, sum->endpoint_vlan_tx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_TX_B], 0, FS_OP_SET, sum->endpoint_vlan_tx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_PKT], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_drop.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_B], 0, FS_OP_SET, global_metrics->device.endpoint_vlan_drop.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_PKT], 0, FS_OP_SET, sum->endpoint_vlan_drop.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DEVICE_ENDPOINT_VLAN_DROP_B], 0, FS_OP_SET, sum->endpoint_vlan_drop.n_bytes);
 
     // data_pkt_metrics
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_bypass.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_bypass.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_PKT], 0, FS_OP_SET, sum->mirr_bypass.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BYPASS_B], 0, FS_OP_SET, sum->mirr_bypass.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_block.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_block.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_PKT], 0, FS_OP_SET, sum->mirr_block.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_BLOCK_B], 0, FS_OP_SET, sum->mirr_block.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_rx_drop.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_rx_drop.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_PKT], 0, FS_OP_SET, sum->mirr_rx_drop.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_RX_DROP_B], 0, FS_OP_SET, sum->mirr_rx_drop.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_PKT], 0, FS_OP_SET, global_metrics->data_pkt.mirr_tx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_B], 0, FS_OP_SET, global_metrics->data_pkt.mirr_tx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_PKT], 0, FS_OP_SET, sum->mirr_tx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MIRR_TX_B], 0, FS_OP_SET, sum->mirr_tx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_bypass.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_bypass.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_PKT], 0, FS_OP_SET, sum->stee_bypass.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BYPASS_B], 0, FS_OP_SET, sum->stee_bypass.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_block.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_block.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_PKT], 0, FS_OP_SET, sum->stee_block.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_BLOCK_B], 0, FS_OP_SET, sum->stee_block.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_rx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_rx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_PKT], 0, FS_OP_SET, sum->stee_rx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_RX_B], 0, FS_OP_SET, sum->stee_rx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_PKT], 0, FS_OP_SET, global_metrics->data_pkt.stee_tx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_B], 0, FS_OP_SET, global_metrics->data_pkt.stee_tx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_PKT], 0, FS_OP_SET, sum->stee_tx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_STEE_TX_B], 0, FS_OP_SET, sum->stee_tx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.miss_sess.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_B], 0, FS_OP_SET, global_metrics->data_pkt.miss_sess.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_PKT], 0, FS_OP_SET, sum->miss_sess.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_MISS_SESS_B], 0, FS_OP_SET, sum->miss_sess.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_PKT], 0, FS_OP_SET, global_metrics->data_pkt.error_bypass.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_B], 0, FS_OP_SET, global_metrics->data_pkt.error_bypass.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_PKT], 0, FS_OP_SET, sum->error_bypass.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BYPASS_B], 0, FS_OP_SET, sum->error_bypass.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_PKT], 0, FS_OP_SET, global_metrics->data_pkt.error_block.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_B], 0, FS_OP_SET, global_metrics->data_pkt.error_block.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_PKT], 0, FS_OP_SET, sum->error_block.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_DATA_PKT_ERROR_BLOCK_B], 0, FS_OP_SET, sum->error_block.n_bytes);
 
     // ctrl_pkt_metrics
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RX_PKT], 0, FS_OP_SET, global_metrics->ctrl_pkt.rx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RX_B], 0, FS_OP_SET, global_metrics->ctrl_pkt.rx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RX_PKT], 0, FS_OP_SET, sum->ctrl_rx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RX_B], 0, FS_OP_SET, sum->ctrl_rx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_TX_PKT], 0, FS_OP_SET, global_metrics->ctrl_pkt.tx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_TX_B], 0, FS_OP_SET, global_metrics->ctrl_pkt.tx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_TX_PKT], 0, FS_OP_SET, sum->ctrl_tx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_TX_B], 0, FS_OP_SET, sum->ctrl_tx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_OPENING], 0, FS_OP_SET, global_metrics->ctrl_pkt.opening);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_ACTIVE], 0, FS_OP_SET, global_metrics->ctrl_pkt.active);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_CLOSING], 0, FS_OP_SET, global_metrics->ctrl_pkt.closing);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RESETALL], 0, FS_OP_SET, global_metrics->ctrl_pkt.resetall);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_ERROR], 0, FS_OP_SET, global_metrics->ctrl_pkt.error);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_OPENING], 0, FS_OP_SET, sum->ctrl_opening);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_ACTIVE], 0, FS_OP_SET, sum->ctrl_active);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_CLOSING], 0, FS_OP_SET, sum->ctrl_closing);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_RESETALL], 0, FS_OP_SET, sum->ctrl_resetall);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_CTRL_PKT_ERROR], 0, FS_OP_SET, sum->ctrl_error);
 
     // keepalived_pkt_metrics
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_RX_PKT], 0, FS_OP_SET, global_metrics->kee_pkt.downlink_rx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_RX_B], 0, FS_OP_SET, global_metrics->kee_pkt.downlink_rx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_RX_PKT], 0, FS_OP_SET, sum->downlink_rx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_RX_B], 0, FS_OP_SET, sum->downlink_rx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_TX_PKT], 0, FS_OP_SET, global_metrics->kee_pkt.downlink_tx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_TX_B], 0, FS_OP_SET, global_metrics->kee_pkt.downlink_tx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_TX_PKT], 0, FS_OP_SET, sum->downlink_tx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_DOWN_TX_B], 0, FS_OP_SET, sum->downlink_tx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_RX_PKT], 0, FS_OP_SET, global_metrics->kee_pkt.uplink_rx.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_RX_B], 0, FS_OP_SET, global_metrics->kee_pkt.uplink_rx.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_RX_PKT], 0, FS_OP_SET, sum->uplink_rx.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_RX_B], 0, FS_OP_SET, sum->uplink_rx.n_bytes);
 
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_TX_DROP_PKT], 0, FS_OP_SET, global_metrics->kee_pkt.uplink_tx_drop.n_pkts);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_TX_DROP_B], 0, FS_OP_SET, global_metrics->kee_pkt.uplink_tx_drop.n_bytes);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_TX_DROP_PKT], 0, FS_OP_SET, sum->uplink_tx_drop.n_pkts);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_KEE_PKT_UP_TX_DROP_B], 0, FS_OP_SET, sum->uplink_tx_drop.n_bytes);
 
     // sf_status_metrics
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_STATUS_ACTIVE], 0, FS_OP_SET, global_metrics->sf_status.active);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_STATUS_INACTIVE], 0, FS_OP_SET, global_metrics->sf_status.inactive);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_STATUS_ACTIVE], 0, FS_OP_SET, sum->sf_active);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_STATUS_INACTIVE], 0, FS_OP_SET, sum->sf_inactive);
 
     // sf_session_metrics
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_SESSION_NUM], 0, FS_OP_SET, global_metrics->sf_session.num);
-    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_SESSION_LOG], 0, FS_OP_SET, global_metrics->sf_session.log);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_SESSION_NUM], 0, FS_OP_SET, sum->session_num);
+    FS_operate(global_metrics->fs_handle, global_metrics->fs_id[STAT_SF_SESSION_LOG], 0, FS_OP_SET, sum->session_log);
 
     FS_passive_output(global_metrics->fs_handle);
 }
diff --git a/platform/src/packet_io.cpp b/platform/src/packet_io.cpp
index fef959a..b7a1fb7 100644
--- a/platform/src/packet_io.cpp
+++ b/platform/src/packet_io.cpp
@@ -67,6 +67,30 @@ struct packet_io
  * metadata
  ******************************************************************************/
 
+static inline void sids_copy(struct sids *dst, struct sids *src)
+{
+    if (dst && src)
+    {
+        dst->num = src->num;
+        memcpy(dst->elems, src->elems, sizeof(dst->elems[0]) * dst->num);
+    }
+}
+
+static inline void route_ctx_copy(struct route_ctx *dst, struct route_ctx *src)
+{
+    memcpy(dst->data, src->data, src->len);
+    dst->len = src->len;
+}
+
+static inline void route_ctx_copy_once(struct route_ctx *dst, struct route_ctx *src)
+{
+    if (dst->len == 0)
+    {
+        memcpy(dst->data, src->data, src->len);
+        dst->len = src->len;
+    }
+}
+
 void sce_packet_get_innermost_tuple(const struct packet *handler, struct four_tuple *tuple)
 {
     memset(tuple, 0, sizeof(struct four_tuple));
@@ -205,47 +229,39 @@ int mbuff_set_metadata(marsio_buff_t *tx_buff, struct metadata *meta)
 
 static void update_session_by_metadata(struct session_ctx *ctx, struct metadata *meta)
 {
-    struct metadata *dst_meta_i2e = NULL;
-    struct metadata *dst_meta_e2i = NULL;
+    struct sids *e2i_sids = NULL;
+    struct sids *i2e_sids = NULL;
+    struct route_ctx *e2i_route_ctx = NULL;
+    struct route_ctx *i2e_route_ctx = NULL;
 
     if (meta->is_decrypted)
     {
-        dst_meta_i2e = &ctx->decrypted_meta_i2e;
-        dst_meta_e2i = &ctx->decrypted_meta_e2i;
+        e2i_sids = &ctx->decrypted_e2i_sids;
+        i2e_sids = &ctx->decrypted_i2e_sids;
+
+        e2i_route_ctx = &ctx->decrypted_e2i_route_ctx;
+        i2e_route_ctx = &ctx->decrypted_i2e_route_ctx;
     }
     else
     {
-        dst_meta_i2e = &ctx->raw_meta_i2e;
-        dst_meta_e2i = &ctx->raw_meta_e2i;
+        e2i_sids = &ctx->raw_e2i_sids;
+        i2e_sids = &ctx->raw_i2e_sids;
+
+        e2i_route_ctx = &ctx->raw_e2i_route_ctx;
+        i2e_route_ctx = &ctx->raw_i2e_route_ctx;
     }
 
     // 1: E2I
     // 0: I2E
     if (meta->direction)
     {
-        // first packet update metadata
-        if (metadata_isempty(dst_meta_e2i))
-        {
-            metadata_copy(dst_meta_e2i, meta);
-        }
-        else
-        {
-            // next packet only update sids
-            sids_copy(&dst_meta_e2i->sids, &meta->sids);
-        }
+        route_ctx_copy_once(e2i_route_ctx, &meta->route_ctx);
+        sids_copy(e2i_sids, &meta->sids);
     }
     else
     {
-        // first packet update metadata
-        if (metadata_isempty(dst_meta_i2e))
-        {
-            metadata_copy(dst_meta_i2e, meta);
-        }
-        else
-        {
-            // next packet only update sids
-            sids_copy(&dst_meta_i2e->sids, &meta->sids);
-        }
+        route_ctx_copy_once(i2e_route_ctx, &meta->route_ctx);
+        sids_copy(i2e_sids, &meta->sids);
     }
 }
 
@@ -262,26 +278,26 @@ static void update_metadata_by_session(struct session_ctx *ctx, struct metadata
     {
         if (meta->is_decrypted)
         {
-            sids = &(ctx->decrypted_meta_e2i.sids);
-            route_ctx = &(ctx->decrypted_meta_e2i.route_ctx);
+            sids = &(ctx->decrypted_e2i_sids);
+            route_ctx = &(ctx->decrypted_e2i_route_ctx);
         }
         else
         {
-            sids = &(ctx->raw_meta_e2i.sids);
-            route_ctx = &(ctx->raw_meta_e2i.route_ctx);
+            sids = &(ctx->raw_e2i_sids);
+            route_ctx = &(ctx->raw_e2i_route_ctx);
         }
     }
     else
     {
         if (meta->is_decrypted)
         {
-            sids = &(ctx->decrypted_meta_i2e.sids);
-            route_ctx = &(ctx->decrypted_meta_i2e.route_ctx);
+            sids = &(ctx->decrypted_i2e_sids);
+            route_ctx = &(ctx->decrypted_i2e_route_ctx);
         }
         else
         {
-            sids = &(ctx->raw_meta_i2e.sids);
-            route_ctx = &(ctx->raw_meta_i2e.route_ctx);
+            sids = &(ctx->raw_i2e_sids);
+            route_ctx = &(ctx->raw_i2e_route_ctx);
         }
     }
 
@@ -295,7 +311,7 @@ static void update_metadata_by_session(struct session_ctx *ctx, struct metadata
 
 // return 0 : not keepalive packet
 // return 1 : is  keepalive packet
-static int is_downlink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
+static inline int is_downlink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
 {
     char *raw_data = marsio_buff_mtod(rx_buff);
     if (raw_data == NULL || raw_len < (int)(sizeof(struct ethhdr)))
@@ -316,7 +332,7 @@ static int is_downlink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
 
 // return 0 : not keepalive packet
 // return 1 : is  keepalive packet
-static int is_uplink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
+static inline int is_uplink_keepalive_packet(marsio_buff_t *rx_buff, int raw_len)
 {
     char *raw_data = marsio_buff_mtod(rx_buff);
     if (raw_data == NULL || raw_len < (int)(sizeof(struct ethhdr) + sizeof(struct ip) + sizeof(struct udphdr)))
@@ -495,7 +511,7 @@ static inline int send_packet_to_sf(struct session_ctx *session_ctx, marsio_buff
     char *buffer = NULL;
     struct packet_io *packet_io = thread_ctx->ref_io;
     struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
-    uint32_t rehash_index = session_ctx->ctrl_meta.rehash_index;
+    uint32_t rehash_index = session_ctx->rehash_index;
 
     marsio_buff_ctrlzone_reset(mbuff);
     switch (sf->sf_connectivity.method)
@@ -511,7 +527,7 @@ static inline int send_packet_to_sf(struct session_ctx *session_ctx, marsio_buff
         nsend = marsio_buff_datalen(mbuff);
         marsio_buff_set_metadata(mbuff, MR_BUFF_REHASH_INDEX, &rehash_index, sizeof(rehash_index));
         marsio_send_burst(packet_io->dev_endpoint_l3.mr_path, thread_ctx->thread_index, &mbuff, 1);
-        throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_tx), 1, nsend);
+        THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_tx), 1, nsend);
         break;
     case ENCAPSULATE_METHOD_LAYER2_SWITCH:
         vlan_encapsulate(mbuff,
@@ -520,7 +536,7 @@ static inline int send_packet_to_sf(struct session_ctx *session_ctx, marsio_buff
         nsend = marsio_buff_datalen(mbuff);
         marsio_buff_set_metadata(mbuff, MR_BUFF_REHASH_INDEX, &rehash_index, sizeof(rehash_index));
         marsio_send_burst(packet_io->dev_endpoint_l2.mr_path, thread_ctx->thread_index, &mbuff, 1);
-        throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_tx), 1, nsend);
+        THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_tx), 1, nsend);
         break;
     case ENCAPSULATE_METHOD_LAYER3_SWITCH:
         // TODO
@@ -541,7 +557,7 @@ static inline void action_err_bypass(marsio_buff_t *rx_buff, struct metadata *me
     int nsend = action_nf_inject(rx_buff, meta, sf, thread_ctx);
     if (nsend > 0)
     {
-        throughput_metrics_inc(&(thread_metrics->data_pkt.error_bypass), 1, nsend);
+        THROUGHPUT_METRICS_INC(&(thread_metrics->error_bypass), 1, nsend);
     }
 }
 
@@ -551,7 +567,7 @@ static inline void action_err_block(marsio_buff_t *rx_buff, struct metadata *met
     struct packet_io *packet_io = thread_ctx->ref_io;
     int thread_index = thread_ctx->thread_index;
 
-    throughput_metrics_inc(&(thread_metrics->data_pkt.error_block), 1, meta->raw_len);
+    THROUGHPUT_METRICS_INC(&(thread_metrics->error_block), 1, meta->raw_len);
     marsio_buff_free(packet_io->instance, &rx_buff, 1, 0, thread_index);
 }
 
@@ -570,7 +586,7 @@ static inline int action_nf_inject(marsio_buff_t *rx_buff, struct metadata *meta
     }
 
     marsio_send_burst(packet_io->dev_nf.mr_path, thread_index, &rx_buff, 1);
-    throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, meta->raw_len);
+    THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, meta->raw_len);
     return meta->raw_len;
 }
 
@@ -578,14 +594,14 @@ static inline void action_mirr_bypass(marsio_buff_t *rx_buff, struct metadata *m
 {
     struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
 
-    throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_bypass), 1, meta->raw_len);
+    THROUGHPUT_METRICS_INC(&(thread_metrics->mirr_bypass), 1, meta->raw_len);
 }
 
 static inline void action_mirr_block(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
 {
     struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
 
-    throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_block), 1, meta->raw_len);
+    THROUGHPUT_METRICS_INC(&(thread_metrics->mirr_block), 1, meta->raw_len);
 }
 
 static inline void action_mirr_forward(struct session_ctx *session_ctx, marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -607,8 +623,8 @@ static inline void action_mirr_forward(struct session_ctx *session_ctx, marsio_b
     memcpy(copy_ptr, raw_data, meta->raw_len);
 
     int nsend = send_packet_to_sf(session_ctx, new_buff, meta, sf, thread_ctx);
-    throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_tx), 1, meta->raw_len);
-    throughput_metrics_inc(&sf->tx, 1, nsend);
+    THROUGHPUT_METRICS_INC(&(thread_metrics->mirr_tx), 1, meta->raw_len);
+    THROUGHPUT_METRICS_INC(&sf->tx, 1, nsend);
     struct sf_metrics_key key = {0};
     key.rule_id = sf->rule_id;
     key.sff_profile_id = sf->sff_profile_id;
@@ -621,7 +637,7 @@ static inline void action_stee_bypass(marsio_buff_t *rx_buff, struct metadata *m
 {
     struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
 
-    throughput_metrics_inc(&(thread_metrics->data_pkt.stee_bypass), 1, meta->raw_len);
+    THROUGHPUT_METRICS_INC(&(thread_metrics->stee_bypass), 1, meta->raw_len);
 }
 
 static inline void action_stee_block(marsio_buff_t *rx_buff, struct metadata *meta, struct selected_sf *sf, struct thread_ctx *thread_ctx)
@@ -630,7 +646,7 @@ static inline void action_stee_block(marsio_buff_t *rx_buff, struct metadata *me
     struct packet_io *packet_io = thread_ctx->ref_io;
     int thread_index = thread_ctx->thread_index;
 
-    throughput_metrics_inc(&(thread_metrics->data_pkt.stee_block), 1, meta->raw_len);
+    THROUGHPUT_METRICS_INC(&(thread_metrics->stee_block), 1, meta->raw_len);
     marsio_buff_free(packet_io->instance, &rx_buff, 1, 0, thread_index);
 }
 
@@ -639,8 +655,8 @@ static inline void action_stee_forward(struct session_ctx *session_ctx, marsio_b
     struct thread_metrics *thread_metrics = &thread_ctx->thread_metrics;
 
     int nsend = send_packet_to_sf(session_ctx, rx_buff, meta, sf, thread_ctx);
-    throughput_metrics_inc(&(thread_metrics->data_pkt.stee_tx), 1, meta->raw_len);
-    throughput_metrics_inc(&sf->tx, 1, nsend);
+    THROUGHPUT_METRICS_INC(&(thread_metrics->stee_tx), 1, meta->raw_len);
+    THROUGHPUT_METRICS_INC(&sf->tx, 1, nsend);
     struct sf_metrics_key key = {0};
     key.rule_id = sf->rule_id;
     key.sff_profile_id = sf->sff_profile_id;
@@ -839,8 +855,8 @@ static int send_ctrl_packet(struct session_ctx *session_ctx, struct thread_ctx *
     LOG_INFO("%s: session %lu %s send event log %ld bytes", LOG_TAG_SFMETRICS, session_ctx->session_id, session_ctx->session_addr, size);
 
     marsio_buff_t *tx_buffs[1];
-    const char *packet_header_data = session_ctx->ctrl_packet_header_data;
-    int packet_header_len = session_ctx->ctrl_packet_header_len;
+    const char *packet_header_data = session_ctx->ctrl_pkt_hdr_ptr;
+    int packet_header_len = session_ctx->ctrl_pkt_hdr_len;
     marsio_buff_malloc_global(packet_io->instance, tx_buffs, 1, 0, thread_index);
     char *dst = marsio_buff_append(tx_buffs[0], packet_header_len + size);
     memcpy(dst, packet_header_data, packet_header_len);
@@ -852,7 +868,7 @@ static int send_ctrl_packet(struct session_ctx *session_ctx, struct thread_ctx *
     meta.is_ctrl_pkt = 1;
     meta.sids.num = 1;
     meta.sids.elems[0] = sce_ctx->firewall_sids;
-    route_ctx_copy(&meta.route_ctx, &(session_ctx->ctrl_meta.route_ctx));
+    route_ctx_copy(&meta.route_ctx, &(session_ctx->ctrl_route_ctx));
     mbuff_set_metadata(tx_buffs[0], &meta);
     int nsend = marsio_buff_datalen(tx_buffs[0]);
     marsio_send_burst(packet_io->dev_nf.mr_path, thread_index, tx_buffs, 1);
@@ -872,9 +888,9 @@ static void send_event_log(struct session_ctx *session_ctx, struct thread_ctx *t
         nsend = send_ctrl_packet(session_ctx, thread_ctx);
         if (nsend > 0)
         {
-            ATOMIC_INC(&(thread_metrics->sf_session.log));
-            throughput_metrics_inc(&(thread_metrics->ctrl_pkt.tx), 1, nsend);
-            throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, nsend);
+            ATOMIC_INC(&(thread_metrics->session_log));
+            THROUGHPUT_METRICS_INC(&(thread_metrics->ctrl_tx), 1, nsend);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, nsend);
         }
     }
 }
@@ -945,7 +961,7 @@ static void handle_session_closing(struct metadata *meta, struct control_packet
         dump_sf_metrics(s_ctx, s_ctx->chaining_decrypted);
 
         session_table_delete_by_id(session_table, meta->session_id);
-        ATOMIC_DEC(&(thread_metrics->sf_session.num));
+        ATOMIC_DEC(&(thread_metrics->session_num));
     }
 }
 
@@ -991,11 +1007,12 @@ static void handle_session_active(struct metadata *meta, struct control_packet *
         struct session_ctx *session_ctx = session_ctx_new();
         session_ctx->session_id = meta->session_id;
         session_ctx->session_addr = sce_ctx->enable_debug ? four_tuple_tostring(&inner_tuple4) : NULL;
+        session_ctx->rehash_index = meta->rehash_index;
         session_ctx->vxlan_src_port = calculate_vxlan_source_port(&inner_tuple4);
         four_tuple_copy(&session_ctx->inner_tuple4, &inner_tuple4);
-        metadata_copy(&session_ctx->ctrl_meta, meta);
-        session_ctx->ctrl_packet_header_data = memdup(meta->raw_data, meta->raw_len);
-        session_ctx->ctrl_packet_header_len = meta->raw_len;
+        route_ctx_copy(&session_ctx->ctrl_route_ctx, &meta->route_ctx);
+        session_ctx->ctrl_pkt_hdr_ptr = memdup(meta->raw_data, meta->raw_len);
+        session_ctx->ctrl_pkt_hdr_len = meta->raw_len;
         session_ctx->chaining_raw = selected_chaining_create(chaining_size, session_ctx->session_id, session_ctx->session_addr);
         session_ctx->chaining_decrypted = selected_chaining_create(chaining_size, session_ctx->session_id, session_ctx->session_addr);
         session_ctx->ref_thread_ctx = thread_ctx;
@@ -1005,7 +1022,7 @@ static void handle_session_active(struct metadata *meta, struct control_packet *
         send_event_log(session_ctx, thread_ctx);
 
         session_table_insert(session_table, session_ctx->session_id, &session_ctx->inner_tuple4, session_ctx, session_value_free_cb);
-        ATOMIC_INC(&(thread_metrics->sf_session.num));
+        ATOMIC_INC(&(thread_metrics->session_num));
     }
 }
 
@@ -1015,7 +1032,7 @@ static void handle_session_resetall(struct metadata *meta, struct control_packet
     struct sce_ctx *sce_ctx = thread_ctx->ref_sce_ctx;
 
     LOG_ERROR("%s: session %lu resetall: notification clears all session tables !!!", LOG_TAG_PKTIO, meta->session_id);
-    ATOMIC_ZERO(&(global_metrics->sf_session.num));
+    ATOMIC_ZERO(&(global_metrics->sum.session_num));
     for (int i = 0; i < sce_ctx->nr_worker_threads; i++)
     {
         struct thread_ctx *temp_ctx = &sce_ctx->work_threads[i];
@@ -1058,20 +1075,20 @@ static void handle_control_packet(marsio_buff_t *rx_buff, struct thread_ctx *thr
     switch (ctrl_pkt.state)
     {
     case SESSION_STATE_OPENING:
-        ATOMIC_INC(&(thread_metrics->ctrl_pkt.opening));
+        ATOMIC_INC(&(thread_metrics->ctrl_opening));
         // when session opening, firewall not send policy id
         // return handle_session_opening(&meta, &ctrl_pkt, ctx);
         break;
     case SESSION_STATE_CLOSING:
-        ATOMIC_INC(&(thread_metrics->ctrl_pkt.closing));
+        ATOMIC_INC(&(thread_metrics->ctrl_closing));
         handle_session_closing(&meta, &ctrl_pkt, thread_ctx);
         break;
     case SESSION_STATE_ACTIVE:
-        ATOMIC_INC(&(thread_metrics->ctrl_pkt.active));
+        ATOMIC_INC(&(thread_metrics->ctrl_active));
         handle_session_active(&meta, &ctrl_pkt, thread_ctx);
         break;
     case SESSION_STATE_RESETALL:
-        ATOMIC_INC(&(thread_metrics->ctrl_pkt.resetall));
+        ATOMIC_INC(&(thread_metrics->ctrl_resetall));
         handle_session_resetall(&meta, &ctrl_pkt, thread_ctx);
         break;
     default:
@@ -1080,7 +1097,7 @@ static void handle_control_packet(marsio_buff_t *rx_buff, struct thread_ctx *thr
     return;
 
 error_ctrl_pkt:
-    ATOMIC_INC(&(thread_metrics->ctrl_pkt.error));
+    ATOMIC_INC(&(thread_metrics->ctrl_error));
     return;
 }
 
@@ -1122,7 +1139,7 @@ static void handle_data_packet(marsio_buff_t *rx_buff, struct thread_ctx *thread
     session_ctx = data_packet_search_session(session_table, meta.raw_data, meta.raw_len, meta.session_id);
     if (session_ctx == NULL)
     {
-        throughput_metrics_inc(&(thread_metrics->data_pkt.miss_sess), 1, meta.raw_len);
+        THROUGHPUT_METRICS_INC(&(thread_metrics->miss_sess), 1, meta.raw_len);
         goto error_bypass;
     }
 
@@ -1164,7 +1181,7 @@ static void handle_inject_vxlan_packet(marsio_buff_t *rx_buff, struct thread_ctx
     char *raw_data = marsio_buff_mtod(rx_buff);
     if (vxlan_frame_decode(&vxlan_hdr, raw_data, raw_len) == -1)
     {
-        throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_drop), 1, raw_len);
+        THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_drop), 1, raw_len);
         meta.raw_len = raw_len;
         action_err_block(rx_buff, &meta, NULL, thread_ctx);
         return;
@@ -1206,14 +1223,14 @@ static void handle_inject_vxlan_packet(marsio_buff_t *rx_buff, struct thread_ctx
     {
         LOG_DEBUG("%s: unexpected inject packet, session %lu %s with sf_profile_id %d executes mirror and does not require reflow, drop !!!",
                   LOG_TAG_PKTIO, session_ctx->session_id, session_ctx->session_addr, chaining->chaining[sf_index].sf_profile_id);
-        throughput_metrics_inc(&(thread_metrics->data_pkt.mirr_rx_drop), 1, meta.raw_len);
+        THROUGHPUT_METRICS_INC(&(thread_metrics->mirr_rx_drop), 1, meta.raw_len);
         goto error_block;
     }
     else
     {
         struct selected_sf *sf = &(chaining->chaining[sf_index]);
-        throughput_metrics_inc(&sf->rx, 1, raw_len);
-        throughput_metrics_inc(&(thread_metrics->data_pkt.stee_rx), 1, meta.raw_len);
+        THROUGHPUT_METRICS_INC(&sf->rx, 1, raw_len);
+        THROUGHPUT_METRICS_INC(&(thread_metrics->stee_rx), 1, meta.raw_len);
         struct sf_metrics_key key = {0};
         key.rule_id = sf->rule_id;
         key.sff_profile_id = sf->sff_profile_id;
@@ -1227,7 +1244,7 @@ static void handle_inject_vxlan_packet(marsio_buff_t *rx_buff, struct thread_ctx
     return;
 
 error_block:
-    throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_drop), 1, raw_len);
+    THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_drop), 1, raw_len);
     marsio_buff_adj(rx_buff, raw_len - meta.raw_len);
     action_err_block(rx_buff, &meta, NULL, thread_ctx);
 }
@@ -1496,8 +1513,8 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
         {
             int raw_len = marsio_buff_datalen(rx_buffs[j]);
 
-            throughput_metrics_inc(&(thread_metrics->device.nf_rx), 1, raw_len);
-            throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->nf_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, raw_len);
         }
 
         marsio_send_burst(handle->dev_nf.mr_path, thread_index, rx_buffs, nr_recv);
@@ -1511,28 +1528,28 @@ int packet_io_thread_polling_nf(struct packet_io *handle, struct thread_ctx *thr
 
         if (is_downlink_keepalive_packet(rx_buff, raw_len))
         {
-            throughput_metrics_inc(&(thread_metrics->device.nf_rx), 1, raw_len);
-            throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->nf_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, raw_len);
 
-            throughput_metrics_inc(&(thread_metrics->kee_pkt.downlink_rx), 1, raw_len);
-            throughput_metrics_inc(&(thread_metrics->kee_pkt.downlink_tx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->downlink_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->downlink_tx), 1, raw_len);
 
             marsio_send_burst(handle->dev_nf.mr_path, thread_index, &rx_buff, 1);
         }
         else if (marsio_buff_is_ctrlbuf(rx_buff))
         {
-            throughput_metrics_inc(&(thread_metrics->device.nf_rx), 1, raw_len);
-            throughput_metrics_inc(&(thread_metrics->device.nf_tx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->nf_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->nf_tx), 1, raw_len);
 
-            throughput_metrics_inc(&(thread_metrics->ctrl_pkt.rx), 1, raw_len);
-            throughput_metrics_inc(&(thread_metrics->ctrl_pkt.tx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->ctrl_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->ctrl_tx), 1, raw_len);
 
             handle_control_packet(rx_buff, thread_ctx, raw_len);
             marsio_send_burst(handle->dev_nf.mr_path, thread_index, &rx_buff, 1);
         }
         else
         {
-            throughput_metrics_inc(&(thread_metrics->device.nf_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->nf_rx), 1, raw_len);
 
             handle_data_packet(rx_buff, thread_ctx, raw_len);
         }
@@ -1559,8 +1576,8 @@ int packet_io_thread_polling_endpoint_l3(struct packet_io *handle, struct thread
         {
             int raw_len = marsio_buff_datalen(rx_buffs[j]);
 
-            throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
-            throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_tx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_tx), 1, raw_len);
         }
 
         marsio_send_burst(handle->dev_endpoint_l3.mr_path, thread_index, rx_buffs, nr_recv);
@@ -1574,15 +1591,15 @@ int packet_io_thread_polling_endpoint_l3(struct packet_io *handle, struct thread
 
         if (is_uplink_keepalive_packet(rx_buff, raw_len))
         {
-            throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
-            throughput_metrics_inc(&(thread_metrics->kee_pkt.uplink_rx), 1, raw_len);
-            throughput_metrics_inc(&(thread_metrics->kee_pkt.uplink_tx_drop), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->uplink_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->uplink_tx_drop), 1, raw_len);
 
             marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_index);
         }
         else
         {
-            throughput_metrics_inc(&(thread_metrics->device.endpoint_vxlan_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vxlan_rx), 1, raw_len);
 
             handle_inject_vxlan_packet(rx_buff, thread_ctx, raw_len);
         }
@@ -1609,8 +1626,8 @@ int packet_io_thread_polling_endpoint_l2(struct packet_io *handle, struct thread
         {
             int raw_len = marsio_buff_datalen(rx_buffs[j]);
 
-            throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_rx), 1, raw_len);
-            throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_tx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_rx), 1, raw_len);
+            THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_tx), 1, raw_len);
         }
 
         marsio_send_burst(handle->dev_endpoint_l2.mr_path, thread_index, rx_buffs, nr_recv);
@@ -1622,8 +1639,8 @@ int packet_io_thread_polling_endpoint_l2(struct packet_io *handle, struct thread
         marsio_buff_t *rx_buff = rx_buffs[j];
         int raw_len = marsio_buff_datalen(rx_buffs[j]);
 
-        throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_rx), 1, raw_len);
-        throughput_metrics_inc(&(thread_metrics->device.endpoint_vlan_drop), 1, raw_len);
+        THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_rx), 1, raw_len);
+        THROUGHPUT_METRICS_INC(&(thread_metrics->endpoint_vlan_drop), 1, raw_len);
 
         marsio_buff_free(handle->instance, &rx_buff, 1, 0, thread_index);
     }
diff --git a/platform/src/policy.cpp b/platform/src/policy.cpp
index 4fbe4ce..018c15a 100644
--- a/platform/src/policy.cpp
+++ b/platform/src/policy.cpp
@@ -1194,7 +1194,7 @@ static void select_sf_by_ldbc(struct sff_param *sff_param, struct selected_sf *s
         memset(selected_sf->sf_dst_mac, 0, sizeof(selected_sf->sf_dst_mac));
         if (health_check_session_get_mac(sf_param->health_check_session_id, selected_sf->sf_dst_mac) == 0)
         {
-            ATOMIC_INC(&(thread_metrics->sf_status.active));
+            ATOMIC_INC(&(thread_metrics->sf_active));
             LOG_INFO("%s: session %lu %s select sf by ldbc, sf_profile_id %d to be selected", LOG_TAG_POLICY, s_ctx->session_id, s_ctx->session_addr, sf_param->sf_profile_id);
             selected_sf_set_action(selected_sf, ACTION_FORWAED_DUE_SELECTED_SF);
             selected_sf_set_info(selected_sf, sf_param);
@@ -1202,7 +1202,7 @@ static void select_sf_by_ldbc(struct sff_param *sff_param, struct selected_sf *s
         }
         else
         {
-            ATOMIC_INC(&(thread_metrics->sf_status.inactive));
+            ATOMIC_INC(&(thread_metrics->sf_inactive));
             if (handle_fail_action(&sff_param->sff_exception, selected_sf, utarray_len(sf_array) - 1) == 0)
             {
                 LOG_INFO("%s: session %lu %s select sf by re-dispatch, sf_profile_id %d to be excluded", LOG_TAG_POLICY, s_ctx->session_id, s_ctx->session_addr, sf_param->sf_profile_id);
diff --git a/platform/src/sce.cpp b/platform/src/sce.cpp
index 26f7f92..dcd92a3 100644
--- a/platform/src/sce.cpp
+++ b/platform/src/sce.cpp
@@ -5,38 +5,6 @@
 #include "log.h"
 #include "global_metrics.h"
 
-/******************************************************************************
- * Struct Metadata
- ******************************************************************************/
-
-int metadata_isempty(struct metadata *meta)
-{
-    if (meta->write_ref == 0)
-    {
-        return 1;
-    }
-    else
-    {
-        return 0;
-    }
-}
-
-void metadata_copy(struct metadata *dst, struct metadata *src)
-{
-    dst->write_ref++;
-    dst->session_id = src->session_id;
-    dst->rehash_index = src->rehash_index;
-    dst->raw_data = NULL;
-    dst->raw_len = 0;
-    dst->l7offset = src->l7offset;
-    dst->direction = src->direction;
-    dst->is_ctrl_pkt = src->is_ctrl_pkt;
-    dst->is_decrypted = src->is_decrypted;
-
-    sids_copy(&dst->sids, &src->sids);
-    route_ctx_copy(&dst->route_ctx, &src->route_ctx);
-}
-
 char *memdup(const char *src, int len)
 {
     if (src == NULL || len == 0)
@@ -72,10 +40,10 @@ void session_ctx_free(struct session_ctx *session_ctx)
             session_ctx->session_addr = NULL;
         }
 
-        if (session_ctx->ctrl_packet_header_data)
+        if (session_ctx->ctrl_pkt_hdr_ptr)
         {
-            free(session_ctx->ctrl_packet_header_data);
-            session_ctx->ctrl_packet_header_data = NULL;
+            free(session_ctx->ctrl_pkt_hdr_ptr);
+            session_ctx->ctrl_pkt_hdr_ptr = NULL;
         }
 
         if (session_ctx->chaining_raw)
diff --git a/test/gtest_utils.h b/test/gtest_utils.h
index 59697ba..b7b3cc4 100644
--- a/test/gtest_utils.h
+++ b/test/gtest_utils.h
@@ -29,7 +29,6 @@ extern marsio_buff_t *marsio_mbuff_dup(marsio_buff_t *m);
 #define set_metadata(meta, id, offset, is_ctrl, is_decrypt)   \
     {                                                         \
         memset(&meta, 0, sizeof(meta));                       \
-        meta.write_ref = 0;                                   \
         meta.session_id = id;                                 \
         meta.raw_data = NULL;                                 \
         meta.raw_len = 0;                                     \