hash: add bulk lookup with signatures array
[dpdk.git] / lib / librte_hash / rte_cuckoo_hash.c
index 6af8ca4..38767a8 100644 (file)
@@ -1711,64 +1711,20 @@ compare_signatures(uint32_t *prim_hash_matches, uint32_t *sec_hash_matches,
        }
 }
 
-#define PREFETCH_OFFSET 4
 static inline void
-__rte_hash_lookup_bulk_l(const struct rte_hash *h, const void **keys,
-                       int32_t num_keys, int32_t *positions,
-                       uint64_t *hit_mask, void *data[])
+__bulk_lookup_l(const struct rte_hash *h, const void **keys,
+               const struct rte_hash_bucket **primary_bkt,
+               const struct rte_hash_bucket **secondary_bkt,
+               uint16_t *sig, int32_t num_keys, int32_t *positions,
+               uint64_t *hit_mask, void *data[])
 {
        uint64_t hits = 0;
        int32_t i;
        int32_t ret;
-       uint32_t prim_hash[RTE_HASH_LOOKUP_BULK_MAX];
-       uint32_t prim_index[RTE_HASH_LOOKUP_BULK_MAX];
-       uint32_t sec_index[RTE_HASH_LOOKUP_BULK_MAX];
-       uint16_t sig[RTE_HASH_LOOKUP_BULK_MAX];
-       const struct rte_hash_bucket *primary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
-       const struct rte_hash_bucket *secondary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
        uint32_t prim_hitmask[RTE_HASH_LOOKUP_BULK_MAX] = {0};
        uint32_t sec_hitmask[RTE_HASH_LOOKUP_BULK_MAX] = {0};
        struct rte_hash_bucket *cur_bkt, *next_bkt;
 
-       /* Prefetch first keys */
-       for (i = 0; i < PREFETCH_OFFSET && i < num_keys; i++)
-               rte_prefetch0(keys[i]);
-
-       /*
-        * Prefetch rest of the keys, calculate primary and
-        * secondary bucket and prefetch them
-        */
-       for (i = 0; i < (num_keys - PREFETCH_OFFSET); i++) {
-               rte_prefetch0(keys[i + PREFETCH_OFFSET]);
-
-               prim_hash[i] = rte_hash_hash(h, keys[i]);
-
-               sig[i] = get_short_sig(prim_hash[i]);
-               prim_index[i] = get_prim_bucket_index(h, prim_hash[i]);
-               sec_index[i] = get_alt_bucket_index(h, prim_index[i], sig[i]);
-
-               primary_bkt[i] = &h->buckets[prim_index[i]];
-               secondary_bkt[i] = &h->buckets[sec_index[i]];
-
-               rte_prefetch0(primary_bkt[i]);
-               rte_prefetch0(secondary_bkt[i]);
-       }
-
-       /* Calculate and prefetch rest of the buckets */
-       for (; i < num_keys; i++) {
-               prim_hash[i] = rte_hash_hash(h, keys[i]);
-
-               sig[i] = get_short_sig(prim_hash[i]);
-               prim_index[i] = get_prim_bucket_index(h, prim_hash[i]);
-               sec_index[i] = get_alt_bucket_index(h, prim_index[i], sig[i]);
-
-               primary_bkt[i] = &h->buckets[prim_index[i]];
-               secondary_bkt[i] = &h->buckets[sec_index[i]];
-
-               rte_prefetch0(primary_bkt[i]);
-               rte_prefetch0(secondary_bkt[i]);
-       }
-
        __hash_rw_reader_lock(h);
 
        /* Compare signatures and prefetch key slot of first hit */
@@ -1903,63 +1859,20 @@ next_key:
 }
 
 static inline void
