🎈 perf(TSG-11429): 优化LB 节点动态配置解析流程

优化LB 节点动态配置解析流程

3 files changed, 158 insertions, 202 deletions

diff --git a/service/src/node_bfd.c b/service/src/node_bfd.c
index b9dfd3e..d5c1807 100644
--- a/service/src/node_bfd.c
+++ b/service/src/node_bfd.c
@@ -13,23 +13,23 @@
 
 /* Global Config */
 #ifndef MR_BFD_MAX_SESSION_NUM
-#define MR_BFD_MAX_SESSION_NUM                 1024
+#define MR_BFD_MAX_SESSION_NUM                  1024
 #endif
 
 #ifndef MR_BFD_MAX_SESSION_BUF_NUM
-#define MR_BFD_MAX_SESSION_BUF_NUM             MR_BFD_MAX_SESSION_NUM + 1
+#define MR_BFD_MAX_SESSION_BUF_NUM              MR_BFD_MAX_SESSION_NUM + 1
 #endif
 
 #ifndef MR_BFD_MAX_SESSION_ID
-#define MR_BFD_MAX_SESSION_ID                  1023
+#define MR_BFD_MAX_SESSION_ID                   1023
 #endif
 
 #ifndef MR_BFD_INVALID_SESSION_ID
-#define MR_BFD_INVALID_SESSION_ID              MR_BFD_MAX_SESSION_NUM
+#define MR_BFD_INVALID_SESSION_ID               MR_BFD_MAX_SESSION_NUM
 #endif
 
 #ifndef TIMEOUT_CHECK_US
-#define TIMEOUT_CHECK_US                    500000
+#define TIMEOUT_CHECK_US                        500000
 #endif
 
 #define MR_BFD_STAT_ADD_FOR_TOTAL(st, gid,counter, value)                                                           \
@@ -106,7 +106,7 @@ struct bfd_stat_per_lcore
 /* Bfd Main Struct */
 struct node_bfd_main
 {
-    uint16_t port_tx_map[MR_PHYDEV_MAX];
+    uint16_t port_id_to_edge_node[MR_PHYDEV_MAX];
     struct bfd_stat_per_lcore graph_stat[RTE_MAX_LCORE];
 };
 
@@ -118,26 +118,26 @@ static struct node_bfd_main * global_bfd_main = NULL;
 static void port_tx_map_init(struct sc_main * sc,struct node_bfd_main * bfd_main)
 {
     uint32_t next_edges_count = 0;
-    rte_node_t pfd_node_id = 0;
-    char tx_node_name[MR_SYMBOL_MAX];
+    rte_node_t bfd_node_id = 0;
+    char edge_node_name[MR_SYMBOL_MAX];
     char ** next_edges = NULL;
     struct phydev * phydev_iter = NULL;
 
     /* Create 'Port Id To Tx Node Index' Table */
-    pfd_node_id = rte_node_from_name("bfd");
-    next_edges_count = rte_node_edge_get(pfd_node_id, NULL);
+    bfd_node_id = rte_node_from_name("bfd");
+    next_edges_count = rte_node_edge_get(bfd_node_id, NULL);
     next_edges = malloc(next_edges_count);
-    next_edges_count = rte_node_edge_get(pfd_node_id, next_edges);
+    next_edges_count = rte_node_edge_get(bfd_node_id, next_edges);
 
     while (phydev_iterate(sc->phydev_main, &phydev_iter) >= 0)
     {
-        snprintf(tx_node_name, sizeof(tx_node_name), "phydev_tx-%s",phydev_iter->symbol);
+        snprintf(edge_node_name, sizeof(edge_node_name), "phydev_tx-%s",phydev_iter->symbol);
 
         for (int i = 0; i < next_edges_count; i++)
         {
-            if (strncmp(next_edges[i],tx_node_name,sizeof(tx_node_name)) == 0)
+            if (strncmp(next_edges[i],edge_node_name,sizeof(edge_node_name)) == 0)
             {
-                bfd_main->port_tx_map[phydev_iter->port_id] = i;
+                bfd_main->port_id_to_edge_node[phydev_iter->port_id] = i;
                 break;
             }
         }
@@ -153,10 +153,8 @@ int bfd_init(struct sc_main * sc)
     MR_VERIFY_MALLOC(bfd_main);
 
     port_tx_map_init(sc,bfd_main);
-
     sc->bfd_node_main = bfd_main;
     global_bfd_main = bfd_main;
-
     return RT_SUCCESS;
 }
 
@@ -188,6 +186,7 @@ uint16_t get_bfd_session_id(struct bfd_stat_per_lcore * graph_stat,struct rte_ip
 
     return get_free_session_id(graph_stat,ipv4_hdr);
 }
+
 /* Reply Bfd Request */
 void bfd_reply(struct rte_ether_hdr * ether_hdr, struct rte_ipv4_hdr * ipv4_hdr,struct bfd_header_t * bfd_hdr)
 {
@@ -195,17 +194,15 @@ void bfd_reply(struct rte_ether_hdr * ether_hdr, struct rte_ipv4_hdr * ipv4_hdr,
     struct rte_ipv4_hdr swap_ip_hdr;
 
     /* Swap ether_hdr */
-    swap_eth_hdr.dst_addr = ether_hdr->dst_addr;
-    swap_eth_hdr.src_addr = ether_hdr->src_addr;
-    ether_hdr->dst_addr = swap_eth_hdr.src_addr ;
-    ether_hdr->src_addr = swap_eth_hdr.dst_addr ;
-
+    rte_ether_addr_copy(&ether_hdr->dst_addr, &swap_eth_hdr.dst_addr);
+    rte_ether_addr_copy(&ether_hdr->src_addr, &swap_eth_hdr.src_addr);
+    rte_ether_addr_copy(&swap_eth_hdr.src_addr, &ether_hdr->dst_addr);
+    rte_ether_addr_copy(&swap_eth_hdr.dst_addr, &ether_hdr->src_addr);
     /* Swap ipv4_hdr */
     swap_ip_hdr.src_addr = ipv4_hdr->src_addr;
     swap_ip_hdr.dst_addr = ipv4_hdr->dst_addr;
     ipv4_hdr->src_addr = swap_ip_hdr.dst_addr;
     ipv4_hdr->dst_addr = swap_ip_hdr.src_addr;
-
     /* Set Bfd State */
     bfd_hdr->state = BFD_STATE_UP;
 }
@@ -296,7 +293,7 @@ static __rte_always_inline uint16_t bfd_node_process(struct rte_graph * graph, s
         /* Update prev_tsc */
         MR_BFD_STAT_UPDATE_TSC_FOR_SESSION_ID(bfd_main,gid,bfd_session_id,prev_tsc,rte_rdtsc());
         /* From Ingress Port Id Get Next Node Index (TX) */
-        next0 = bfd_main->port_tx_map[ingress_port_id];
+        next0 = bfd_main->port_id_to_edge_node[ingress_port_id];
         goto node_enqueue;
 
 exception_handling:
@@ -352,19 +349,15 @@ cJSON * bfd_node_monit_loop(struct sc_main * sc)
     unsigned int nr_io_thread = sc->nr_io_thread;
     char bfd_session_id[MR_STRING_MAX];
     const uint64_t drain_tsc = (rte_get_tsc_hz() + US_PER_S - 1) / US_PER_S * TIMEOUT_CHECK_US;
-
     json_root = cJSON_CreateObject();
 
-
     for (gid = 0; gid < nr_io_thread; gid++)
     {
         char graph_index[MR_STRING_MAX];
         uint64_t stats = 0;
 
         struct bfd_stat_per_lcore * stat_item = &bfd_main->graph_stat[gid];
-
         stats = stat_item->total_pkts;
-
         if (stats > 0)
         {
             graph_obj = cJSON_CreateObject();
@@ -391,7 +384,6 @@ cJSON * bfd_node_monit_loop(struct sc_main * sc)
                     cJSON_AddItemToObject(graph_obj,bfd_session_id,graph_session_obj);
                 }
             }
-
         }
         else
         {
@@ -399,10 +391,8 @@ cJSON * bfd_node_monit_loop(struct sc_main * sc)
         }
 
         cJSON_AddNumberToObject(graph_obj, "graph_id", gid);
-
         sprintf(graph_index,"graph-%u",graph_num);
         cJSON_AddItemToObject(json_root,graph_index,graph_obj);
-
         graph_num ++;
     }
 
@@ -466,6 +456,5 @@ cJSON * bfd_node_monit_loop(struct sc_main * sc)
 
     cJSON_AddNumberToObject(json_root, "total_graph_num", graph_num);
     cJSON_AddNumberToObject(json_root, "total_session_num", session_num);
-
     return json_root;
 }
