Integrated ReD congestion packet drop to Wi-SUN bootstrap interface.

Author: Juha Heiuskanen

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Features
 * Use high priority for Wi-SUN maintenance messages to improve network stability under heavy load.
 * Limit network TX queue size under heavy load by using Random Early Detection for congestion avoidance.
+* Integrated Random early detection congestion packet drop to Wi-SUN interface.
 
 ### Changes
 * Nanostack now indicates connection down on RPL local repair start

source/6LoWPAN/ws/ws_bootstrap.c

@@ -20,6 +20,7 @@
 #ifdef HAVE_WS
 #include "ns_types.h"
 #include "ns_trace.h"
+#include "nsdynmemLIB.h"
 #include "net_interface.h"
 #include "eventOS_event.h"
 #include "randLIB.h"
@@ -76,6 +77,7 @@
 #include "6LoWPAN/ws/ws_eapol_auth_relay.h"
 #include "6LoWPAN/ws/ws_eapol_relay.h"
 #include "libNET/src/net_dns_internal.h"
+#include "Service_Libs/random_early_detection/random_early_detection_api.h"
 
 #define TRACE_GROUP "wsbs"
 
@@ -112,6 +114,7 @@ static int8_t ws_bootstrap_neighbor_set(protocol_interface_info_entry_t *cur, pa
 static void ws_bootstrap_candidate_table_reset(protocol_interface_info_entry_t *cur);
 static parent_info_t *ws_bootstrap_candidate_parent_get(struct protocol_interface_info_entry *cur, const uint8_t *addr, bool create);
 static void ws_bootstrap_candidate_parent_sort(struct protocol_interface_info_entry *cur, parent_info_t *new_entry);
+static void ws_bootstrap_packet_congestion_init(protocol_interface_info_entry_t *cur);
 
 typedef enum {
     WS_PARENT_SOFT_SYNCH = 0,  /**< let FHSS make decision if synchronization is needed*/
@@ -3310,6 +3313,8 @@ static void ws_bootstrap_event_handler(arm_event_s *event)
 
             // All trickle timers stopped to allow entry from any state
             ws_bootstrap_asynch_trickle_stop(cur);
+            //Init Packet congestion
+            ws_bootstrap_packet_congestion_init(cur);
 
             if (cur->bootsrap_mode == ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
                 tr_info("Border router start network");
@@ -3799,4 +3804,78 @@ int ws_bootstrap_get_info(protocol_interface_info_entry_t *cur, struct ws_stack_
     return 0;
 }
 
+//Calculate max_packet queue size
+static uint16_t ws_bootstrap_define_congestin_max_threshold(uint32_t heap_total_size, uint16_t packet_size, uint16_t packet_per_seconds, uint32_t max_delay, uint16_t min_packet_queue_size, uint16_t max_packet_queue_size)
+{
+    uint32_t max_packet_count = 0;
+    if (heap_total_size) {
+        //Claculate how many packet can be max queue to half of heap
+        max_packet_count = (heap_total_size / 2) / packet_size;
+    }
+
+    //Calculate how many packet is possible to queue for guarantee given max delay
+    uint32_t max_delayded_queue_size = max_delay * packet_per_seconds;
+
+    if (max_packet_count > max_delayded_queue_size) {
+        //Limit queue size by MAX delay
+        max_packet_count = max_delayded_queue_size;
+    }
+
+    if (max_packet_count > max_packet_queue_size) {
+        //Limit queue size by Max
+        max_packet_count = max_packet_queue_size;
+    } else if (max_packet_count < min_packet_queue_size) {
+        //Limit queue size by Min
+        max_packet_count = min_packet_queue_size;
+    }
+    return (uint16_t)max_packet_count;
+}
+
+static uint16_t ws_bootstrap_packet_per_seconds(protocol_interface_info_entry_t *cur, uint16_t packet_size)
+{
+    uint32_t data_rate = ws_common_datarate_get(cur);
+
+    //calculate how many packet is possible send in paper
+    data_rate /= 8 * packet_size;
+
+    //Divide optimal  by / 5 because we split TX / RX slots and BC schedule
+    //With Packet size 500 it should return
+    //Return 15 for 300kBits
+    //Return 7 for 150kBits
+    //Return 2 for 50kBits
+    return data_rate / 5;
+}
+
+
+
+static void ws_bootstrap_packet_congestion_init(protocol_interface_info_entry_t *cur)
+{
+    random_early_detection_free(cur->random_early_detection);
+    cur->random_early_detection = NULL;
+
+    //TODO implement API for HEAP info request
+    uint32_t heap_size;
+    const mem_stat_t *mem_stats = ns_dyn_mem_get_mem_stat();
+    if (mem_stats) {
+        heap_size = mem_stats->heap_sector_size;
+    } else {
+        heap_size = 0;
+    }
+
+    uint16_t packet_per_seconds = ws_bootstrap_packet_per_seconds(cur, WS_CONGESTION_PACKET_SIZE);
+
+    uint16_t min_th, max_th;
+
+    if (cur->bootsrap_mode == ARM_NWK_BOOTSRAP_MODE_6LoWPAN_BORDER_ROUTER) {
+        max_th = ws_bootstrap_define_congestin_max_threshold(heap_size, WS_CONGESTION_PACKET_SIZE, packet_per_seconds, WS_CONGESTION_QUEUE_DELAY, WS_CONGESTION_BR_MIN_QUEUE_SIZE, WS_CONGESTION_BR_MAX_QUEUE_SIZE);
+    } else {
+        max_th = ws_bootstrap_define_congestin_max_threshold(heap_size, WS_CONGESTION_PACKET_SIZE, packet_per_seconds, WS_CONGESTION_QUEUE_DELAY, WS_CONGESTION_NODE_MIN_QUEUE_SIZE, WS_CONGESTION_NODE_MAX_QUEUE_SIZE);
+    }
+
+    min_th = max_th / 2;
+    tr_info("Wi-SUN packet congestion minTh %u, maxTh %u, drop probability %u weight %u, Packet/Seconds %u", min_th, max_th, WS_CONGESTION_RED_DROP_PROBABILITY, RED_AVERAGE_WEIGHT_EIGHTH, packet_per_seconds);
+    cur->random_early_detection = random_early_detection_create(min_th, max_th, WS_CONGESTION_RED_DROP_PROBABILITY, RED_AVERAGE_WEIGHT_EIGHTH);
+
+}
+
 #endif //HAVE_WS

source/6LoWPAN/ws/ws_config.h

@@ -221,6 +221,13 @@ extern uint8_t DEVICE_MIN_SENS;
 #define WS_PARENT_LIST_MAX_PAN_IN_DISCOVERY 5  // During discovery state how many neighbours per pan
 #define WS_PARENT_LIST_MAX_PAN_IN_ACTIVE 2     // During active state two nodes per pan is allowed
 
+#define WS_CONGESTION_PACKET_SIZE 500           // Packet length for calculate how much heap message queue can fit
+#define WS_CONGESTION_QUEUE_DELAY 60            // Define message queue max length for given delay. This value is multiple by packet/seconds
+#define WS_CONGESTION_RED_DROP_PROBABILITY 10 //10.0%
+#define WS_CONGESTION_BR_MIN_QUEUE_SIZE 85000 / WS_CONGESTION_PACKET_SIZE
+#define WS_CONGESTION_BR_MAX_QUEUE_SIZE 600000 / WS_CONGESTION_PACKET_SIZE
+#define WS_CONGESTION_NODE_MIN_QUEUE_SIZE 10000 / WS_CONGESTION_PACKET_SIZE
+#define WS_CONGESTION_NODE_MAX_QUEUE_SIZE 85000 / WS_CONGESTION_PACKET_SIZE
 /*
  * Modifications for base specification.
  *