-__rte_hash_lookup_bulk_lf(const struct rte_hash *h, const void **keys,
-                       int32_t num_keys, int32_t *positions,
-                       uint64_t *hit_mask, void *data[])
+__bulk_lookup_lf(const struct rte_hash *h, const void **keys,
+               const struct rte_hash_bucket **primary_bkt,
+               const struct rte_hash_bucket **secondary_bkt,
+               uint16_t *sig, int32_t num_keys, int32_t *positions,
+               uint64_t *hit_mask, void *data[])
 {
        uint64_t hits = 0;
        int32_t i;
        int32_t ret;
-       uint32_t prim_hash[RTE_HASH_LOOKUP_BULK_MAX];
-       uint32_t prim_index[RTE_HASH_LOOKUP_BULK_MAX];
-       uint32_t sec_index[RTE_HASH_LOOKUP_BULK_MAX];
-       uint16_t sig[RTE_HASH_LOOKUP_BULK_MAX];
-       const struct rte_hash_bucket *primary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
-       const struct rte_hash_bucket *secondary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
        uint32_t prim_hitmask[RTE_HASH_LOOKUP_BULK_MAX] = {0};
        uint32_t sec_hitmask[RTE_HASH_LOOKUP_BULK_MAX] = {0};
        struct rte_hash_bucket *cur_bkt, *next_bkt;
        uint32_t cnt_b, cnt_a;
 
-       /* Prefetch first keys */
-       for (i = 0; i < PREFETCH_OFFSET && i < num_keys; i++)
-               rte_prefetch0(keys[i]);
-
-       /*
-        * Prefetch rest of the keys, calculate primary and
-        * secondary bucket and prefetch them
-        */
-       for (i = 0; i < (num_keys - PREFETCH_OFFSET); i++) {
-               rte_prefetch0(keys[i + PREFETCH_OFFSET]);
-
-               prim_hash[i] = rte_hash_hash(h, keys[i]);
-
-               sig[i] = get_short_sig(prim_hash[i]);
-               prim_index[i] = get_prim_bucket_index(h, prim_hash[i]);
-               sec_index[i] = get_alt_bucket_index(h, prim_index[i], sig[i]);
-
-               primary_bkt[i] = &h->buckets[prim_index[i]];
-               secondary_bkt[i] = &h->buckets[sec_index[i]];
-
-               rte_prefetch0(primary_bkt[i]);
-               rte_prefetch0(secondary_bkt[i]);
-       }
-
-       /* Calculate and prefetch rest of the buckets */
-       for (; i < num_keys; i++) {
-               prim_hash[i] = rte_hash_hash(h, keys[i]);
-
-               sig[i] = get_short_sig(prim_hash[i]);
-               prim_index[i] = get_prim_bucket_index(h, prim_hash[i]);
-               sec_index[i] = get_alt_bucket_index(h, prim_index[i], sig[i]);
-
-               primary_bkt[i] = &h->buckets[prim_index[i]];
-               secondary_bkt[i] = &h->buckets[sec_index[i]];
-
-               rte_prefetch0(primary_bkt[i]);
-               rte_prefetch0(secondary_bkt[i]);
-       }
-
        for (i = 0; i < num_keys; i++)
                positions[i] = -ENOENT;
 
@@ -2124,6 +2037,92 @@ next_key:
                *hit_mask = hits;
 }
 