diff --git a/service/src/node_etherfabric.c b/service/src/node_etherfabric.c
index 5504123..0510637 100644
--- a/service/src/node_etherfabric.c
+++ b/service/src/node_etherfabric.c
@@ -34,12 +34,11 @@ do
     st->ingress_stat_per_graph[graph_id].counter += value;                                                                  \
 } while(0)                                                                                                                  \
 
-
-#define MR_ETHERFABRIC_EGRESS_STAT_ADD(st, graph_id, counter, value)                                                       \
-do                                                                                                                    \
-{                                                                                                                     \
-    st->egress_stat_per_graph[graph_id].counter += value;                                                                  \
-} while(0)                                                                                                            \
+#define MR_ETHERFABRIC_EGRESS_STAT_ADD(st, graph_id, counter, value)                                                        \
+do                                                                                                                          \
+{                                                                                                                           \
+    st->egress_stat_per_graph[graph_id].counter += value;                                                                   \
+} while(0)                                                                                                                  \
 
 /* Etherfabric Ingress Next Node */
 enum {
@@ -85,7 +84,7 @@ struct etherfabric_management
 {
     uint16_t es_conf_num;
     uint16_t el_conf_num;
-    uint16_t port_tx_map[MR_PHYDEV_MAX];
+    uint16_t port_id_to_edge_node[MR_PHYDEV_MAX];
     struct etherfabric_service_config etherfabric_service_array[MR_ETHERFABRIC_MAX_CONF];
     struct etherfabric_fwd_table etherfabric_fwd_array[MR_ETHERFABRIC_MAX_CONF];
 };
@@ -164,7 +163,6 @@ int etherfabric_string_to_mac(char *s,struct rte_ether_addr * addr )
     addr->addr_bytes[3] = (uint8_t)a[3];
     addr->addr_bytes[4] = (uint8_t)a[4];
     addr->addr_bytes[5] = (uint8_t)a[5];
-
     return RT_SUCCESS;
 }
 
