Changeset 6f7cd4b

Timestamp:

01/13/17 14:27:15 (4 years ago)

Author:

Richard Sanger <rsanger@…>

Branches:

4.0.1-hotfixes, cachetimestamps, develop, dpdk-ndag, etsilive, master, ndag_format, rc-4.0.1, rc-4.0.2, rc-4.0.3, rc-4.0.4, ringdecrementfix, ringperformance, ringtimestampfixes

Children:

174b3c7

Parents:

d31b952

Message:

Makes a couple of modifications to the DPDK RSS hash key patch

• Ensure CUSTOM_HASHER still returns -1 to libtrace
• Rework to allow any size of hash
• Rework to malloc the key I'm not 100% convinced DPDK does not hold on to the reference.

• Also fixes a bug in the fallback libtrace hasher handling. Which was always sending packets to the same thread.

Location:

lib

Files:

• format_dpdk.c (modified) (5 diffs)
• hash_toeplitz.c (modified) (3 diffs)
• hash_toeplitz.h (modified) (1 diff)

lib/format_dpdk.c

@@ -365 +365 @@
         char mempool_name[MEMPOOL_NAME_LEN]; /* The name of the mempool that we are using */
         enum hasher_types hasher_type;
+        uint8_t *rss_key;
         /* To improve single-threaded performance we always batch reading
          * packets, in a burst, otherwise the parallel library does this for us */
@@ -857 +858 @@
         FORMAT(libtrace)->burst_offset = 0;
         FORMAT(libtrace)->hasher_type = HASHER_BALANCE;
+        FORMAT(libtrace)->rss_key = NULL;
 
         /* Make our first stream */
@@ -930 +932 @@
                 return 0;
         case TRACE_OPTION_HASHER:
-                FORMAT(libtrace)->hasher_type=*(enum hasher_types*)data;
-                return 0;
+                switch (*((enum hasher_types *) data))
+                {
+                case HASHER_BALANCE:
+                case HASHER_UNIDIRECTIONAL:
+                case HASHER_BIDIRECTIONAL:
+                        FORMAT(libtrace)->hasher_type = *(enum hasher_types*)data;
+                        if (FORMAT(libtrace)->rss_key)
+                                free(FORMAT(libtrace)->rss_key);
+                        FORMAT(libtrace)->rss_key = NULL;
+                        return 0;
+                case HASHER_CUSTOM:
+                        // Let libtrace do this
+                        return -1;
+                }
+                break;
         case TRACE_OPTION_FILTER:
                 /* TODO filtering */
@@ -1340 +1355 @@
         }
 
-        // for symmetric rss, repeat 2 bytes
-        // otherwise, use default rss key in drivers
-        uint8_t rss_key[52]; // 52 for i40e, 40 for others
-        if (format_data->hasher_type == HASHER_BIDIRECTIONAL) {
+        /* Generate the hash key, based on the device */
+        uint8_t rss_size = 52; // 52 for i40e, 40 for others, use the largest by default
+        // In new versions DPDK we can query the size
 #if RTE_VERSION >= RTE_VERSION_NUM(2, 1, 0, 0)
-                struct rte_eth_dev_info dev_info;
-                rte_eth_dev_info_get(format_data->port, &dev_info);
-                port_conf.rx_adv_conf.rss_conf.rss_key_len = dev_info.hash_key_size;
-#else
-                port_conf.rx_adv_conf.rss_conf.rss_key_len = sizeof(rss_key);
-#endif
-                // first 2 bytes of rss_intel_key from drivers/net/e1000/igb_rxtx.c
-                static uint8_t rss_key_2bytes[] = {0x6D, 0x5A};
-                int i;
-                for (i=0; i<port_conf.rx_adv_conf.rss_conf.rss_key_len; i += sizeof(rss_key_2bytes))
-                        memcpy(rss_key + i, rss_key_2bytes, sizeof(rss_key_2bytes));
-                port_conf.rx_adv_conf.rss_conf.rss_key = rss_key;
+        struct rte_eth_dev_info dev_info;
+        rte_eth_dev_info_get(format_data->port, &dev_info);
+        rss_size = dev_info.hash_key_size;
+#endif
+        if (rss_size != 0) {
+                format_data->rss_key = malloc(rss_size);
+                if (format_data->hasher_type == HASHER_BIDIRECTIONAL) {
+                        toeplitz_ncreate_bikey(format_data->rss_key, rss_size);
+                } else {
+                        toeplitz_ncreate_unikey(format_data->rss_key, rss_size);
+                }
+                port_conf.rx_adv_conf.rss_conf.rss_key = format_data->rss_key;
+#if RTE_VERSION >= RTE_VERSION_NUM(1, 7, 0, 1)
+                port_conf.rx_adv_conf.rss_conf.rss_key_len = rss_size;
+#endif
+        } else {
+                fprintf(stderr, "DPDK couldn't configure RSS hashing!");
         }
 
@@ -1762 +1781 @@
                 libtrace_list_deinit(FORMAT(libtrace)->per_stream);
                 /* filter here if we used it */
+                if (FORMAT(libtrace)->rss_key)
+                        free(FORMAT(libtrace)->rss_key);
                 free(libtrace->format_data);
         }

