+if (ent)
+rte_mempool_put(table->ext_ent_pool, ent);
+table->nb_ent--;
+return 0;
+}
+}
+
+SLIST_FOREACH(ent, &table->t[bucket].head, next)
+if (ent->key == key)
+break;
+
+if (ent == NULL)
+return -ENOENT;
+
+rte_atomic32_inc(&table->t[bucket].cnt);
+SLIST_REMOVE(&table->t[bucket].head, ent, rte_k32v64_ext_ent, next);
+rte_atomic32_inc(&table->t[bucket].cnt);
+rte_mempool_put(table->ext_ent_pool, ent);
+
+table->nb_ext_ent--;
+table->nb_ent--;
+
+return 0;
+}
+
+struct rte_k32v64_hash_table *
+rte_k32v64_hash_find_existing(const char *name)
+{
+struct rte_k32v64_hash_table *h = NULL;
+struct rte_tailq_entry *te;
+struct rte_k32v64_hash_list *k32v64_hash_list;
+
+k32v64_hash_list = RTE_TAILQ_CAST(rte_k32v64_hash_tailq.head,
+rte_k32v64_hash_list);
+
+rte_mcfg_tailq_read_lock();
+TAILQ_FOREACH(te, k32v64_hash_list, next) {
+h = (struct rte_k32v64_hash_table *) te->data;
+if (strncmp(name, h->name, RTE_K32V64_HASH_NAMESIZE) == 0)
+break;
+}
+rte_mcfg_tailq_read_unlock();
+if (te == NULL) {
+rte_errno = ENOENT;
+return NULL;
+}
+return h;
+}
+
+struct rte_k32v64_hash_table *
+rte_k32v64_hash_create(const struct rte_k32v64_hash_params *params)
+{
+char hash_name[RTE_K32V64_HASH_NAMESIZE];
+struct rte_k32v64_hash_table *ht = NULL;
+struct rte_tailq_entry *te;
+struct rte_k32v64_hash_list *k32v64_hash_list;
+uint32_t mem_size, nb_buckets, max_ent;
+int ret;
+struct rte_mempool *mp;
+
+if ((params == NULL) || (params->name == NULL) ||
+(params->entries == 0)) {
+rte_errno = EINVAL;
+return NULL;
+}
+
+k32v64_hash_list = RTE_TAILQ_CAST(rte_k32v64_hash_tailq.head,
+rte_k32v64_hash_list);
+
+ret = snprintf(hash_name, sizeof(hash_name), "K32V64_%s", params->name);
+if (ret < 0 || ret >= RTE_K32V64_HASH_NAMESIZE) {
+rte_errno = ENAMETOOLONG;
+return NULL;
+}
+
+max_ent = rte_align32pow2(params->entries);
+nb_buckets = max_ent / RTE_K32V64_KEYS_PER_BUCKET;
+mem_size = sizeof(struct rte_k32v64_hash_table) +
+sizeof(struct rte_k32v64_hash_bucket) * nb_buckets;
+
+mp = rte_mempool_create(hash_name, max_ent,
+sizeof(struct rte_k32v64_ext_ent), 0, 0, NULL, NULL, NULL, NULL,
+params->socket_id, 0);
+
+if (mp == NULL)
+return NULL;
+
+rte_mcfg_tailq_write_lock();
+TAILQ_FOREACH(te, k32v64_hash_list, next) {
+ht = (struct rte_k32v64_hash_table *) te->data;
+if (strncmp(params->name, ht->name,
+RTE_K32V64_HASH_NAMESIZE) == 0)
+break;
+}
+ht = NULL;
+if (te != NULL) {
+rte_errno = EEXIST;
+rte_mempool_free(mp);
+goto exit;
+}
+
+te = rte_zmalloc("K32V64_HASH_TAILQ_ENTRY", sizeof(*te), 0);
+if (te == NULL) {
+RTE_LOG(ERR, HASH, "Failed to allocate tailq entry\n");
+rte_mempool_free(mp);
+goto exit;
+}
+
+ht = rte_zmalloc_socket(hash_name, mem_size,
+RTE_CACHE_LINE_SIZE, params->socket_id);
+if (ht == NULL) {
+RTE_LOG(ERR, HASH, "Failed to allocate fbk hash table\n");
+rte_free(te);
+rte_mempool_free(mp);
+goto exit;
+}
+
+memcpy(ht->name, hash_name, sizeof(ht->name));
+ht->max_ent = max_ent;
+ht->bucket_msk = nb_buckets - 1;
+ht->ext_ent_pool = mp;
+ht->lookup = get_lookup_bulk_fn();
+
+te->data = (void *)ht;
+TAILQ_INSERT_TAIL(k32v64_hash_list, te, next);
+
+exit:
+rte_mcfg_tailq_write_unlock();
+
+return ht;
+}
+
+void
+rte_k32v64_hash_free(struct rte_k32v64_hash_table *ht)
+{
+struct rte_tailq_entry *te;
+struct rte_k32v64_hash_list *k32v64_hash_list;
+
+if (ht == NULL)
+return;
+
+k32v64_hash_list = RTE_TAILQ_CAST(rte_k32v64_hash_tailq.head,
+rte_k32v64_hash_list);
+
+rte_mcfg_tailq_write_lock();
+
+/* find out tailq entry */
+TAILQ_FOREACH(te, k32v64_hash_list, next) {
+if (te->data == (void *) ht)
+break;
+}
+
+
+if (te == NULL) {
+rte_mcfg_tailq_write_unlock();
+return;
+}
+
+TAILQ_REMOVE(k32v64_hash_list, te, next);
+
+rte_mcfg_tailq_write_unlock();
+
+rte_mempool_free(ht->ext_ent_pool);
+rte_free(ht);
+rte_free(te);
+}
diff --git a/lib/librte_hash/rte_k32v64_hash.h
b/lib/librte_hash/rte_k32v64_hash.h
new file mode 100644
index 0000000..b2c52e9
--- /dev/null
+++ b/lib/librte_hash/rte_k32v64_hash.h
@@ -0,0 +1,211 @@
+/* SPDX-License-Identifier: BSD-3-Clause
+ * Copyright(c) 2020 Intel Corporation
+ */
+
+#ifndef _RTE_K32V64_HASH_H_
+#define _RTE_K32V64_HASH_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <rte_compat.h>
+#include <rte_atomic.h>
+#include <rte_mempool.h>
+
+#define RTE_K32V64_HASH_NAMESIZE32
+#define RTE_K32V64_KEYS_PER_BUCKET4
+#define RTE_K32V64_WRITE_IN_PROGRESS1
+
+struct rte_k32v64_hash_params {
+const char *name;
+uint32_t entries;
+int socket_id;
+};
+
+struct rte_k32v64_ext_ent {
+SLIST_ENTRY(rte_k32v64_ext_ent) next;
+uint32_tkey;
+uint64_tval;
+};
+
+struct rte_k32v64_hash_bucket {
+uint32_tkey[RTE_K32V64_KEYS_PER_BUCKET];
+uint64_tval[RTE_K32V64_KEYS_PER_BUCKET];
+uint8_tkey_mask;
+rte_atomic32_tcnt;
+SLIST_HEAD(rte_k32v64_list_head, rte_k32v64_ext_ent) head;
+} __rte_cache_aligned;
+
+struct rte_k32v64_hash_table;
+
+typedef int (*rte_k32v64_hash_bulk_lookup_t)
+(struct rte_k32v64_hash_table *table, uint32_t *keys, uint32_t *hashes,
+uint64_t *values, unsigned int n);
+
+struct rte_k32v64_hash_table {
+char name[RTE_K32V64_HASH_NAMESIZE];/**< Name of the hash. */
+uint32_tnb_ent;/**< Number of entities in the table*/
+uint32_tnb_ext_ent;/**< Number of extended entities */
+uint32_tmax_ent;/**< Maximum number of entities */
+uint32_tbucket_msk;
+struct rte_mempool*ext_ent_pool;
+rte_k32v64_hash_bulk_lookup_tlookup;
+__extension__ struct rte_k32v64_hash_buckett[0];
+};
+
+typedef int (*rte_k32v64_cmp_fn_t)
+(struct rte_k32v64_hash_bucket *bucket, uint32_t key, uint64_t *val);
+
+static inline int
+__k32v64_cmp_keys(struct rte_k32v64_hash_bucket *bucket, uint32_t key,
+uint64_t *val)
+{
+int i;
+
+for (i = 0; i < RTE_K32V64_KEYS_PER_BUCKET; i++) {
+if ((key == bucket->key[i]) &&
+(bucket->key_mask & (1 << i))) {
+*val = bucket->val[i];
+return 1;
+}
+}
+
+return 0;
+}
+
+static inline int
+__k32v64_hash_lookup(struct rte_k32v64_hash_table *table, uint32_t key,
+uint32_t hash, uint64_t *value, rte_k32v64_cmp_fn_t cmp_f)
+{
+uint64_tval = 0;
+struct rte_k32v64_ext_ent *ent;
+int32_tcnt;
+int found = 0;
+uint32_t bucket = hash & table->bucket_msk;
+
+do {
+do
+cnt = rte_atomic32_read(&table->t[bucket].cnt);
+while (unlikely(cnt & RTE_K32V64_WRITE_IN_PROGRESS));
+
+found = cmp_f(&table->t[bucket], key, &val);
+if (unlikely((found == 0) &&
+(!SLIST_EMPTY(&table->t[bucket].head)))) {
+SLIST_FOREACH(ent, &table->t[bucket].head, next) {
+if (ent->key == key) {
+val = ent->val;
+found = 1;
+break;
+}
+}
+}
+
+} while (unlikely(cnt != rte_atomic32_read(&table->t[bucket].cnt)));