@@ -191,7 +189,7 @@ int parser_etherfabric_service_conf(struct sc_main * sc, struct etherfabric_mana
     char str_buf[MR_STRING_MAX];
     char str_conf_section[MR_STRING_MAX];
     char str_ip_addr[MR_STRING_MAX];
-    char tx_node_name[MR_SYMBOL_MAX];
+    char edge_node_name[MR_SYMBOL_MAX];
     char str_listen_device[MR_STRING_MAX];
     char **next_edges = NULL;
 
@@ -292,18 +290,17 @@ int parser_etherfabric_service_conf(struct sc_main * sc, struct etherfabric_mana
 
     while (phydev_iterate(sc->phydev_main, &phydev_iter) >= 0)
     {
-        snprintf(tx_node_name, sizeof(tx_node_name), "phydev_tx-%s",phydev_iter->symbol);
+        snprintf(edge_node_name, sizeof(edge_node_name), "phydev_tx-%s",phydev_iter->symbol);
 
         for (int edge_index = 0; edge_index < count; edge_index++)
         {
-            if (strncmp(next_edges[edge_index],tx_node_name,sizeof(tx_node_name)) == 0)
+            if (strncmp(next_edges[edge_index],edge_node_name,sizeof(edge_node_name)) == 0)
             {
-                etherfabric_manage->port_tx_map[phydev_iter->port_id] = edge_index;
+                etherfabric_manage->port_id_to_edge_node[phydev_iter->port_id] = edge_index;
                 break;
             }
         }
     }
-
     return RT_SUCCESS;
 }
 
@@ -392,7 +389,6 @@ void dump_etherfabric_service_config(struct etherfabric_management * etherfabric
 
             MR_INFO("    Id                            : %d",i);
             MR_INFO("     Name                         : %s",etherfabric_service_item->name);
-
             switch (etherfabric_service_item->mode)
             {
                 case MODE_VIRTUAL_WIRE:
@@ -451,7 +447,6 @@ int etherfabric_init(struct sc_main * sc)
 
     /* Parsing The Etherfabric Service Config */
     ret = parser_etherfabric_service_conf(sc,etherfabric_manage);
-
     /* Dump The Config And Update Ip Listen Num */
     if (ret == RT_ERR)
     {
@@ -471,13 +466,13 @@ int etherfabric_init(struct sc_main * sc)
     {
         dump_etherfabric_link_config(etherfabric_manage);
     }
-
     return ret;
 }
 
 /************************************** Etherfabric Node **************************************/
 /* Match Etherfabric Service Conf */
-struct etherfabric_service_config * match_etherfabric_service_conf(struct etherfabric_management * etherfabric_manage,struct rte_ipv4_hdr * ipv4_hdr,struct rte_udp_hdr * udp_hdr,uint16_t * service_index)
+struct etherfabric_service_config * match_etherfabric_service_conf(struct etherfabric_management * etherfabric_manage,struct rte_ipv4_hdr * ipv4_hdr,
+                                                                    struct rte_udp_hdr * udp_hdr,uint16_t * service_index)
 {
     struct etherfabric_service_config * etherfabric_service_item = NULL;
 
@@ -489,25 +484,24 @@ struct etherfabric_service_config * match_etherfabric_service_conf(struct etherf
             *service_index = i;
             return etherfabric_service_item;
         }
-
     }
     return NULL;
 }
 
 /* Match Etherfabric Link Conf  */
-struct etherfabric_fwd_table * match_etherfabric_link_conf(struct etherfabric_management * etherfabric_manage,struct rte_ether_hdr * ether_hdr,struct rte_ipv4_hdr * ipv4_hdr,uint16_t * fwd_table_index)
+struct etherfabric_fwd_table * match_etherfabric_link_conf(struct etherfabric_management * etherfabric_manage,struct rte_ether_hdr * ether_hdr,
+                                                            struct rte_ipv4_hdr * ipv4_hdr,uint16_t * fwd_table_index)
 {
     struct etherfabric_fwd_table * etherfabric_fwd_item = NULL;
     for (int i = 0; etherfabric_manage->el_conf_num; i++)
     {
         etherfabric_fwd_item = &etherfabric_manage->etherfabric_fwd_array[i];
-        if (etherfabric_fwd_item->etherfabric_ip_v4 == ipv4_hdr->src_addr)
+        if (etherfabric_fwd_item->etherfabric_ip_v4 != ipv4_hdr->src_addr)
+            continue;
+        if (memcmp(&etherfabric_fwd_item->etherfabric_mac_addr, &ether_hdr->src_addr, sizeof(struct rte_ether_addr)) == 0)
         {
-            if (memcmp(&etherfabric_fwd_item->etherfabric_mac_addr, &ether_hdr->src_addr, sizeof(struct rte_ether_addr)) == 0)
-            {
-                *fwd_table_index = i;
-                return etherfabric_fwd_item;
-            }
+            *fwd_table_index = i;
+            return etherfabric_fwd_item;
         }
     }
     return NULL;
@@ -542,7 +536,6 @@ static __rte_always_inline uint16_t etherfabric_ingress_node_process(struct rte_
     /* Single Packet Processing */
     while (n_left_from > 0)
     {
-
         uint16_t service_index = MR_ETHERFABRIC_INVALID_SERVICE_INDEX;
         uint32_t head_flg = MR_PARSE_NONE;
         int ret = RT_SUCCESS;
@@ -819,32 +812,29 @@ static __rte_always_inline uint16_t etherfabric_egress_node_process(struct rte_g
                 fill_ipv4_pkt_for_original_packet(mbuf);
                 MR_ETHERFABRIC_EGRESS_STAT_ADD(etherfabric_main,graph_id,ipv4_original_pkt,1);
                 /* From Port Id Get Next Node Index */
-                next_node_index = etherfabric_manage->port_tx_map[port_ingress];
+                next_node_index = etherfabric_manage->port_id_to_edge_node[port_ingress];
                 goto node_enqueue;
             }
-            else
+
+            if (unlikely((service_tag_item->fwd_table_index >= MR_ETHERFABRIC_MAX_CONF)))
             {
-                if (unlikely((service_tag_item->fwd_table_index >= MR_ETHERFABRIC_MAX_CONF)))
-                {
-                    MR_ETHERFABRIC_EGRESS_STAT_ADD(etherfabric_main,graph_id,link_index_invalid,1);
-                    goto exception_handling;
-                }
-
-                etherfabric_fwd_item = &etherfabric_main->etherfabric_manage.etherfabric_fwd_array[service_tag_item->fwd_table_index];
-                etherfabric_service_item = &etherfabric_main->etherfabric_manage.etherfabric_service_array[etherfabric_fwd_item->etherfabric_service_index];
-
-                if (unlikely((etherfabric_fwd_item->etherfabric_service_index >= MR_ETHERFABRIC_MAX_CONF)))
-                {
-                    MR_ETHERFABRIC_EGRESS_STAT_ADD(etherfabric_main,graph_id,service_index_invalid,1);
-                    goto exception_handling;
-                }
-
-                fill_ipv4_pkt_for_constructed_packet(sc,mbuf,port_ingress,service_tag_item->dir,etherfabric_fwd_item,etherfabric_service_item);
-                MR_ETHERFABRIC_EGRESS_STAT_ADD(etherfabric_main,graph_id,ipv4_new_create_pkt,1);
-                /* From Port Id Get Next Node Index */
-                next_node_index = etherfabric_manage->port_tx_map[port_ingress];
-                goto node_enqueue;
+                MR_ETHERFABRIC_EGRESS_STAT_ADD(etherfabric_main,graph_id,link_index_invalid,1);
+                goto exception_handling;
+            }
+
+            etherfabric_fwd_item = &etherfabric_main->etherfabric_manage.etherfabric_fwd_array[service_tag_item->fwd_table_index];
+            etherfabric_service_item = &etherfabric_main->etherfabric_manage.etherfabric_service_array[etherfabric_fwd_item->etherfabric_service_index];
+            if (unlikely((etherfabric_fwd_item->etherfabric_service_index >= MR_ETHERFABRIC_MAX_CONF)))
+            {
+                MR_ETHERFABRIC_EGRESS_STAT_ADD(etherfabric_main,graph_id,service_index_invalid,1);
+                goto exception_handling;
             }
+
+            fill_ipv4_pkt_for_constructed_packet(sc,mbuf,port_ingress,service_tag_item->dir,etherfabric_fwd_item,etherfabric_service_item);
+            MR_ETHERFABRIC_EGRESS_STAT_ADD(etherfabric_main,graph_id,ipv4_new_create_pkt,1);
+            /* From Port Id Get Next Node Index */
+            next_node_index = etherfabric_manage->port_id_to_edge_node[port_ingress];
+            goto node_enqueue;
         }
         else
         {
@@ -904,7 +894,6 @@ cJSON * etherfabric_ingress_node_monit_loop(struct sc_main * sc)
     cJSON * json_root = NULL,* graph_obj = NULL;
     struct node_etherfabric_main * etherfabric_main = sc->etherfabric_node_main;
     unsigned int nr_io_thread = sc->nr_io_thread;
-
     json_root = cJSON_CreateObject();
 
     for (graph_id = 0; graph_id < nr_io_thread; graph_id++)
@@ -915,7 +904,6 @@ cJSON * etherfabric_ingress_node_monit_loop(struct sc_main * sc)
 
         struct etherfabric_ingress_stat_per_lcore * stat_item = &etherfabric_main->ingress_stat_per_graph[graph_id];
         stats = stat_item->total_pkts;
-
         if (stats > 0)
         {
             cJSON_AddNumberToObject(graph_obj, "total_pkts", stats);
@@ -945,7 +933,6 @@ cJSON * etherfabric_ingress_node_monit_loop(struct sc_main * sc)
     }
 
     cJSON_AddNumberToObject(json_root, "total_graph_num", graph_num);
-
     return json_root;
 }
 
@@ -955,7 +942,6 @@ cJSON * etherfabric_egress_node_monit_loop(struct sc_main * sc)
     cJSON * json_root = NULL,* graph_obj = NULL;
     struct node_etherfabric_main * etherfabric_main = sc->etherfabric_node_main;
     unsigned int nr_io_thread = sc->nr_io_thread;
-
     json_root = cJSON_CreateObject();
 
     for (graph_id = 0; graph_id < nr_io_thread; graph_id++)
@@ -991,6 +977,5 @@ cJSON * etherfabric_egress_node_monit_loop(struct sc_main * sc)
     }
 
     cJSON_AddNumberToObject(json_root, "total_graph_num", graph_num);
-
     return json_root;
 }
\ No newline at end of file
diff --git a/service/src/node_lb.c b/service/src/node_lb.c
index 6e1ead2..2049f5b 100644
--- a/service/src/node_lb.c
+++ b/service/src/node_lb.c
@@ -27,12 +27,12 @@
 #define MR_LB_MAX_DEV_FOR_SINGLE_GROUP                          1024
 #endif
 
-#ifndef MR_LB_INVALID_RULE_ARG
-#define MR_LB_INVALID_RULE_ARG                                  0
+#ifndef MR_LB_INVALID_EDGES_INDEX
+#define MR_LB_INVALID_EDGES_INDEX                               65535
 #endif
 
-#ifndef MR_LB_DEV_INVALID
-#define MR_LB_DEV_INVALID                                       0
+#ifndef MR_LB_DEV_NUM_MIN
+#define MR_LB_DEV_NUM_MIN                                  0
 #endif
 
 #ifndef MR_LB_DEV_NEXT_NODE_VALID
@@ -92,7 +92,8 @@ do
 } while(0)                                                                                                              \
 
 /* LB Next Node */
-enum {
+enum
+{
     LB_NEXT_CLASSIFIER = 0,
     LB_NEXT_PKT_DROP,
     LB_NEXT_MAX
@@ -130,7 +131,8 @@ enum
 };
 
 /* Dynamic Load Balance Rule Add Deal Result */
-enum {
+enum
+{
     DYNAMIC_LB_RULE_ADD_SUCCESS = 0,
     DYNAMIC_LB_RULE_ADD_NUM_OUT_OF_MAX,
     DYNAMIC_LB_RULE_ADD_NO_FREE_GROUP_ITEM,
@@ -149,7 +151,8 @@ enum {
 };
 
 /* Dynamic Load Balance Rule Delete Deal Result */
-enum {
+enum
+{
     DYNAMIC_LB_RULE_DEL_SUCCESS = 0,
     DYNAMIC_LB_RULE_DEL_RULE_NUM_IS_ZERO,
     DYNAMIC_LB_RULE_DEL_GROUP_ID_NO_CONFIG,
@@ -158,7 +161,6 @@ enum {
 
 /* Declaration Struct */
 struct lb_group;
-
 /* Dispatch Function */
 typedef uint16_t (*lb_dispatch_func)(struct node_lb_main * lb_main,struct lb_group * group_item,uint32_t hash_usr);
 
@@ -167,7 +169,7 @@ struct lb_vdev
 {
     uint8_t vdev_type;
     uint8_t vdev_flag;
-    uint16_t tx_node_index;
+    uint16_t next_edges_index;
     struct vdev * vdev;
     char vdevsym[MR_SYMBOL_MAX];
 };
@@ -232,7 +234,6 @@ uint16_t get_vdev_up_num(struct lb_vdev * vdev_array,uint16_t vdev_num,uint16_t
             vdev_up_num ++;
         }
     }
-
     return vdev_up_num;
 }
 
@@ -249,12 +250,11 @@ uint16_t load_balance(struct node_lb_main * lb_main,struct lb_group * group_item
     if (total_member_num != 0)
     {
         tx_member_index = hash_usr % total_member_num;
-
         if (tx_member_index < vdev_member_num)
         {
             /* Issued By Vdev */
             uint16_t vdev_index = up_vdev_array[tx_member_index];
-            next_node = group_item->vdev_array[vdev_index].tx_node_index;
+            next_node = group_item->vdev_array[vdev_index].next_edges_index;
         }
         else
         {
@@ -264,7 +264,6 @@ uint16_t load_balance(struct node_lb_main * lb_main,struct lb_group * group_item
             next_node = load_balance(lb_main,tx_group_item,hash_usr);
         }
     }
-
     return next_node;
 }
 
@@ -334,28 +333,16 @@ int lb_repeated_rule_check(struct lb_management * lb_manage,struct lb_group * ch
     for (int i = 0; i < MR_LB_MAX_GROUP; i++)
     {
         group_item = &lb_manage->lb_groups[i];
-        if (group_item->group_status == GROUP_STATUS_IN_USE)
-        {
-            if ((group_item->group_mode == check_group_item->group_mode) || (group_item->vdev_num == check_group_item->vdev_num))
-            {
-                uint16_t vdev_num = 0;
-                for (int j = 0; j < MR_LB_MAX_DEV_FOR_SINGLE_GROUP; j++)
-                {
-                    if (group_item->vdev_array[j].vdev_flag == DEV_ENABLE)
-                    {
-                        if (group_item->vdev_array[j].vdev == check_group_item->vdev_array[j].vdev )
-                        {
-                            vdev_num ++;
-                        }
-                    }
-                }
 
-                if (check_group_item->vdev_num == vdev_num)
-                {
-                    return RT_ERR;
-                }
-            }
-        }
+        if (group_item->group_status != GROUP_STATUS_IN_USE)
+            continue;
+        if (group_item->group_mode != check_group_item->group_mode)
+            continue;
+        if (group_item->vdev_num != check_group_item->vdev_num)
+            continue;
+        if (group_item->vdev_num != check_group_item->vdev_num)
+            continue;
+        return RT_ERR;
     }
     return RT_SUCCESS;
 }
@@ -369,7 +356,6 @@ uint16_t get_lb_item_index_from_group_id(struct lb_management * lb_manage,uint16
         {
             return i;
         }
-
     }
     return MR_LB_GROUP_ITEM_ID_INVALID;
 }
@@ -397,7 +383,6 @@ int parser_local_lb_conf(struct sc_main * sc, struct lb_management * lb_manage)
         {
             continue;
         }
-
         ret = MESA_load_profile_string_nodef(sc->local_cfgfile, str_section, "devices", str_devices,sizeof(str_devices));
         if (ret < 0)
         {
@@ -411,7 +396,6 @@ int parser_local_lb_conf(struct sc_main * sc, struct lb_management * lb_manage)
             MR_ERROR("Load Balance Config : %s ,Dont Have Free Group Item .",str_section);
             return RT_ERR;
         }
-
         lb_group_item = &lb_manage->lb_groups[item_id];
         /* Save Mode */
         if (strcmp(str_mode, "balance") == 0)
@@ -434,52 +418,47 @@ int parser_local_lb_conf(struct sc_main * sc, struct lb_management * lb_manage)
 
         for (int i = 0; i < nr_str_tokens; i += 2)
         {
+            uint8_t vdev_type = DEV_TYPE_MAX;
+            uint16_t next_edges_index = MR_LB_INVALID_EDGES_INDEX;
             uint32_t count;
-            char **next_edges;
+            char ** next_edges;
             char tx_node_name[MR_SYMBOL_MAX];
-            int vdev_flg = MR_LB_DEV_INVALID;
+            struct lb_vdev * _lb_vdev_item = &lb_group_item->vdev_array[vdev_num];
 
-            snprintf(lb_group_item->vdev_array[vdev_num].vdevsym, sizeof(lb_group_item->vdev_array[vdev_num].vdevsym), "%s", str_tokens[i]);
             /* Check The Dev Name */
-            snprintf(tx_node_name, sizeof(tx_node_name), "shmdev_tx-%s",lb_group_item->vdev_array[vdev_num].vdevsym);
+            snprintf(tx_node_name, sizeof(tx_node_name), "shmdev_tx-%s",str_tokens[i]);
             rte_node_t node_id = rte_node_from_name("lb");
             count = rte_node_edge_get(node_id, NULL);
             next_edges = malloc(count);
             count = rte_node_edge_get(node_id, next_edges);
 
-            for (int next_edges_index = 0; next_edges_index < count; next_edges_index++)
+            for (int edges_index = 0; edges_index < count; edges_index++)
             {
-                if (strncmp(next_edges[next_edges_index],tx_node_name,sizeof(tx_node_name)) == 0)
+                if (strncmp(next_edges[edges_index],tx_node_name,sizeof(tx_node_name)) == 0)
                 {
-                    lb_group_item->vdev_array[vdev_num].tx_node_index = next_edges_index;
-                    vdev_flg = MR_LB_DEV_NEXT_NODE_VALID;
+                    next_edges_index = edges_index;
                     break;
                 }
             }
-
             free(next_edges);
 
-            if (vdev_flg != MR_LB_DEV_NEXT_NODE_VALID)
+            if (next_edges_index == MR_LB_INVALID_EDGES_INDEX)
             {
-                MR_ERROR("Load Balance Config : %s The %s ,Not Find Tx Node Index .",str_section,lb_group_item->vdev_array[vdev_num].vdevsym);
+                MR_ERROR("Load Balance Config : %s The %s ,Not Find Tx Node Index .",str_section,str_tokens[i]);
                 return RT_ERR;
             }
 
-            struct vdev * vdev = vdev_lookup(sc->vdev_main, lb_group_item->vdev_array[vdev_num].vdevsym);
+            struct vdev * vdev = vdev_lookup(sc->vdev_main, str_tokens[i]);
             if (vdev == NULL)
             {
-                MR_ERROR("Load Balance Config :  %s ,Dev Name '%s' Is Invalid .",str_section,lb_group_item->vdev_array[vdev_num].vdevsym);
+                MR_ERROR("Load Balance Config :  %s ,Dev Name '%s' Is Invalid .",str_section,str_tokens[i]);
                 return RT_ERR;
             }
 
-            /* Save The vdev */
-            lb_group_item->vdev_array[vdev_num].vdev = vdev;
-            lb_group_item->vdev_array[vdev_num].vdev_flag = DEV_ENABLE;
-
             /* Save Type */
             if (strcmp(str_tokens[i+1], "normal") == 0)
             {
-                lb_group_item->vdev_array[vdev_num].vdev_type = DEV_TYPE_NORMAL;
+                vdev_type = DEV_TYPE_NORMAL;
             }
             else
             {
@@ -488,6 +467,11 @@ int parser_local_lb_conf(struct sc_main * sc, struct lb_management * lb_manage)
             }
 
             vdev_num ++;
+            _lb_vdev_item->vdev_type = vdev_type;
+            _lb_vdev_item->vdev_flag = DEV_ENABLE;
+            _lb_vdev_item->next_edges_index = next_edges_index;
+            _lb_vdev_item->vdev = vdev;
+            snprintf(_lb_vdev_item->vdevsym, sizeof(_lb_vdev_item->vdevsym), "%s", str_tokens[i]);
         }
 
         lb_group_item->group_status = GROUP_STATUS_IN_USE;
@@ -554,7 +538,7 @@ void dump_lb_config(struct lb_management * lb_manage)
                             break;
                         }
 
-                        MR_INFO("     Tx Node Index                : %u",vdev->tx_node_index);
+                        MR_INFO("     Tx Node Index                : %u",vdev->next_edges_index);
                     }
                 }
             }
@@ -564,24 +548,22 @@ void dump_lb_config(struct lb_management * lb_manage)
 
 /************************************** LB Dynamic Rule Process **************************************/
 /* Parse LB Rules For Add */
-int parse_lb_rule_for_add(struct sc_main * sc,struct lb_management * lb_manage,cJSON * j_rule,cJSON *response)
+int parse_lb_rule_for_add(struct sc_main * sc,struct lb_management * lb_manage,cJSON * j_rule,cJSON *response,uint16_t * _group_id)
 {
     uint8_t group_mode = 0;
     uint16_t item_id = 0,group_id = 0,vdev_num = 0;
     struct lb_group lb_group_item = {};
-    struct lb_group * group_item;
+    struct lb_group * group_item = &lb_group_item;
     char dev_str_section[MR_STRING_MAX];
     cJSON * j_group_id = NULL,* j_group_mode = NULL,* j_dev_num = NULL,* j_dev = NULL,* j_dev_name = NULL,* j_dev_type = NULL;
 
-
     /* Get Free Group Item Id */
     if (get_free_group_item_id(lb_manage,&item_id) == RT_ERR)
     {
+        MR_ERROR("LB Single Rule Add Error,No free group item .");
         return DYNAMIC_LB_RULE_ADD_NO_FREE_GROUP_ITEM;
     }
 
-    group_item = &lb_group_item;
-
     /* Group Id */
     j_group_id = cJSON_GetObjectItem(j_rule,MR_LB_CJSON_KEY_GROUP_ID);
     /* Group Mode */
@@ -591,60 +573,63 @@ int parse_lb_rule_for_add(struct sc_main * sc,struct lb_management * lb_manage,c
 
     if (j_group_id == NULL)
     {
+        MR_ERROR("LB Single Rule Add Error,No config group id .");
         return DYNAMIC_LB_RULE_ADD_GROUP_ID_NO_CONFIG;
     }
+    *_group_id = group_id = (uint16_t)j_group_id->valuedouble;
 
     if (j_group_mode == NULL)
     {
+        MR_ERROR("LB Single Rule Add Error,Group Id '%u',No config group mode .",group_id);
         return DYNAMIC_LB_RULE_ADD_GROUP_MODE_NO_CONFIG;
     }
-
     if (j_dev_num == NULL)
     {
+        MR_ERROR("LB Single Rule Add Error,Group Id '%u',No config dev num .",group_id);
         return DYNAMIC_LB_RULE_ADD_DEV_NUM_NO_CONFIG;
     }
+    group_mode = (uint8_t)j_group_mode->valuedouble;
+    vdev_num = (uint16_t)j_dev_num->valuedouble;
 
-    switch ((uint8_t)j_group_mode->valuedouble)
+    switch (group_mode)
     {
         case GROUP_MODE_BALANCE:
             group_item->dispatch_func = (lb_dispatch_func)load_balance;
             break;
 
         default:
+            MR_ERROR("LB Single Rule Add Error,Group Id '%u',Group mode invalid .",group_id);
             return DYNAMIC_LB_RULE_ADD_GROUP_MODE_INVALID;
             break;
     }
 
-    if (((uint16_t)j_dev_num->valuedouble == MR_LB_INVALID_RULE_ARG) || ((uint16_t)j_dev_num->valuedouble > MR_LB_MAX_DEV_FOR_SINGLE_GROUP))
+    if ((vdev_num <= MR_LB_DEV_NUM_MIN) || (vdev_num > MR_LB_MAX_DEV_FOR_SINGLE_GROUP))
     {
+        MR_ERROR("LB Single Rule Add Error,Group Id '%u',Dev num is invalid .",group_id);
         return DYNAMIC_LB_RULE_ADD_DEV_NUM_INVALID;
     }
 
-    group_id = (uint16_t)j_group_id->valuedouble;
-    group_mode = (uint8_t)j_group_mode->valuedouble;
-    vdev_num = (uint16_t)j_dev_num->valuedouble;
-
     /* Parsing All Device */
-    for (int i = 0; i < vdev_num; i++)
+    for (int dev_index = 0; dev_index < vdev_num; dev_index++)
     {
-        int vdev_flg = MR_LB_DEV_INVALID;
+        uint16_t next_edges_index = MR_LB_INVALID_EDGES_INDEX;
         uint32_t count;
         char **next_edges;
-        char tx_node_name[MR_SYMBOL_MAX];
-        struct lb_vdev * vdev_item = NULL;
+        char edge_node_name[MR_SYMBOL_MAX];
+        struct lb_vdev * _lb_vdev_item = NULL;
         struct vdev * vdev = NULL;
-        vdev_item = &group_item->vdev_array[i];
+        _lb_vdev_item = &group_item->vdev_array[dev_index];
 
-        snprintf(dev_str_section, sizeof(dev_str_section), "%s%d", MR_LB_CJSON_KEY_DEV, i);
+        snprintf(dev_str_section, sizeof(dev_str_section), "%s%d", MR_LB_CJSON_KEY_DEV, dev_index);
         j_dev = cJSON_GetObjectItem(j_rule,dev_str_section);
-
         if (j_dev == NULL)
         {
             cJSON *err_info = cJSON_CreateObject();
             cJSON_AddNumberToObject(err_info, MR_LB_CJSON_KEY_GROUP_ID, group_id);
-            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, i);
+            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, dev_index);
             cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ERR_CODE, DYNAMIC_LB_RULE_ADD_DEV_ITEM_NO_CONFIG);
             cJSON_AddItemToObject(response,MR_LB_RPC_RESULT_ERR_INFO,err_info);
+            MR_ERROR("LB Single Rule Add Error,Group Id '%u',Dev Index '%d',The object no config .",group_id,dev_index);
             return DYNAMIC_LB_RULE_ADD_DEV_ITEM_NO_CONFIG;
         }
 
@@ -653,52 +638,49 @@ int parse_lb_rule_for_add(struct sc_main * sc,struct lb_management * lb_manage,c
         {
             cJSON *err_info = cJSON_CreateObject();
             cJSON_AddNumberToObject(err_info, MR_LB_CJSON_KEY_GROUP_ID, group_id);
-            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, i);
+            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, dev_index);
             cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ERR_CODE, DYNAMIC_LB_RULE_ADD_DEV_NAME_NO_CONFIG);
             cJSON_AddItemToObject(response,MR_LB_RPC_RESULT_ERR_INFO,err_info);