lib/hash_toeplitz.c

@@ -71 +71 @@
  * Creates a random unidirectional RSS key - a ip or ip+port combination in
  * the opposite directions will most likely get different hashes.
+ * @param key An array of bytes to retrieve the RSS key
+ * @param num The number of bytes in key
+ */
+void toeplitz_ncreate_unikey(uint8_t *key, size_t num) {
+        size_t i;
+        unsigned int seed = time(NULL);
+        for (i = 0; i < num; i++) {
+                key[i] = (uint8_t) rand_r(&seed);
+        }
+}
+
+/**
+ * Creates a random 40 byte unidirectional RSS key - a ip or ip+port combination
+ * in the opposite directions will most likely get different hashes.
  * @param key must have 40 bytes of space to retrieve random the key
- */ 
+ */
 void toeplitz_create_unikey(uint8_t *key) {
-        int i;
-        unsigned int seed = time(NULL);
-        for (i = 0; i < 40; i++) {
-                key[i] = (uint8_t) rand_r(&seed);
-        }
+        toeplitz_ncreate_unikey(key, 40);
 }
 
@@ -85 +95 @@
  * in opposite directions will receive the same hash
  * @param key must have 40 bytes of space to retrieve random the key
- */
-void toeplitz_create_bikey(uint8_t *key) {
+ * @param num The number of bytes in the key, must be a multiple of 2
+ */
+void toeplitz_ncreate_bikey(uint8_t *key, size_t num) {
         unsigned int seed = time(NULL);
-        int i;
+        size_t i;
+        if (num % 2 != 0) {
+                perror("Can not create a bidirectional key for an odd length key");
+        }
         // Every thing is 16bit (port=16, ipv4=32, ipv6=128 
         // aligned so this will make the hash bidirectional
         uint16_t bi_key = (uint16_t) rand_r(&seed);
         uint16_t *bi_rep = (uint16_t *) key;
-        for (i = 0; i < 20; i++) {
+        for (i = 0; i < num/2; i++) {
                 bi_rep[i] = bi_key;
         }
+}
+
+/**
+ * Create a 40 byte bidirectional RSS key, i.e. ip and ip+port configurations
+ * in opposite directions will receive the same hash
+ * @param key An array of bytes to retrieve the RSS key
+ */
+void toeplitz_create_bikey(uint8_t *key) {
+        toeplitz_ncreate_bikey(key, 40);
 }
 
@@ -106 +129 @@
         }
         toeplitz_hash_expand_key(conf);
+        conf->hash_ipv4 = 1;
+        conf->hash_ipv6 = 1;
+        conf->hash_tcp_ipv4 = 1;
+        conf->x_hash_udp_ipv4 = 1;
+        conf->hash_tcp_ipv6 = 1;
+        conf->x_hash_udp_ipv6 = 1;
 }
 

lib/hash_toeplitz.h

@@ -58 +58 @@
 void toeplitz_init_config(toeplitz_conf_t *conf, bool bidirectional);
 uint64_t toeplitz_hash_packet(const libtrace_packet_t * pkt, const toeplitz_conf_t *cnf);
+void toeplitz_ncreate_bikey(uint8_t *key, size_t num);
 void toeplitz_create_bikey(uint8_t *key);
+void toeplitz_ncreate_unikey(uint8_t *key, size_t num);
 void toeplitz_create_unikey(uint8_t *key);