+#define PREFETCH_OFFSET 4
+static inline void
+__bulk_lookup_prefetching_loop(const struct rte_hash *h,
+       const void **keys, int32_t num_keys,
+       uint16_t *sig,
+       const struct rte_hash_bucket **primary_bkt,
+       const struct rte_hash_bucket **secondary_bkt)
+{
+       int32_t i;
+       uint32_t prim_hash[RTE_HASH_LOOKUP_BULK_MAX];
+       uint32_t prim_index[RTE_HASH_LOOKUP_BULK_MAX];
+       uint32_t sec_index[RTE_HASH_LOOKUP_BULK_MAX];
+
+       /* Prefetch first keys */
+       for (i = 0; i < PREFETCH_OFFSET && i < num_keys; i++)
+               rte_prefetch0(keys[i]);
+
+       /*
+        * Prefetch rest of the keys, calculate primary and
+        * secondary bucket and prefetch them
+        */
+       for (i = 0; i < (num_keys - PREFETCH_OFFSET); i++) {
+               rte_prefetch0(keys[i + PREFETCH_OFFSET]);
+
+               prim_hash[i] = rte_hash_hash(h, keys[i]);
+
+               sig[i] = get_short_sig(prim_hash[i]);
+               prim_index[i] = get_prim_bucket_index(h, prim_hash[i]);
+               sec_index[i] = get_alt_bucket_index(h, prim_index[i], sig[i]);
+
+               primary_bkt[i] = &h->buckets[prim_index[i]];
+               secondary_bkt[i] = &h->buckets[sec_index[i]];
+
+               rte_prefetch0(primary_bkt[i]);
+               rte_prefetch0(secondary_bkt[i]);
+       }
+
+       /* Calculate and prefetch rest of the buckets */
+       for (; i < num_keys; i++) {
+               prim_hash[i] = rte_hash_hash(h, keys[i]);
+
+               sig[i] = get_short_sig(prim_hash[i]);
+               prim_index[i] = get_prim_bucket_index(h, prim_hash[i]);
+               sec_index[i] = get_alt_bucket_index(h, prim_index[i], sig[i]);
+
+               primary_bkt[i] = &h->buckets[prim_index[i]];
+               secondary_bkt[i] = &h->buckets[sec_index[i]];
+
+               rte_prefetch0(primary_bkt[i]);
+               rte_prefetch0(secondary_bkt[i]);
+       }
+}
+
+
+static inline void
+__rte_hash_lookup_bulk_l(const struct rte_hash *h, const void **keys,
+                       int32_t num_keys, int32_t *positions,
+                       uint64_t *hit_mask, void *data[])
+{
+       uint16_t sig[RTE_HASH_LOOKUP_BULK_MAX];
+       const struct rte_hash_bucket *primary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
+       const struct rte_hash_bucket *secondary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
+
+       __bulk_lookup_prefetching_loop(h, keys, num_keys, sig,
+               primary_bkt, secondary_bkt);
+
+       __bulk_lookup_l(h, keys, primary_bkt, secondary_bkt, sig, num_keys,
+               positions, hit_mask, data);
+}
+
+static inline void
+__rte_hash_lookup_bulk_lf(const struct rte_hash *h, const void **keys,
+                       int32_t num_keys, int32_t *positions,
+                       uint64_t *hit_mask, void *data[])
+{
+       uint16_t sig[RTE_HASH_LOOKUP_BULK_MAX];
+       const struct rte_hash_bucket *primary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
+       const struct rte_hash_bucket *secondary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
+
+       __bulk_lookup_prefetching_loop(h, keys, num_keys, sig,
+               primary_bkt, secondary_bkt);
+
+       __bulk_lookup_lf(h, keys, primary_bkt, secondary_bkt, sig, num_keys,
+               positions, hit_mask, data);
+}
+
 static inline void
 __rte_hash_lookup_bulk(const struct rte_hash *h, const void **keys,
                        int32_t num_keys, int32_t *positions,
@@ -2165,6 +2164,123 @@ rte_hash_lookup_bulk_data(const struct rte_hash *h, const void **keys,
        return __builtin_popcountl(*hit_mask);
 }
 
+
+static inline void
+__rte_hash_lookup_with_hash_bulk_l(const struct rte_hash *h,
+                       const void **keys, hash_sig_t *prim_hash,
+                       int32_t num_keys, int32_t *positions,
+                       uint64_t *hit_mask, void *data[])
+{
+       int32_t i;
+       uint32_t prim_index[RTE_HASH_LOOKUP_BULK_MAX];
+       uint32_t sec_index[RTE_HASH_LOOKUP_BULK_MAX];
+       uint16_t sig[RTE_HASH_LOOKUP_BULK_MAX];
+       const struct rte_hash_bucket *primary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
+       const struct rte_hash_bucket *secondary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
+
+       /*
+        * Prefetch keys, calculate primary and
+        * secondary bucket and prefetch them
+        */
+       for (i = 0; i < num_keys; i++) {
+               rte_prefetch0(keys[i]);
+
+               sig[i] = get_short_sig(prim_hash[i]);
+               prim_index[i] = get_prim_bucket_index(h, prim_hash[i]);
+               sec_index[i] = get_alt_bucket_index(h, prim_index[i], sig[i]);
+
+               primary_bkt[i] = &h->buckets[prim_index[i]];
+               secondary_bkt[i] = &h->buckets[sec_index[i]];
+
+               rte_prefetch0(primary_bkt[i]);
+               rte_prefetch0(secondary_bkt[i]);
+       }
+
+       __bulk_lookup_l(h, keys, primary_bkt, secondary_bkt, sig, num_keys,
+               positions, hit_mask, data);
+}
+
+static inline void
+__rte_hash_lookup_with_hash_bulk_lf(const struct rte_hash *h,
+                       const void **keys, hash_sig_t *prim_hash,
+                       int32_t num_keys, int32_t *positions,
+                       uint64_t *hit_mask, void *data[])
+{
+       int32_t i;
+       uint32_t prim_index[RTE_HASH_LOOKUP_BULK_MAX];
+       uint32_t sec_index[RTE_HASH_LOOKUP_BULK_MAX];
+       uint16_t sig[RTE_HASH_LOOKUP_BULK_MAX];
+       const struct rte_hash_bucket *primary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
+       const struct rte_hash_bucket *secondary_bkt[RTE_HASH_LOOKUP_BULK_MAX];
+
+       /*
+        * Prefetch keys, calculate primary and
+        * secondary bucket and prefetch them
+        */
+       for (i = 0; i < num_keys; i++) {
+               rte_prefetch0(keys[i]);
+
+               sig[i] = get_short_sig(prim_hash[i]);
+               prim_index[i] = get_prim_bucket_index(h, prim_hash[i]);
+               sec_index[i] = get_alt_bucket_index(h, prim_index[i], sig[i]);
+
+               primary_bkt[i] = &h->buckets[prim_index[i]];
+               secondary_bkt[i] = &h->buckets[sec_index[i]];
+
+               rte_prefetch0(primary_bkt[i]);
+               rte_prefetch0(secondary_bkt[i]);
+       }
+
+       __bulk_lookup_lf(h, keys, primary_bkt, secondary_bkt, sig, num_keys,
+               positions, hit_mask, data);
+}
+
+static inline void
+__rte_hash_lookup_with_hash_bulk(const struct rte_hash *h, const void **keys,
+                       hash_sig_t *prim_hash, int32_t num_keys,
+                       int32_t *positions, uint64_t *hit_mask, void *data[])
+{
+       if (h->readwrite_concur_lf_support)
+               __rte_hash_lookup_with_hash_bulk_lf(h, keys, prim_hash,
+                               num_keys, positions, hit_mask, data);
+       else
+               __rte_hash_lookup_with_hash_bulk_l(h, keys, prim_hash,
+                               num_keys, positions, hit_mask, data);
+}
+
+int
+rte_hash_lookup_with_hash_bulk(const struct rte_hash *h, const void **keys,
+               hash_sig_t *sig, uint32_t num_keys, int32_t *positions)
+{
+       RETURN_IF_TRUE(((h == NULL) || (keys == NULL) ||
+                       (sig == NULL) || (num_keys == 0) ||
+                       (num_keys > RTE_HASH_LOOKUP_BULK_MAX) ||
+                       (positions == NULL)), -EINVAL);
+
+       __rte_hash_lookup_with_hash_bulk(h, keys, sig, num_keys,
+               positions, NULL, NULL);
+       return 0;
+}
+
+int
+rte_hash_lookup_with_hash_bulk_data(const struct rte_hash *h,
+               const void **keys, hash_sig_t *sig,
+               uint32_t num_keys, uint64_t *hit_mask, void *data[])
+{
+       RETURN_IF_TRUE(((h == NULL) || (keys == NULL) ||
+                       (sig == NULL) || (num_keys == 0) ||
+                       (num_keys > RTE_HASH_LOOKUP_BULK_MAX) ||
+                       (hit_mask == NULL)), -EINVAL);
+
+       int32_t positions[num_keys];
+
+       __rte_hash_lookup_with_hash_bulk(h, keys, sig, num_keys,
+                       positions, hit_mask, data);
+
+       /* Return number of hits */
+       return __builtin_popcountl(*hit_mask);
+}
+
 int32_t
 rte_hash_iterate(const struct rte_hash *h, const void **key, void **data, uint32_t *next)
 {