+            MR_ERROR("LB Single Rule Add Error,Group Id '%u',Dev Index '%d', The dev name no config .",group_id,dev_index);
             return DYNAMIC_LB_RULE_ADD_DEV_NAME_NO_CONFIG;
         }
 
         /* Check The Dev Name */
-        memcpy(vdev_item->vdevsym,j_dev_name->valuestring,sizeof(vdev_item->vdevsym));
-        vdev = vdev_lookup(sc->vdev_main, vdev_item->vdevsym);
+        vdev = vdev_lookup(sc->vdev_main, j_dev_name->valuestring);
         if (vdev == NULL)
         {
             cJSON *err_info = cJSON_CreateObject();
             cJSON_AddNumberToObject(err_info, MR_LB_CJSON_KEY_GROUP_ID, group_id);
-            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, i);
+            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, dev_index);
             cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ERR_CODE, DYNAMIC_LB_RULE_ADD_DEV_NO_FIND_THE_DEV);
             cJSON_AddItemToObject(response,MR_LB_RPC_RESULT_ERR_INFO,err_info);
+            MR_ERROR("LB Single Rule Add Error,Group Id '%u',Dev Id '%d', Dev Name '%s',The device not find .",group_id,dev_index,j_dev_name->valuestring);
             return DYNAMIC_LB_RULE_ADD_DEV_NO_FIND_THE_DEV;
         }
