bc4e8ca6a4
1. downlod dpdk 2.2.0 debian spec wget -c https://launchpad.net/ubuntu/+archive/primary/+files/dpdk_2.2.0-0ubuntu8.dsc wget -c https://launchpad.net/ubuntu/+archive/primary/+files/dpdk_2.2.0.orig.tar.gz wget -c https://launchpad.net/ubuntu/+archive/primary/+files/dpdk_2.2.0-0ubuntu8.debian.tar.xz dpkg-source -x dpdk_2.2.0-0ubuntu8.dsc Change-Id: Icb9aaf51982fa944e2b8a477c2816bf501ba2e03 Signed-off-by: Guo Ruijing <ruijing.guo@intel.com>
261 lines
8.9 KiB
Diff
261 lines
8.9 KiB
Diff
Description: backport of dpdk 16.04-rc fix for LP: #1568838
|
|
|
|
Minimal modification to adapt to the not yet existing unified RTE_ARCH_X86
|
|
|
|
Forwarded: n/a (already upstream)
|
|
Author: Christian Ehrhardt <christian.ehrhardt@canonical.com>
|
|
Last-Update: 2016-04-11
|
|
|
|
From f9bd3342114a9db436f71b12ac424aff224482cb Mon Sep 17 00:00:00 2001
|
|
From: Pablo de Lara <pablo.de.lara.guarch@intel.com>
|
|
Date: Fri, 1 Apr 2016 16:03:49 +0100
|
|
Subject: [PATCH] hash: fix multi-process support
|
|
|
|
Hash library used a function pointer to choose a different
|
|
key compare function, depending on the key size.
|
|
As a result, multiple processes could not use the same hash table,
|
|
as the function addresses vary from one process to another.
|
|
|
|
Instead, a jump table is used, so each process has its own
|
|
function addresses, accessing this table with an index stored
|
|
in the hash table (note that using a custom key compare function
|
|
is not supported in multi-process mode).
|
|
|
|
Fixes: 48a399119619 ("hash: replace with cuckoo hash implementation")
|
|
|
|
Signed-off-by: Pablo de Lara <pablo.de.lara.guarch@intel.com>
|
|
Acked-by: Bruce Richardson <bruce.richardson@intel.com>
|
|
---
|
|
doc/guides/prog_guide/hash_lib.rst | 8 +++
|
|
doc/guides/rel_notes/release_16_04.rst | 8 +++
|
|
lib/librte_hash/rte_cuckoo_hash.c | 107 +++++++++++++++++++++++++++------
|
|
3 files changed, 104 insertions(+), 19 deletions(-)
|
|
|
|
Index: dpdk/doc/guides/prog_guide/hash_lib.rst
|
|
===================================================================
|
|
--- dpdk.orig/doc/guides/prog_guide/hash_lib.rst
|
|
+++ dpdk/doc/guides/prog_guide/hash_lib.rst
|
|
@@ -87,6 +87,14 @@ or stored in the hash table itself.
|
|
The example hash tables in the L2/L3 Forwarding sample applications defines which port to forward a packet to based on a packet flow identified by the five-tuple lookup.
|
|
However, this table could also be used for more sophisticated features and provide many other functions and actions that could be performed on the packets and flows.
|
|
|
|
+Multi-process support
|
|
+---------------------
|
|
+
|
|
+The hash library can be used in a multi-process environment, minding that only lookups are thread-safe.
|
|
+The only function that can only be used in single-process mode is rte_hash_set_cmp_func(), which sets up
|
|
+a custom compare function, which is assigned to a function pointer (therefore, it is not supported in
|
|
+multi-process mode).
|
|
+
|
|
Implementation Details
|
|
----------------------
|
|
|
|
Index: dpdk/lib/librte_hash/rte_cuckoo_hash.c
|
|
===================================================================
|
|
--- dpdk.orig/lib/librte_hash/rte_cuckoo_hash.c
|
|
+++ dpdk/lib/librte_hash/rte_cuckoo_hash.c
|
|
@@ -102,6 +102,64 @@ EAL_REGISTER_TAILQ(rte_hash_tailq)
|
|
|
|
#define LCORE_CACHE_SIZE 8
|
|
|
|
+#if defined(RTE_ARCH_X86_64) || defined(RTE_ARCH_I686) ||\
|
|
+ defined(RTE_ARCH_X86_X32) || defined(RTE_ARCH_ARM64)
|
|
+/*
|
|
+ * All different options to select a key compare function,
|
|
+ * based on the key size and custom function.
|
|
+ */
|
|
+enum cmp_jump_table_case {
|
|
+ KEY_CUSTOM = 0,
|
|
+ KEY_16_BYTES,
|
|
+ KEY_32_BYTES,
|
|
+ KEY_48_BYTES,
|
|
+ KEY_64_BYTES,
|
|
+ KEY_80_BYTES,
|
|
+ KEY_96_BYTES,
|
|
+ KEY_112_BYTES,
|
|
+ KEY_128_BYTES,
|
|
+ KEY_OTHER_BYTES,
|
|
+ NUM_KEY_CMP_CASES,
|
|
+};
|
|
+
|
|
+/*
|
|
+ * Table storing all different key compare functions
|
|
+ * (multi-process supported)
|
|
+ */
|
|
+const rte_hash_cmp_eq_t cmp_jump_table[NUM_KEY_CMP_CASES] = {
|
|
+ NULL,
|
|
+ rte_hash_k16_cmp_eq,
|
|
+ rte_hash_k32_cmp_eq,
|
|
+ rte_hash_k48_cmp_eq,
|
|
+ rte_hash_k64_cmp_eq,
|
|
+ rte_hash_k80_cmp_eq,
|
|
+ rte_hash_k96_cmp_eq,
|
|
+ rte_hash_k112_cmp_eq,
|
|
+ rte_hash_k128_cmp_eq,
|
|
+ memcmp
|
|
+};
|
|
+#else
|
|
+/*
|
|
+ * All different options to select a key compare function,
|
|
+ * based on the key size and custom function.
|
|
+ */
|
|
+enum cmp_jump_table_case {
|
|
+ KEY_CUSTOM = 0,
|
|
+ KEY_OTHER_BYTES,
|
|
+ NUM_KEY_CMP_CASES,
|
|
+};
|
|
+
|
|
+/*
|
|
+ * Table storing all different key compare functions
|
|
+ * (multi-process supported)
|
|
+ */
|
|
+const rte_hash_cmp_eq_t cmp_jump_table[NUM_KEY_CMP_CASES] = {
|
|
+ NULL,
|
|
+ memcmp
|
|
+};
|
|
+
|
|
+#endif
|
|
+
|
|
struct lcore_cache {
|
|
unsigned len; /**< Cache len */
|
|
void *objs[LCORE_CACHE_SIZE]; /**< Cache objects */
|
|
@@ -115,7 +173,10 @@ struct rte_hash {
|
|
uint32_t key_len; /**< Length of hash key. */
|
|
rte_hash_function hash_func; /**< Function used to calculate hash. */
|
|
uint32_t hash_func_init_val; /**< Init value used by hash_func. */
|
|
- rte_hash_cmp_eq_t rte_hash_cmp_eq; /**< Function used to compare keys. */
|
|
+ rte_hash_cmp_eq_t rte_hash_custom_cmp_eq;
|
|
+ /**< Custom function used to compare keys. */
|
|
+ enum cmp_jump_table_case cmp_jump_table_idx;
|
|
+ /**< Indicates which compare function to use. */
|
|
uint32_t bucket_bitmask; /**< Bitmask for getting bucket index
|
|
from hash signature. */
|
|
uint32_t key_entry_size; /**< Size of each key entry. */
|
|
@@ -187,7 +248,16 @@ rte_hash_find_existing(const char *name)
|
|
|
|
void rte_hash_set_cmp_func(struct rte_hash *h, rte_hash_cmp_eq_t func)
|
|
{
|
|
- h->rte_hash_cmp_eq = func;
|
|
+ h->rte_hash_custom_cmp_eq = func;
|
|
+}
|
|
+
|
|
+static inline int
|
|
+rte_hash_cmp_eq(const void *key1, const void *key2, const struct rte_hash *h)
|
|
+{
|
|
+ if (h->cmp_jump_table_idx == KEY_CUSTOM)
|
|
+ return h->rte_hash_custom_cmp_eq(key1, key2, h->key_len);
|
|
+ else
|
|
+ return cmp_jump_table[h->cmp_jump_table_idx](key1, key2, h->key_len);
|
|
}
|
|
|
|
struct rte_hash *
|
|
@@ -292,35 +362,35 @@ rte_hash_create(const struct rte_hash_pa
|
|
/* Select function to compare keys */
|
|
switch (params->key_len) {
|
|
case 16:
|
|
- h->rte_hash_cmp_eq = rte_hash_k16_cmp_eq;
|
|
+ h->cmp_jump_table_idx = KEY_16_BYTES;
|
|
break;
|
|
case 32:
|
|
- h->rte_hash_cmp_eq = rte_hash_k32_cmp_eq;
|
|
+ h->cmp_jump_table_idx = KEY_32_BYTES;
|
|
break;
|
|
case 48:
|
|
- h->rte_hash_cmp_eq = rte_hash_k48_cmp_eq;
|
|
+ h->cmp_jump_table_idx = KEY_48_BYTES;
|
|
break;
|
|
case 64:
|
|
- h->rte_hash_cmp_eq = rte_hash_k64_cmp_eq;
|
|
+ h->cmp_jump_table_idx = KEY_64_BYTES;
|
|
break;
|
|
case 80:
|
|
- h->rte_hash_cmp_eq = rte_hash_k80_cmp_eq;
|
|
+ h->cmp_jump_table_idx = KEY_80_BYTES;
|
|
break;
|
|
case 96:
|
|
- h->rte_hash_cmp_eq = rte_hash_k96_cmp_eq;
|
|
+ h->cmp_jump_table_idx = KEY_96_BYTES;
|
|
break;
|
|
case 112:
|
|
- h->rte_hash_cmp_eq = rte_hash_k112_cmp_eq;
|
|
+ h->cmp_jump_table_idx = KEY_112_BYTES;
|
|
break;
|
|
case 128:
|
|
- h->rte_hash_cmp_eq = rte_hash_k128_cmp_eq;
|
|
+ h->cmp_jump_table_idx = KEY_128_BYTES;
|
|
break;
|
|
default:
|
|
/* If key is not multiple of 16, use generic memcmp */
|
|
- h->rte_hash_cmp_eq = memcmp;
|
|
+ h->cmp_jump_table_idx = KEY_OTHER_BYTES;
|
|
}
|
|
#else
|
|
- h->rte_hash_cmp_eq = memcmp;
|
|
+ h->cmp_jump_table_idx = KEY_OTHER_BYTES;
|
|
#endif
|
|
|
|
snprintf(ring_name, sizeof(ring_name), "HT_%s", params->name);
|
|
@@ -594,7 +664,7 @@ __rte_hash_add_key_with_hash(const struc
|
|
prim_bkt->signatures[i].alt == alt_hash) {
|
|
k = (struct rte_hash_key *) ((char *)keys +
|
|
prim_bkt->key_idx[i] * h->key_entry_size);
|
|
- if (h->rte_hash_cmp_eq(key, k->key, h->key_len) == 0) {
|
|
+ if (rte_hash_cmp_eq(key, k->key, h) == 0) {
|
|
/* Enqueue index of free slot back in the ring. */
|
|
enqueue_slot_back(h, cached_free_slots, slot_id);
|
|
/* Update data */
|
|
@@ -614,7 +684,7 @@ __rte_hash_add_key_with_hash(const struc
|
|
sec_bkt->signatures[i].current == alt_hash) {
|
|
k = (struct rte_hash_key *) ((char *)keys +
|
|
sec_bkt->key_idx[i] * h->key_entry_size);
|
|
- if (h->rte_hash_cmp_eq(key, k->key, h->key_len) == 0) {
|
|
+ if (rte_hash_cmp_eq(key, k->key, h) == 0) {
|
|
/* Enqueue index of free slot back in the ring. */
|
|
enqueue_slot_back(h, cached_free_slots, slot_id);
|
|
/* Update data */
|
|
@@ -725,7 +795,7 @@ __rte_hash_lookup_with_hash(const struct
|
|
bkt->signatures[i].sig != NULL_SIGNATURE) {
|
|
k = (struct rte_hash_key *) ((char *)keys +
|
|
bkt->key_idx[i] * h->key_entry_size);
|
|
- if (h->rte_hash_cmp_eq(key, k->key, h->key_len) == 0) {
|
|
+ if (rte_hash_cmp_eq(key, k->key, h) == 0) {
|
|
if (data != NULL)
|
|
*data = k->pdata;
|
|
/*
|
|
@@ -748,7 +818,7 @@ __rte_hash_lookup_with_hash(const struct
|
|
bkt->signatures[i].alt == sig) {
|
|
k = (struct rte_hash_key *) ((char *)keys +
|
|
bkt->key_idx[i] * h->key_entry_size);
|
|
- if (h->rte_hash_cmp_eq(key, k->key, h->key_len) == 0) {
|
|
+ if (rte_hash_cmp_eq(key, k->key, h) == 0) {
|
|
if (data != NULL)
|
|
*data = k->pdata;
|
|
/*
|
|
@@ -840,7 +910,7 @@ __rte_hash_del_key_with_hash(const struc
|
|
bkt->signatures[i].sig != NULL_SIGNATURE) {
|
|
k = (struct rte_hash_key *) ((char *)keys +
|
|
bkt->key_idx[i] * h->key_entry_size);
|
|
- if (h->rte_hash_cmp_eq(key, k->key, h->key_len) == 0) {
|
|
+ if (rte_hash_cmp_eq(key, k->key, h) == 0) {
|
|
remove_entry(h, bkt, i);
|
|
|
|
/*
|
|
@@ -863,7 +933,7 @@ __rte_hash_del_key_with_hash(const struc
|
|
bkt->signatures[i].sig != NULL_SIGNATURE) {
|
|
k = (struct rte_hash_key *) ((char *)keys +
|
|
bkt->key_idx[i] * h->key_entry_size);
|
|
- if (h->rte_hash_cmp_eq(key, k->key, h->key_len) == 0) {
|
|
+ if (rte_hash_cmp_eq(key, k->key, h) == 0) {
|
|
remove_entry(h, bkt, i);
|
|
|
|
/*
|
|
@@ -980,7 +1050,7 @@ lookup_stage3(unsigned idx, const struct
|
|
unsigned hit;
|
|
unsigned key_idx;
|
|
|
|
- hit = !h->rte_hash_cmp_eq(key_slot->key, keys[idx], h->key_len);
|
|
+ hit = !rte_hash_cmp_eq(key_slot->key, keys[idx], h);
|
|
if (data != NULL)
|
|
data[idx] = key_slot->pdata;
|
|
|