-        /* Save The vdev */
-        vdev_item->vdev = vdev;
 
-        snprintf(tx_node_name, sizeof(tx_node_name), "shmdev_tx-%s",vdev_item->vdevsym);
+        snprintf(edge_node_name, sizeof(edge_node_name), "shmdev_tx-%s",j_dev_name->valuestring);
         rte_node_t node_id = rte_node_from_name("lb");
         count = rte_node_edge_get(node_id, NULL);
         next_edges = malloc(count);
         count = rte_node_edge_get(node_id, next_edges);
-
-        for (int ni = 0; ni < count; ni++)
+        for (int edges_index = 0; edges_index < count; edges_index++)
         {
-            if (strncmp(next_edges[ni],tx_node_name,sizeof(tx_node_name)) == 0)
+            if (strncmp(next_edges[edges_index],edge_node_name,sizeof(edge_node_name)) == 0)
             {
-                vdev_item->tx_node_index = ni;
-                vdev_flg = MR_LB_DEV_NEXT_NODE_VALID;
+                next_edges_index = edges_index;
                 break;
             }
         }
-
         free(next_edges);
 
-        if (vdev_flg != MR_LB_DEV_NEXT_NODE_VALID)
+        if (next_edges_index == MR_LB_INVALID_EDGES_INDEX)
         {
             cJSON *err_info = cJSON_CreateObject();
             cJSON_AddNumberToObject(err_info, MR_LB_CJSON_KEY_GROUP_ID, group_id);
-            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, i);
+            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, dev_index);
             cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ERR_CODE, DYNAMIC_LB_RULE_ADD_DEV_NO_FIND_TX_NODE);
             cJSON_AddItemToObject(response,MR_LB_RPC_RESULT_ERR_INFO,err_info);
+            MR_ERROR("LB Single Rule Add Error,Group Id '%u',Dev Id '%d', Dev Name '%s',The device not find tx node .",group_id,dev_index,j_dev_name->valuestring);
             return DYNAMIC_LB_RULE_ADD_DEV_NO_FIND_TX_NODE;
         }
 
@@ -708,24 +690,29 @@ int parse_lb_rule_for_add(struct sc_main * sc,struct lb_management * lb_manage,c
         {
             cJSON *err_info = cJSON_CreateObject();
             cJSON_AddNumberToObject(err_info, MR_LB_CJSON_KEY_GROUP_ID, group_id);
-            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, i);
+            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, dev_index);
             cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ERR_CODE, DYNAMIC_LB_RULE_ADD_DEV_TYPE_NO_CONFIG);
             cJSON_AddItemToObject(response,MR_LB_RPC_RESULT_ERR_INFO,err_info);
+            MR_ERROR("LB Single Rule Add Error,Group Id '%u',Dev Id '%d', Dev Name '%s',The device no config device type .",group_id,dev_index,j_dev_name->valuestring);
             return DYNAMIC_LB_RULE_ADD_DEV_TYPE_NO_CONFIG;
         }
 
-        vdev_item->vdev_type = (uint8_t)j_dev_type->valuedouble;
-        if (vdev_item->vdev_type >= DEV_TYPE_MAX)
+        if ((uint8_t)j_dev_type->valuedouble >= DEV_TYPE_MAX)
         {
             cJSON *err_info = cJSON_CreateObject();
             cJSON_AddNumberToObject(err_info, MR_LB_CJSON_KEY_GROUP_ID, group_id);
-            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, i);
+            cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ID, dev_index);
             cJSON_AddNumberToObject(err_info, MR_LB_RPC_RESULT_ERR_DEV_ERR_CODE, DYNAMIC_LB_RULE_ADD_DEV_TYPE_INVALID);
             cJSON_AddItemToObject(response,MR_LB_RPC_RESULT_ERR_INFO,err_info);
+            MR_ERROR("LB Single Rule Add Error,Group Id '%u',Dev Id '%d', Dev Name '%s',The device type invalid .",group_id,dev_index,j_dev_name->valuestring);
             return DYNAMIC_LB_RULE_ADD_DEV_TYPE_INVALID;
         }
 
-        vdev_item->vdev_flag = DEV_ENABLE;
+        _lb_vdev_item->vdev_type = (uint8_t)j_dev_type->valuedouble;
+        _lb_vdev_item->vdev_flag = DEV_ENABLE;
+        _lb_vdev_item->next_edges_index = next_edges_index;
+        _lb_vdev_item->vdev = vdev;
+        memcpy(_lb_vdev_item->vdevsym,j_dev_name->valuestring,sizeof(_lb_vdev_item->vdevsym));
     }
 
     group_item->group_mode = group_mode;
@@ -735,18 +722,20 @@ int parse_lb_rule_for_add(struct sc_main * sc,struct lb_management * lb_manage,c
 
     if (lb_repeated_rule_check(lb_manage,group_item) == RT_ERR)
     {
+
+        MR_ERROR("LB Single Rule Add Error,Group Id '%u',The rule repeated .",group_id);
         return DYNAMIC_LB_RULE_ADD_REPEATED_RULE;
     }
 
     lb_manage->group_num ++;
     memcpy(&lb_manage->lb_groups[item_id],group_item,sizeof(struct lb_group));
-
     return DYNAMIC_LB_RULE_ADD_SUCCESS;
 }
 
 /* Add A Single Dynamic Load Balance Rule Callback */
 int lb_single_rule_add(struct sc_main * sc,cJSON * j_rule,cJSON *response)
 {
+    uint16_t group_id = 0;
     int ret = RT_ERR;
     struct lb_management * new_lb_management = NULL;
     struct lb_management * old_lb_management = global_lb_main->lb_manage;
@@ -758,24 +747,24 @@ int lb_single_rule_add(struct sc_main * sc,cJSON * j_rule,cJSON *response)
     /* Check Current Rule Number */
     if (old_lb_management->group_num >= MR_LB_MAX_GROUP )
     {
+        MR_ERROR("LB Single Rule Add Error,The rule number out of max .");
         ret = DYNAMIC_LB_RULE_ADD_NUM_OUT_OF_MAX;
         goto add_err;
     }
 
     /* LB Management Copy  */
     lb_management_copy(old_lb_management,new_lb_management);
-    ret = parse_lb_rule_for_add(sc,new_lb_management,j_rule,response);
+    ret = parse_lb_rule_for_add(sc,new_lb_management,j_rule,response,&group_id);
     if (ret == DYNAMIC_LB_RULE_ADD_SUCCESS)
     {
         /* Update LB Management */
         global_lb_main->lb_manage = new_lb_management;
-
         /* Wait All Thread Quiescent State */
         rte_rcu_qsbr_synchronize(qsv, RTE_QSBR_THRID_INVALID);
-
         /* Free Old Load Balance Management */
         free_lb_management(old_lb_management);
-        dump_lb_config(new_lb_management);
+        //dump_lb_config(new_lb_management);
+        MR_INFO("LB Single Rule Add Success, Group Id '%u'. ",group_id);
         goto add_success;
     }
 
@@ -793,18 +782,13 @@ static int __lb_single_rule_add_request_handler(cJSON *req, cJSON **rsp, void *a
     struct sc_main * sc = (struct sc_main *)arg;
 
     ret = lb_single_rule_add(sc,req,response);
-
     cJSON_AddNumberToObject(response, MR_LB_RPC_RESULT, ret);
-                char *req_str = cJSON_Print(response);
-                printf("%s\n",req_str);
-                free(req_str);
     *rsp = response;
-
     return 0;
 }
 
 /* Parse LB Rules For Del */
-int parse_lb_rule_for_del(struct lb_management * lb_manage,cJSON * j_rule,cJSON *response)
+int parse_lb_rule_for_del(struct lb_management * lb_manage,cJSON * j_rule,cJSON *response,uint16_t * _group_id)
 {
     uint16_t group_item_id = MR_LB_GROUP_ITEM_ID_INVALID;
     cJSON * j_group_id = NULL;
@@ -812,28 +796,30 @@ int parse_lb_rule_for_del(struct lb_management * lb_manage,cJSON * j_rule,cJSON
 
     /* Group Id */
     j_group_id = cJSON_GetObjectItem(j_rule,MR_LB_CJSON_KEY_GROUP_ID);
-
     if (j_group_id == NULL)
     {
+        MR_ERROR("LB Single Rule Delete Error,The rule no config group id .");
         return DYNAMIC_LB_RULE_DEL_GROUP_ID_NO_CONFIG;
     }
 
+    *_group_id = (uint16_t)j_group_id->valuedouble;
     group_item_id = get_lb_item_index_from_group_id(lb_manage,(uint16_t)j_group_id->valuedouble);
     if (group_item_id == MR_LB_GROUP_ITEM_ID_INVALID)
     {
+        MR_ERROR("LB Single Rule Delete Error,Group Id '%u',The Group id is invalid .",(uint16_t)j_group_id->valuedouble);
         return DYNAMIC_LB_RULE_DEL_GROUP_ID_INVALID;
     }
 
     del_group_item = &lb_manage->lb_groups[group_item_id];
     memset(del_group_item,0,sizeof(struct lb_group));
     lb_manage->group_num --;
-
     return DYNAMIC_LB_RULE_DEL_SUCCESS;
 }
 
 /* Delete A Single Dynamic Load Balance Rule Callback */
 int lb_single_rule_del(cJSON * j_rule,cJSON *response)
 {
+    uint16_t group_id = 0;
     int ret = RT_ERR;
     struct lb_management * new_lb_management = NULL;
     struct lb_management * old_lb_management = global_lb_main->lb_manage;
@@ -841,28 +827,27 @@ int lb_single_rule_del(cJSON * j_rule,cJSON *response)
 
     /* Create A New Load Balance Management */
     new_lb_management = create_lb_management();
-
     /* Check Current Rule Number */
     if (old_lb_management->group_num == 0 )
     {
+        MR_ERROR("LB Single Rule Delete Error,The Local LB Rule Is Null .");
         ret = DYNAMIC_LB_RULE_DEL_RULE_NUM_IS_ZERO;
         goto del_err;
     }
 
     /* LB Management Copy  */
     lb_management_copy(old_lb_management,new_lb_management);
-    ret = parse_lb_rule_for_del(new_lb_management,j_rule,response);
+    ret = parse_lb_rule_for_del(new_lb_management,j_rule,response,&group_id);
     if (ret == DYNAMIC_LB_RULE_DEL_SUCCESS)
     {
         /* Update LB Management */
         global_lb_main->lb_manage = new_lb_management;
-
         /* Wait All Thread Quiescent State */
         rte_rcu_qsbr_synchronize(qsv, RTE_QSBR_THRID_INVALID);
-
         /* Free Old Load Balance Management */
         free_lb_management(old_lb_management);
         dump_lb_config(new_lb_management);
+        MR_ERROR("LB Single Rule Delete Success,Group Id '%u'.",group_id);
         goto del_success;
     }
 
@@ -879,10 +864,8 @@ static int __lb_single_rule_del_request_handler(cJSON *req, cJSON **rsp, void *a
     cJSON *response = cJSON_CreateObject();
 
     ret = lb_single_rule_del(req,response);
-
     cJSON_AddNumberToObject(response, MR_LB_RPC_RESULT, ret);
     *rsp = response;
-
     return 0;
 }
 
@@ -923,15 +906,14 @@ int lb_init(struct sc_main * sc)
         rte_rcu_qsbr_thread_register(lb_main->qsv, lcore_id);
     }
 
-    /* 1. Parser The Local LB Config */
+    /* Parser The Local LB Config */
     ret = parser_local_lb_conf(sc,lb_manage);
 
-    /* 2. Dump The Config */
+    /* Dump The Config */
     if (ret != RT_ERR)
     {
         dump_lb_config(lb_manage);
     }
-
     return ret;
 }